Upload KS, IC, SI, ER

.gitattributes

@@ -14,3 +14,4 @@
 *.pb filter=lfs diff=lfs merge=lfs -text
 *.pt filter=lfs diff=lfs merge=lfs -text
 *.pth filter=lfs diff=lfs merge=lfs -text
+*.json filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,3 @@
+.idea
+.vscode
+*.lock

er.json

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

ic.json

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

ks.json

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

si.json

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

superb_dummy.py

@@ -0,0 +1,249 @@
+# 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 base64
+import json
+import textwrap
+
+import datasets
+import numpy as np
+
+_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.
+"""
+
+
+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="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_",
+                        ]
+                    ),
+                    "speech": datasets.Sequence(datasets.Value("float32")),
+                }
+            ),
+            url="https://www.tensorflow.org/datasets/catalog/speech_commands",
+            data_url="ks.json",
+        ),
+        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"]),
+                    "speech": datasets.Sequence(datasets.Value("float32")),
+                }
+            ),
+            url="https://fluent.ai/fluent-speech-commands-a-dataset-for-spoken-language-understanding-research/",
+            data_url="ic.json",
+        ),
+        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)]),
+                    "speech": datasets.Sequence(datasets.Value("float32")),
+                }
+            ),
+            url="https://www.robots.ox.ac.uk/~vgg/data/voxceleb/vox1.html",
+            data_url="si.json",
+        ),
+        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"]),
+                    "speech": datasets.Sequence(datasets.Value("float32")),
+                }
+            ),
+            url="https://sail.usc.edu/iemocap/",
+            data_url="er.json",
+        ),
+    ]
+
+    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):
+        data_path = dl_manager.download_and_extract(self.config.data_url)
+
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.VALIDATION,
+                gen_kwargs={"data_path": data_path},
+            )
+        ]
+
+    def _generate_examples(self, data_path):
+        """Generate examples."""
+        with open(data_path, "r", encoding="utf-8") as f:
+            for key, line in enumerate(f):
+                example = json.loads(line)
+                example["speech"] = np.frombuffer(base64.b64decode(example["speech"]), dtype=np.float32)
+
+                yield key, example