dcase23-task2-enriched.py

import os
import json
import datasets
import datasets.info
import pandas as pd
import numpy as np
import tempfile
import requests
import io
from pathlib import Path
from datasets import load_dataset
from typing import Iterable, Dict, Optional, Union, List


_CITATION = """\
@dataset{kota_dohi_2023_7687464,
  author       = {Kota Dohi and
                  Keisuke and
                  Noboru and
                  Daisuke and
                  Yuma and
                  Tomoya and
                  Harsh and
                  Takashi and
                  Yohei},
  title        = {DCASE 2023 Challenge Task 2 Development Dataset},
  month        = mar,
  year         = 2023,
  publisher    = {Zenodo},
  version      = {1.0},
  doi          = {10.5281/zenodo.7687464},
  url          = {https://doi.org/10.5281/zenodo.7687464}
}
"""
_LICENSE = "Creative Commons Attribution 4.0 International Public License"

_METADATA_REG = r"attributes_\d+.csv"

_NUM_TARGETS = 2
_NUM_CLASSES = 7

_TARGET_NAMES = ["normal", "anomaly"]
_CLASS_NAMES = ["gearbox", "fan", "bearing", "slider", "ToyCar", "ToyTrain", "valve"]

_HOMEPAGE = {
    "dev": "https://zenodo.org/record/7687464#.Y_96q9LMLmH",
    "add": "",
    "eval": "",
}

DATA_URLS = {
    "dev": {
        "train": "data/dev_train.tar.gz",
        "test": "data/dev_test.tar.gz",
        "metadata": "data/dev_metadata.csv",
    },
    "add":  {
        "train": "data/add_train.tar.gz",
        "test": "data/add_test.tar.gz",
        "metadata": "data/add_metadata.csv",
    },
    "eval": {
        "test": "data/eval_test.tar.gz",
        "metadata": "data/eval_metadata.csv",
    },
}

EMBEDDING_URLS = {
    "dev": {
        "ast-finetuned-audioset-10-10-0.4593-embeddings": {
            "train": "data/MIT_ast-finetuned-audioset-10-10-0-4593-embeddings_dev_train.npz",
            "test": "data/MIT_ast-finetuned-audioset-10-10-0-4593-embeddings_dev_test.npz",
            "size": (1, 768),
            "dtype": "float32",
        },
    },
    "add":  {
        "ast-finetuned-audioset-10-10-0.4593-embeddings": {
            "train": "",
            "test": "",
        },
    },
    "eval": {
        "ast-finetuned-audioset-10-10-0.4593-embeddings": {
            "train": "",
            "test": "",
        },
    },
}

STATS = {
    "name": "Enriched Dataset of 'DCASE 2023 Challenge Task 2'",
    "configs": {
        'dev': {
            'date': "Mar 1, 2023",
            'version': "1.0.0",
            'homepage': "https://zenodo.org/record/7687464#.ZABmANLMLmH",
            "splits": ["train", "test"],
        },
        # 'add': {
        #     'date': None,
        #     'version': "0.0.0",
        #     'homepage': None,
        #     "splits": ["train", "test"],
        # },
        # 'eval': {
        #     'date': None,
        #     'version': "0.0.0",
        #     'homepage': None,
        #     "splits": ["test"],
        # },
    }
}

DATASET = {
    'dev': 'DCASE 2023 Challenge Task 2 Development Dataset',
    'add': 'DCASE 2023 Challenge Task 2 Additional Train Dataset',
    'eval': 'DCASE 2023 Challenge Task 2 Evaluation Dataset',
}


