Upload data

data/IEMOCAP_full_release.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:99da5de585066b100f2a16b8960a350a6620fa2487f1127e969198f7d7f9bcba
+size 1209515

data/LibriSpeech-test-clean.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a59633668a54ac2fbd99283afa291be3c3db130a1cf36687e18d8876db9f2df1
+size 626257

data/VoxCeleb1.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:539e1de8d0158ab7cb7fbb7dd793bab99bada17319038e31bccfbed16c9b2219
+size 1512582

data/fluent_speech_commands_dataset.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9d0ef6e970baffb1b6ca6f370c07240bdcd0dd32b1436426fa025019c00d9894
+size 494518

data/speech_commands_test_set_v0.01.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:026ed5d467c50a07dec3ada87a9d833ba9d21cd7367721d3dcb08a28482d4c06
+size 211385

superb_demo.py

@@ -0,0 +1,423 @@
+# coding=utf-8
+# Copyright 2021 The TensorFlow Datasets Authors and the HuggingFace Datasets Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Lint as: python3
+"""SUPERB: Speech processing Universal PERformance Benchmark."""
+
+import csv
+import glob
+import os
+import textwrap
+
+import datasets
+from datasets.tasks import AutomaticSpeechRecognition
+
+_CITATION = """\
+@article{DBLP:journals/corr/abs-2105-01051,
+  author    = {Shu{-}Wen Yang and
+               Po{-}Han Chi and
+               Yung{-}Sung Chuang and
+               Cheng{-}I Jeff Lai and
+               Kushal Lakhotia and
+               Yist Y. Lin and
+               Andy T. Liu and
+               Jiatong Shi and
+               Xuankai Chang and
+               Guan{-}Ting Lin and
+               Tzu{-}Hsien Huang and
+               Wei{-}Cheng Tseng and
+               Ko{-}tik Lee and
+               Da{-}Rong Liu and
+               Zili Huang and
+               Shuyan Dong and
+               Shang{-}Wen Li and
+               Shinji Watanabe and
+               Abdelrahman Mohamed and
+               Hung{-}yi Lee},
+  title     = {{SUPERB:} Speech processing Universal PERformance Benchmark},
+  journal   = {CoRR},
+  volume    = {abs/2105.01051},
+  year      = {2021},
+  url       = {https://arxiv.org/abs/2105.01051},
+  archivePrefix = {arXiv},
+  eprint    = {2105.01051},
+  timestamp = {Thu, 01 Jul 2021 13:30:22 +0200},
+  biburl    = {https://dblp.org/rec/journals/corr/abs-2105-01051.bib},
+  bibsource = {dblp computer science bibliography, https://dblp.org}
+}
+"""
+
+_DESCRIPTION = """\
+Self-supervised learning (SSL) has proven vital for advancing research in
+natural language processing (NLP) and computer vision (CV). The paradigm
+pretrains a shared model on large volumes of unlabeled data and achieves
+state-of-the-art (SOTA) for various tasks with minimal adaptation. However, the
+speech processing community lacks a similar setup to systematically explore the
+paradigm. To bridge this gap, we introduce Speech processing Universal
+PERformance Benchmark (SUPERB). SUPERB is a leaderboard to benchmark the
+performance of a shared model across a wide range of speech processing tasks
+with minimal architecture changes and labeled data. Among multiple usages of the
+shared model, we especially focus on extracting the representation learned from
+SSL due to its preferable re-usability. We present a simple framework to solve
+SUPERB tasks by learning task-specialized lightweight prediction heads on top of
+the frozen shared model. Our results demonstrate that the framework is promising
+as SSL representations show competitive generalizability and accessibility
+across SUPERB tasks. We release SUPERB as a challenge with a leaderboard and a
+benchmark toolkit to fuel the research in representation learning and general
+speech processing.
+
+Note that in order to limit the required storage for preparing this dataset, the
+audio is stored in the .flac format and is not converted to a float32 array. To
+convert, the audio file to a float32 array, please make use of the `.map()`
+function as follows:
+
+
+```python
+import soundfile as sf
+
+def map_to_array(batch):
+    speech_array, _ = sf.read(batch["file"])
+    batch["speech"] = speech_array
+    return batch
+
+dataset = dataset.map(map_to_array, remove_columns=["file"])
+```
+"""
+
+
+class SuperbConfig(datasets.BuilderConfig):
+    """BuilderConfig for Superb."""
+
+    def __init__(
+            self,
+            features,
+            url,
+            data_url=None,
+            supervised_keys=None,
+            task_templates=None,
+            **kwargs,
+    ):
+        super().__init__(version=datasets.Version("1.9.0", ""), **kwargs)
+        self.features = features
+        self.data_url = data_url
+        self.url = url
+        self.supervised_keys = supervised_keys
+        self.task_templates = task_templates
+
+
+class Superb(datasets.GeneratorBasedBuilder):
+    """Superb dataset."""
+
+    BUILDER_CONFIGS = [
+        SuperbConfig(
+            name="asr",
+            description=textwrap.dedent(
+                """\
+            ASR transcribes utterances into words. While PR analyzes the
+            improvement in modeling phonetics, ASR reflects the significance of
+            the improvement in a real-world scenario. LibriSpeech
+            train-clean-100/dev-clean/test-clean subsets are used for
+            training/validation/testing. The evaluation metric is word error
+            rate (WER)."""
+            ),
+            features=datasets.Features(
+                {
+                    "file": datasets.Value("string"),
+                    "text": datasets.Value("string"),
+                    "speaker_id": datasets.Value("int64"),
+                    "chapter_id": datasets.Value("int64"),
+                    "id": datasets.Value("string"),
+                }
+            ),
+            supervised_keys=("file", "text"),
+            url="http://www.openslr.org/12",
+            data_url="data/LibriSpeech-test-clean.zip",
+            task_templates=[AutomaticSpeechRecognition(audio_file_path_column="file", transcription_column="text")],
+        ),
+        SuperbConfig(
+            name="ks",
+            description=textwrap.dedent(
+                """\
+            Keyword Spotting (KS) detects preregistered keywords by classifying utterances into a predefined set of
+            words. The task is usually performed on-device for the fast response time. Thus, accuracy, model size, and
+            inference time are all crucial. SUPERB uses the widely used Speech Commands dataset v1.0 for the task.
+            The dataset consists of ten classes of keywords, a class for silence, and an unknown class to include the
+            false positive. The evaluation metric is accuracy (ACC)"""
+            ),
+            features=datasets.Features(
+                {
+                    "file": datasets.Value("string"),
+                    "label": datasets.ClassLabel(
+                        names=[
+                            "yes",
+                            "no",
+                            "up",
+                            "down",
+                            "left",
+                            "right",
+                            "on",
+                            "off",
+                            "stop",
+                            "go",
+                            "_silence_",
+                            "_unknown_",
+                        ]
+                    ),
+                }
+            ),
+            supervised_keys=("file", "label"),
+            url="https://www.tensorflow.org/datasets/catalog/speech_commands",
+            data_url="data/speech_commands_test_set_v0.01.zip",
+        ),
+        SuperbConfig(
+            name="ic",
+            description=textwrap.dedent(
+                """\
+            Intent Classification (IC) classifies utterances into predefined classes to determine the intent of
+            speakers. SUPERB uses the Fluent Speech Commands dataset, where each utterance is tagged with three intent
+            labels: action, object, and location. The evaluation metric is accuracy (ACC)."""
+            ),
+            features=datasets.Features(
+                {
+                    "file": datasets.Value("string"),
+                    "speaker_id": datasets.Value("string"),
+                    "text": datasets.Value("string"),
+                    "action": datasets.ClassLabel(
+                        names=["activate", "bring", "change language", "deactivate", "decrease", "increase"]
+                    ),
+                    "object": datasets.ClassLabel(
+                        names=[
+                            "Chinese",
+                            "English",
+                            "German",
+                            "Korean",
+                            "heat",
+                            "juice",
+                            "lamp",
+                            "lights",
+                            "music",
+                            "newspaper",
+                            "none",
+                            "shoes",
+                            "socks",
+                            "volume",
+                        ]
+                    ),
+                    "location": datasets.ClassLabel(names=["bedroom", "kitchen", "none", "washroom"]),
+                }
+            ),
+            # no default supervised keys, since there are 3 labels
+            supervised_keys=None,
+            url="https://fluent.ai/fluent-speech-commands-a-dataset-for-spoken-language-understanding-research/",
+            data_url="data/fluent_speech_commands_dataset.zip",
+        ),
+        SuperbConfig(
+            name="si",
+            description=textwrap.dedent(
+                """\
+            Speaker Identification (SI) classifies each utterance for its speaker identity as a multi-class
+            classification, where speakers are in the same predefined set for both training and testing. The widely
+            used VoxCeleb1 dataset is adopted, and the evaluation metric is accuracy (ACC)."""
+            ),
+            features=datasets.Features(
+                {
+                    "file": datasets.Value("string"),
+                    "label": datasets.ClassLabel(names=[f"id{i + 10001}" for i in range(1251)]),
+                }
+            ),
+            supervised_keys=("file", "label"),
+            url="https://www.robots.ox.ac.uk/~vgg/data/voxceleb/vox1.html",
+            data_url="data/VoxCeleb1.zip"
+        ),
+        SuperbConfig(
+            name="er",
+            description=textwrap.dedent(
+                """\
+            Emotion Recognition (ER) predicts an emotion class for each utterance. The most widely used ER dataset
+            IEMOCAP is adopted, and we follow the conventional evaluation protocol: we drop the unbalance emotion
+            classes to leave the final four classes with a similar amount of data points and cross-validates on five
+            folds of the standard splits. The evaluation metric is accuracy (ACC)."""
+            ),
+            features=datasets.Features(
+                {
+                    "file": datasets.Value("string"),
+                    "label": datasets.ClassLabel(names=['neu', 'hap', 'ang', 'sad']),
+                }
+            ),
+            supervised_keys=("file", "label"),
+            url="https://sail.usc.edu/iemocap/",
+            data_url="data/IEMOCAP_full_release.zip"
+        ),
+    ]
+
+    def _info(self):
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=self.config.features,
+            supervised_keys=self.config.supervised_keys,
+            homepage=self.config.url,
+            citation=_CITATION,
+            task_templates=self.config.task_templates,
+        )
+
+    def _split_generators(self, dl_manager):
+        if self.config.name == "asr":
+            archive_path = dl_manager.download_and_extract(self.config.data_url)
+            return [
+                datasets.SplitGenerator(name=datasets.Split.TEST, gen_kwargs={"archive_path": archive_path}),
+            ]
+        elif self.config.name == "ks":
+            archive_path = dl_manager.download_and_extract(self.config.data_url)
+            return [
+                datasets.SplitGenerator(
+                    name=datasets.Split.TEST, gen_kwargs={"archive_path": archive_path, "split": "test"}
+                ),
+            ]
+        elif self.config.name == "ic":
+            archive_path = dl_manager.download_and_extract(self.config.data_url)
+            return [
+                datasets.SplitGenerator(
+                    name=datasets.Split.TEST, gen_kwargs={"archive_path": archive_path, "split": "test"}
+                ),
+            ]
+        elif self.config.name == "si":
+            archive_path = dl_manager.download_and_extract(self.config.data_url)
+            return [
+                datasets.SplitGenerator(
+                    name=datasets.Split.TEST, gen_kwargs={"archive_path": archive_path, "split": 3}
+                ),
+            ]
+        elif self.config.name == "sd":
+            archive_path = dl_manager.download_and_extract(self.config.data_url)
+            return [
+                datasets.SplitGenerator(
+                    name=datasets.Split.TEST, gen_kwargs={"archive_path": archive_path, "split": "test"}
+                )
+            ]
+        elif self.config.name == "er":
+            archive_path = dl_manager.download_and_extract(self.config.data_url)
+            return [
+                datasets.SplitGenerator(
+                    name="session1", gen_kwargs={"archive_path": archive_path, "split": 1},
+                )
+            ]
+
+    def _generate_examples(self, archive_path, split=None):
+        """Generate examples."""
+        if self.config.name == "asr":
+            transcripts_glob = os.path.join(archive_path, "LibriSpeech", "*/*/*/*.txt")
+            key = 0
+            for transcript_path in sorted(glob.glob(transcripts_glob)):
+                transcript_dir_path = os.path.dirname(transcript_path)
+                with open(transcript_path, "r", encoding="utf-8") as f:
+                    for line in f:
+                        line = line.strip()
+                        id_, transcript = line.split(" ", 1)
+                        audio_file = f"{id_}.flac"
+                        speaker_id, chapter_id = [int(el) for el in id_.split("-")[:2]]
+                        yield key, {
+                            "id": id_,
+                            "speaker_id": speaker_id,
+                            "chapter_id": chapter_id,
+                            "file": os.path.join(transcript_dir_path, audio_file),
+                            "text": transcript,
+                        }
+                        key += 1
+        elif self.config.name == "ks":
+            words = ["yes", "no", "up", "down", "left", "right", "on", "off", "stop", "go"]
+            splits = _split_ks_files(archive_path, split)
+            for key, audio_file in enumerate(sorted(splits[split])):
+                base_dir, file_name = os.path.split(audio_file)
+                _, word = os.path.split(base_dir)
+                if word in words:
+                    label = word
+                elif word == "_silence_" or word == "_background_noise_":
+                    label = "_silence_"
+                else:
+                    label = "_unknown_"
+                yield key, {"file": audio_file, "label": label}
+        elif self.config.name == "ic":
+            root_path = os.path.join(archive_path, "fluent_speech_commands_dataset/")
+            csv_path = os.path.join(root_path, f"data/{split}_data.csv")
+            with open(csv_path, encoding="utf-8") as csv_file:
+                csv_reader = csv.reader(csv_file, delimiter=",", skipinitialspace=True)
+                next(csv_reader)
+                for row in csv_reader:
+                    key, file_path, speaker_id, text, action, object_, location = row
+                    yield key, {
+                        "file": os.path.join(root_path, file_path),
+                        "speaker_id": speaker_id,
+                        "text": text,
+                        "action": action,
+                        "object": object_,
+                        "location": location,
+                    }
+        elif self.config.name == "si":
+            wav_path = os.path.join(archive_path, "wav/")
+            splits_path = os.path.join(archive_path, "veri_test_class.txt")
+            with open(splits_path, "r", encoding="utf-8") as f:
+                for key, line in enumerate(f):
+                    split_id, file_path = line.strip().split(" ")
+                    if int(split_id) != split:
+                        continue
+                    speaker_id = file_path.split("/")[0]
+                    yield key, {
+                        "file": os.path.join(wav_path, file_path),
+                        "label": speaker_id,
+                    }
+        elif self.config.name == "er":
+            root_path = os.path.join(archive_path, f"Session{split}/")
+            wav_path = os.path.join(root_path, "sentences/wav/")
+            labels_path = os.path.join(root_path, "dialog/EmoEvaluation/*.txt")
+            emotions = ['neu', 'hap', 'ang', 'sad', 'exc']
+            key = 0
+            for labels_file in sorted(glob.glob(labels_path)):
+                with open(labels_file, "r", encoding="utf-8") as f:
+                    for line in f:
+                        if line[0] != "[":
+                            continue
+                        _, filename, emo, _ = line.split("\t")
+                        if emo not in emotions:
+                            continue
+                        wav_subdir = filename.rsplit("_", 1)[0]
+                        filename = f"{filename}.wav"
+                        yield key, {
+                            "file": os.path.join(wav_path, wav_subdir, filename),
+                            "label": emo.replace('exc', 'hap'),
+                        }
+                        key += 1
+
+
+def _split_ks_files(archive_path, split):
+    audio_path = os.path.join(archive_path, "**/*.wav")
+    audio_paths = glob.glob(audio_path)
+    if split == "test":
+        # use all available files for the test archive
+        return {"test": audio_paths}
+
+    val_list_file = os.path.join(archive_path, "validation_list.txt")
+    test_list_file = os.path.join(archive_path, "testing_list.txt")
+    with open(val_list_file, encoding="utf-8") as f:
+        val_paths = f.read().strip().splitlines()
+        val_paths = [os.path.join(archive_path, p) for p in val_paths]
+    with open(test_list_file, encoding="utf-8") as f:
+        test_paths = f.read().strip().splitlines()
+        test_paths = [os.path.join(archive_path, p) for p in test_paths]
+
+    # the paths for the train set is just whichever paths that do not exist in
+    # either the test or validation splits
+    train_paths = list(set(audio_paths) - set(val_paths) - set(test_paths))
+
+    return {"train": train_paths, "val": val_paths}