Delete loading script

superb_dummy.py

@@ -1,273 +0,0 @@
-# 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,
-        **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
-
-
-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",
-        ),
-        SuperbConfig(
-            name="sd",
-            description=textwrap.dedent(
-                """\
-            Speaker Diarization (SD) predicts `who is speaking when` for each timestamp, and multiple speakers can
-            speak simultaneously. The model has to encode rich speaker characteristics for each frame and should be
-            able to represent mixtures of signals. [LibriMix] is adopted where LibriSpeech
-            train-clean-100/dev-clean/test-clean are used to generate mixtures for training/validation/testing.
-            We focus on the two-speaker scenario as the first step. The time-coded speaker labels were generated using
-            alignments from Kaldi LibriSpeech ASR model. The evaluation metric is diarization error rate (DER)."""
-            ),
-            features=datasets.Features(
-                {
-                    "file": datasets.Value("string"),
-                    "speech": datasets.Sequence(datasets.Value("float32")),
-                    "speakers": [
-                        {
-                            "speaker_id": datasets.Value("string"),
-                            "start": datasets.Value("int64"),
-                            "end": datasets.Value("int64"),
-                        }
-                    ],
-                }
-            ),
-            url="https://github.com/ftshijt/LibriMix",
-            data_url="sd.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,
-        )
-
-    def _split_generators(self, dl_manager):
-        data_path = dl_manager.download_and_extract(self.config.data_url)
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                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