SPOTLIGHT_LAYOUTS = {
    "standard": {
      "orientation": "vertical",
      "children": [
        {
          "kind": "split",
          "weight": 51.96463654223969,
          "orientation": "horizontal",
          "children": [
            {
              "kind": "tab",
              "weight": 30,
              "children": [
                {
                  "kind": "widget",
                  "name": "Table",
                  "type": "table",
                  "config": {
                    "tableView": "full",
                    "visibleColumns": [
                      "class",
                      "class_name",
                      "config",
                      "d1p",
                      "d1v",
                      "d2p",
                      "d2v",
                      "d3p",
                      "d3v",
                      "file_path",
                      "label",
                      "section",
                      "split"
                    ],
                    "sorting": None,
                    "orderByRelevance": False
                  }
                }
              ]
            },
            {
              "kind": "tab",
              "weight": 33.970588235294116,
              "children": [
                {
                  "kind": "widget",
                  "name": "Similarity Map (2)",
                  "type": "similaritymap",
                  "config": {
                    "umapNNeighbors": 20,
                    "umapMinDist": 0.15,
                    "colorBy": "label"
                  }
                }
              ]
            },
            {
              "kind": "tab",
              "weight": 36.029411764705884,
              "children": [
                {
                  "kind": "widget",
                  "name": "Similarity Map",
                  "type": "similaritymap",
                  "config": {
                    "placeBy": None,
                    "reductionMethod": None,
                    "colorBy": "class_name",
                    "sizeBy": None,
                    "filter": False,
                    "umapNNeighbors": 20,
                    "umapMetric": None,
                    "umapMinDist": 0.15,
                    "pcaNormalization": None,
                    "umapMenuLocalGlobalBalance": None,
                    "umapMenuIsAdvanced": False
                  }
                },
                {
                  "kind": "widget",
                  "name": "Scatter Plot",
                  "type": "scatterplot",
                  "config": {
                    "xAxisColumn": None,
                    "yAxisColumn": None,
                    "colorBy": None,
                    "sizeBy": None,
                    "filter": False
                  }
                },
                {
                  "kind": "widget",
                  "name": "Histogram",
                  "type": "histogram",
                  "config": {
                    "columnKey": None,
                    "stackByColumnKey": None,
                    "filter": False
                  }
                }
              ]
            }
          ]
        },
        {
          "kind": "tab",
          "weight": 48.03536345776031,
          "children": [
            {
              "kind": "widget",
              "name": "Inspector",
              "type": "inspector",
              "config": {
                "views": [
                  {
                    "view": "AudioView",
                    "columns": [
                      "audio"
                    ],
                    "name": "view",
                    "key": "9c37fe2d-6305-436b-b944-30dbda7b1f4d"
                  },
                  {
                    "view": "SpectrogramView",
                    "columns": [
                      "audio"
                    ],
                    "name": "view",
                    "key": "9e676bb9-0b21-4214-806f-4e8c0f6db4c3"
                  }
                ],
                "visibleColumns": 4
              }
            }
          ]
        }
      ]
    },
}

SPOTLIGHT_RENAME = {
    "audio": "original_audio",
    "path": "audio",
}


class DCASE2023Task2DatasetConfig(datasets.BuilderConfig):
    """BuilderConfig for DCASE2023Task2Dataset."""

    def __init__(self, name, version, **kwargs):
        self.release_date = kwargs.pop("release_date", None)
        self.homepage = kwargs.pop("homepage", None)
        self.data_urls = kwargs.pop("data_urls", None)
        self.embeddings_urls = kwargs.pop("embeddings_urls", None)
        self.splits = kwargs.pop("splits", None)
        self.rename = kwargs.pop("rename", None)
        self.layout = kwargs.pop("layout", None)
        description = (
            f"Dataset for the DCASE 2023 Challenge Task 2 'First-Shot Unsupervised Anomalous Sound Detection "
            f"for Machine Condition Monitoring'. released on {self.release_date}. Original data available under"
            f"{self.homepage}. "
            f"CONFIG: {name}."
        )
        super(DCASE2023Task2DatasetConfig, self).__init__(
            name=name,
            version=datasets.Version(version),
            description=description,
        )

    def to_spotlight(self, data: Union[pd.DataFrame, datasets.Dataset]) -> pd.DataFrame:

        def get_split(path: str) -> str:
            fn = os.path.basename(path)
            if "train" in fn:
                return "train"
            elif "test" in fn:
                return "test"
            else:
                raise NotImplementedError

        if type(data) == datasets.Dataset:
            # retrieve split
            df = data.to_pandas()
            df["split"] = data.split._name if "+" not in data.split._name else df["path"].map(get_split)
            df["config"] = data.config_name

            # get clearnames for classes
            class_names = data.features["class"].names
            df["class_name"] = df["class"].apply(lambda x: class_names[x])
        elif type(data) == pd.DataFrame:
            df = data
        else:
            raise TypeError("type(data) not in Union[pd.DataFrame, datasets.Dataset]")

        df["file_path"] = df["path"]
        df.rename(columns=self.rename, inplace=True)

        return df.copy()

    def get_layout(self, config: str = "standard") -> str:
        layout_json = tempfile.mktemp(".json")
        with open(layout_json, "w") as outfile:
            json.dump(self.layout[config], outfile)

        return layout_json


class DCASE2023Task2Dataset(datasets.GeneratorBasedBuilder):
    """Dataset for the DCASE 2023 Challenge Task 2 "First-Shot Unsupervised Anomalous Sound Detection
    for Machine Condition Monitoring"."""

    VERSION = datasets.Version("0.0.4")

    DEFAULT_CONFIG_NAME = "dev"

    BUILDER_CONFIGS = [
        DCASE2023Task2DatasetConfig(
            name=key,
            version=stats["version"],
            dataset=DATASET[key],
            homepage=_HOMEPAGE[key],
            data_urls=DATA_URLS[key],
            embeddings_urls=EMBEDDING_URLS[key],
            release_date=stats["date"],
            splits=stats["splits"],
            layout=SPOTLIGHT_LAYOUTS,
            rename=SPOTLIGHT_RENAME,
        )
        for key, stats in STATS["configs"].items()
    ]

    def _info(self):
        features = {
                    "audio": datasets.Audio(sampling_rate=16_000),
                    "path": datasets.Value("string"),
                    "section": datasets.Value("uint32"),
                    "domain": datasets.ClassLabel(num_classes=2, names=["source", "target"]),
                    "label": datasets.ClassLabel(num_classes=_NUM_TARGETS, names=_TARGET_NAMES),
                    "class": datasets.ClassLabel(num_classes=_NUM_CLASSES, names=_CLASS_NAMES),
                    "d1p": datasets.Value("string"),
                    "d1v": datasets.Value("string"),
                    "d2p": datasets.Value("string"),
                    "d2v": datasets.Value("string"),
                    "d3p": datasets.Value("string"),
                    "d3v": datasets.Value("string"),
                }
        if self.config.embeddings_urls is not None:
            features.update({
                emb_name: [datasets.Value(emb["dtype"])] for emb_name, emb in self.config.embeddings_urls.items()
            })
        features = datasets.Features(features)

        return datasets.DatasetInfo(
            # This is the description that will appear on the datasets page.
            description=self.config.description,
            features=features,
            supervised_keys=datasets.info.SupervisedKeysData("label"),
            homepage=self.config.homepage,
            license=_LICENSE,
            citation=_CITATION,
        )

    def _split_generators(
            self,
            dl_manager: datasets.DownloadManager
    ):
        """Returns SplitGenerators."""
        dl_manager.download_config.ignore_url_params = True
        audio_path = {}
        local_extracted_archive = {}
        split_type = {"train": datasets.Split.TRAIN, "test": datasets.Split.TEST}
        embeddings = {split: dict() for split in split_type}

        for split in split_type:
            if split in self.config.splits:
                audio_path[split] = dl_manager.download(self.config.data_urls[split])
                local_extracted_archive[split] = dl_manager.extract(
                    audio_path[split]) if not dl_manager.is_streaming else None
                if self.config.embeddings_urls is not None:
                    for emb_name, emb_data in self.config.embeddings_urls.items():
                        downloaded_embeddings = dl_manager.download(emb_data[split])
                        if dl_manager.is_streaming:
                            response = requests.get(downloaded_embeddings)
                            response.raise_for_status()
                            downloaded_embeddings = io.BytesIO(response.content)
                        npz_file = np.load(downloaded_embeddings, allow_pickle=True)
                        embeddings[split][emb_name] = npz_file["arr_0"].item()

        return [
            datasets.SplitGenerator(
                name=split_type[split],
                gen_kwargs={
                    "split": split,
                    "local_extracted_archive": local_extracted_archive[split],
                    "audio_files": dl_manager.iter_archive(audio_path[split]),
                    "embeddings": embeddings[split],
                    "metadata_file": dl_manager.download_and_extract(self.config.data_urls["metadata"]),
                },
            ) for split in split_type if split in self.config.splits
        ]

    def _generate_examples(
        self,
        split: str,
        local_extracted_archive: Union[Dict, List],
        audio_files: Optional[Iterable],
        embeddings: Optional[Dict],
        metadata_file: Optional[str],
    ):
        """Yields examples."""
        metadata = pd.read_csv(metadata_file)
        data_fields = list(self._info().features.keys())

        id_ = 0
        for path, f in audio_files:
            lookup = Path(path).parent.name + "/" + Path(path).name
            if lookup in metadata["path"].values:
                path = os.path.join(local_extracted_archive, path) if local_extracted_archive else path
                audio = {"path": path, "bytes": f.read()}
                result = {field: None for field in data_fields}
                result.update(metadata[metadata["path"] == lookup].T.squeeze().to_dict())
                for emb_key in embeddings.keys():
                    result[emb_key] = np.asarray(embeddings[emb_key][lookup]).squeeze().tolist()
                result["path"] = path
                yield id_, {**result, "audio": audio}
                id_ += 1


if __name__ == "__main__":
    ds = load_dataset("dcase23-task2-enriched.py", "dev", split="train", streaming=True)