Convert dataset to Parquet

README.md

@@ -49,82 +49,58 @@ dataset_info:
     dtype: string
   splits:
   - name: train
-    num_bytes: 11852430
+    num_bytes: 6375977437.341
     num_examples: 28539
   - name: validation
-    num_bytes: 897213
+    num_bytes: 348570484.902
     num_examples: 2703
   - name: test
-    num_bytes: 871234
+    num_bytes: 372116604.94
     num_examples: 2620
-  download_size: 7071899769
-  dataset_size: 13620877
-- config_name: sd
-  features:
-  - name: record_id
-    dtype: string
-  - name: file
-    dtype: string
-  - name: start
-    dtype: int64
-  - name: end
-    dtype: int64
-  - name: speakers
-    list:
-    - name: speaker_id
-      dtype: string
-    - name: start
-      dtype: int64
-    - name: end
-      dtype: int64
-  splits:
-  - name: train
-    num_bytes: 4622013
-    num_examples: 13901
-  - name: dev
-    num_bytes: 860472
-    num_examples: 3014
-  - name: test
-    num_bytes: 847803
-    num_examples: 3002
-  download_size: 7190370211
-  dataset_size: 6330288
-- config_name: ks
+  download_size: 7125182283
+  dataset_size: 7096664527.183
+- config_name: er
   features:
   - name: file
     dtype: string
+  - name: audio
+    dtype:
+      audio:
+        sampling_rate: 16000
   - name: label
     dtype:
       class_label:
         names:
-          '0': 'yes'
-          '1': 'no'
-          '2': up
-          '3': down
-          '4': left
-          '5': right
-          '6': 'on'
-          '7': 'off'
-          '8': stop
-          '9': go
-          '10': _silence_
-          '11': _unknown_
+          '0': neu
+          '1': hap
+          '2': ang
+          '3': sad
   splits:
-  - name: train
-    num_bytes: 8467781
-    num_examples: 51094
-  - name: validation
-    num_bytes: 1126476
-    num_examples: 6798
-  - name: test
-    num_bytes: 510619
-    num_examples: 3081
-  download_size: 1560367713
-  dataset_size: 10104876
+  - name: session1
+    num_bytes: 165335280.64
+    num_examples: 1085
+  - name: session2
+    num_bytes: 154368877.13
+    num_examples: 1023
+  - name: session3
+    num_bytes: 158481419.59
+    num_examples: 1151
+  - name: session4
+    num_bytes: 147948458.55
+    num_examples: 1031
+  - name: session5
+    num_bytes: 170303066.098
+    num_examples: 1241
+  download_size: 787372540
+  dataset_size: 796437102.0080001
 - config_name: ic
   features:
   - name: file
     dtype: string
+  - name: audio
+    dtype:
+      audio:
+        sampling_rate: 16000
   - name: speaker_id
     dtype: string
   - name: text
@@ -167,20 +143,94 @@ dataset_info:
           '3': washroom
   splits:
   - name: train
-    num_bytes: 7071466
+    num_bytes: 1874399385.936
     num_examples: 23132
   - name: validation
-    num_bytes: 953622
+    num_bytes: 239956791.064
     num_examples: 3118
   - name: test
-    num_bytes: 1158347
+    num_bytes: 315754572.65
     num_examples: 3793
-  download_size: 1544093324
-  dataset_size: 9183435
+  download_size: 1916993254
+  dataset_size: 2430110749.65
+- config_name: ks
+  features:
+  - name: file
+    dtype: string
+  - name: audio
+    dtype:
+      audio:
+        sampling_rate: 16000
+  - name: label
+    dtype:
+      class_label:
+        names:
+          '0': 'yes'
+          '1': 'no'
+          '2': up
+          '3': down
+          '4': left
+          '5': right
+          '6': 'on'
+          '7': 'off'
+          '8': stop
+          '9': go
+          '10': _silence_
+          '11': _unknown_
+  splits:
+  - name: train
+    num_bytes: 2260079579.356
+    num_examples: 51094
+  - name: validation
+    num_bytes: 215210144.552
+    num_examples: 6798
+  - name: test
+    num_bytes: 99219235.676
+    num_examples: 3081
+  download_size: 1770827480
+  dataset_size: 2574508959.584
+- config_name: sd
+  features:
+  - name: record_id
+    dtype: string
+  - name: file
+    dtype: string
+  - name: audio
+    dtype:
+      audio:
+        sampling_rate: 16000
+  - name: start
+    dtype: int64
+  - name: end
+    dtype: int64
+  - name: speakers
+    list:
+    - name: speaker_id
+      dtype: string
+    - name: start
+      dtype: int64
+    - name: end
+      dtype: int64
+  splits:
+  - name: train
+    num_bytes: 6441566080.729
+    num_examples: 13901
+  - name: dev
+    num_bytes: 886182068.496
+    num_examples: 3014
+  - name: test
+    num_bytes: 806042390.538
+    num_examples: 3002
+  download_size: 8179921384
+  dataset_size: 8133790539.7630005
 - config_name: si
   features:
   - name: file
     dtype: string
+  - name: audio
+    dtype:
+      audio:
+        sampling_rate: 16000
   - name: label
     dtype:
       class_label:
@@ -1438,16 +1488,69 @@ dataset_info:
           '1250': id11251
   splits:
   - name: train
-    num_bytes: 12729268
+    num_bytes: 35010298085.36
     num_examples: 138361
   - name: validation
-    num_bytes: 635172
+    num_bytes: 1707484335.0
     num_examples: 6904
   - name: test
-    num_bytes: 759096
+    num_bytes: 2078843122.32
     num_examples: 8251
-  download_size: 0
-  dataset_size: 14123536
+  download_size: 40376064647
+  dataset_size: 38796625542.68
+configs:
+- config_name: asr
+  data_files:
+  - split: train
+    path: asr/train-*
+  - split: validation
+    path: asr/validation-*
+  - split: test
+    path: asr/test-*
+- config_name: er
+  data_files:
+  - split: session1
+    path: er/session1-*
+  - split: session2
+    path: er/session2-*
+  - split: session3
+    path: er/session3-*
+  - split: session4
+    path: er/session4-*
+  - split: session5
+    path: er/session5-*
+- config_name: ic
+  data_files:
+  - split: train
+    path: ic/train-*
+  - split: validation
+    path: ic/validation-*
+  - split: test
+    path: ic/test-*
+- config_name: ks
+  data_files:
+  - split: train
+    path: ks/train-*
+  - split: validation
+    path: ks/validation-*
+  - split: test
+    path: ks/test-*
+- config_name: sd
+  data_files:
+  - split: train
+    path: sd/train-*
+  - split: dev
+    path: sd/dev-*
+  - split: test
+    path: sd/test-*
+- config_name: si
+  data_files:
+  - split: train
+    path: si/train-*
+  - split: validation
+    path: si/validation-*
+  - split: test
+    path: si/test-*
 ---
 
 # Dataset Card for SUPERB

asr/test-00000-of-00001.parquet

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

asr/train-00000-of-00002.parquet

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

asr/train-00001-of-00002.parquet

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

asr/validation-00000-of-00001.parquet

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

er/session1-00000-of-00001.parquet

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

er/session2-00000-of-00001.parquet

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

er/session3-00000-of-00001.parquet

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

er/session4-00000-of-00001.parquet

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

er/session5-00000-of-00001.parquet

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

ic/test-00000-of-00001.parquet

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

ic/train-00000-of-00001.parquet

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

ic/validation-00000-of-00001.parquet

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

ks/test-00000-of-00001.parquet

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

ks/train-00000-of-00001.parquet

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

ks/validation-00000-of-00001.parquet

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

sd/dev-00000-of-00001.parquet

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

sd/test-00000-of-00001.parquet

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

sd/train-00000-of-00002.parquet

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

sd/train-00001-of-00002.parquet

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

si/test-00000-of-00001.parquet

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

si/train-00000-of-00009.parquet

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

si/train-00001-of-00009.parquet

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

si/train-00002-of-00009.parquet

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

si/train-00003-of-00009.parquet

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

si/train-00004-of-00009.parquet

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

si/train-00005-of-00009.parquet

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

si/train-00006-of-00009.parquet

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

si/train-00007-of-00009.parquet

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

si/train-00008-of-00009.parquet

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

si/validation-00000-of-00001.parquet

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

superb.py

@@ -1,686 +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 csv
-import glob
-import os
-import textwrap
-from dataclasses import dataclass
-
-import datasets
-
-
-_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 .wav 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,
-        **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="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"),
-                    "audio": datasets.Audio(sampling_rate=16_000),
-                    "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="http://www.openslr.org/resources/12/",
-        ),
-        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"),
-                    "audio": datasets.Audio(sampling_rate=16_000),
-                    "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="http://download.tensorflow.org/data/{filename}",
-        ),
-        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"),
-                    "audio": datasets.Audio(sampling_rate=16_000),
-                    "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"]),
-                }
-            ),
-            supervised_keys=None,
-            url="https://fluent.ai/fluent-speech-commands-a-dataset-for-spoken-language-understanding-research/",
-            data_url="http://fluent.ai:2052/jf8398hf30f0381738rucj3828chfdnchs.tar.gz",
-        ),
-        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"),
-                    "audio": datasets.Audio(sampling_rate=16_000),
-                    # VoxCeleb1 contains 1251 speaker IDs in range ["id10001",..."id11251"]
-                    "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",
-        ),
-        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(
-                {
-                    "record_id": datasets.Value("string"),
-                    "file": datasets.Value("string"),
-                    "audio": datasets.Audio(sampling_rate=16_000),
-                    "start": datasets.Value("int64"),
-                    "end": datasets.Value("int64"),
-                    "speakers": [
-                        {
-                            "speaker_id": datasets.Value("string"),
-                            "start": datasets.Value("int64"),
-                            "end": datasets.Value("int64"),
-                        }
-                    ],
-                }
-            ),  # TODO
-            supervised_keys=None,  # TODO
-            url="https://github.com/ftshijt/LibriMix",
-            data_url="https://huggingface.co/datasets/superb/superb-data/resolve/main/sd/{split}/{filename}",
-        ),
-        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 unbalanced emotion
-            classes to leave the final four classes with a similar amount of data points and cross-validate on five
-            folds of the standard splits. The evaluation metric is accuracy (ACC)."""
-            ),
-            features=datasets.Features(
-                {
-                    "file": datasets.Value("string"),
-                    "audio": datasets.Audio(sampling_rate=16_000),
-                    "label": datasets.ClassLabel(names=["neu", "hap", "ang", "sad"]),
-                }
-            ),
-            supervised_keys=("file", "label"),
-            url="https://sail.usc.edu/iemocap/",
-        ),
-    ]
-
-    @property
-    def manual_download_instructions(self):
-        if self.config.name == "si":
-            return textwrap.dedent(
-                """
-            Please download the VoxCeleb dataset using the following script,
-            which should create `VoxCeleb1/wav/id*` directories for both train and test speakers`:
-            ```
-            mkdir VoxCeleb1
-            cd VoxCeleb1
-
-            wget https://thor.robots.ox.ac.uk/~vgg/data/voxceleb/vox1a/vox1_dev_wav_partaa
-            wget https://thor.robots.ox.ac.uk/~vgg/data/voxceleb/vox1a/vox1_dev_wav_partab
-            wget https://thor.robots.ox.ac.uk/~vgg/data/voxceleb/vox1a/vox1_dev_wav_partac
-            wget https://thor.robots.ox.ac.uk/~vgg/data/voxceleb/vox1a/vox1_dev_wav_partad
-            cat vox1_dev* > vox1_dev_wav.zip
-            unzip vox1_dev_wav.zip
-
-            wget https://thor.robots.ox.ac.uk/~vgg/data/voxceleb/vox1a/vox1_test_wav.zip
-            unzip vox1_test_wav.zip
-
-            # download the official SUPERB train-dev-test split
-            wget https://raw.githubusercontent.com/s3prl/s3prl/master/s3prl/downstream/voxceleb1/veri_test_class.txt
-            ```"""
-            )
-        elif self.config.name == "er":
-            return textwrap.dedent(
-                """
-            Please download the IEMOCAP dataset after submitting the request form here:
-            https://sail.usc.edu/iemocap/iemocap_release.htm
-            Having downloaded the dataset you can extract it with `tar -xvzf IEMOCAP_full_release.tar.gz`
-            which should create a folder called `IEMOCAP_full_release`
-            """
-            )
-        return None
-
-    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):
-        if self.config.name == "asr":
-            _DL_URLS = {
-                "dev": self.config.data_url + "dev-clean.tar.gz",
-                "test": self.config.data_url + "test-clean.tar.gz",
-                "train": self.config.data_url + "train-clean-100.tar.gz",
-            }
-            archive_path = dl_manager.download_and_extract(_DL_URLS)
-
-            return [
-                datasets.SplitGenerator(name=datasets.Split.TRAIN, gen_kwargs={"archive_path": archive_path["train"]}),
-                datasets.SplitGenerator(
-                    name=datasets.Split.VALIDATION, gen_kwargs={"archive_path": archive_path["dev"]}
-                ),
-                datasets.SplitGenerator(name=datasets.Split.TEST, gen_kwargs={"archive_path": archive_path["test"]}),
-            ]
-        elif self.config.name == "ks":
-            _DL_URLS = {
-                "train_val_test": self.config.data_url.format(filename="speech_commands_v0.01.tar.gz"),
-                "test": self.config.data_url.format(filename="speech_commands_test_set_v0.01.tar.gz"),
-            }
-            archive_path = dl_manager.download_and_extract(_DL_URLS)
-            return [
-                datasets.SplitGenerator(
-                    name=datasets.Split.TRAIN,
-                    gen_kwargs={"archive_path": archive_path["train_val_test"], "split": "train"},
-                ),
-                datasets.SplitGenerator(
-                    name=datasets.Split.VALIDATION,
-                    gen_kwargs={"archive_path": archive_path["train_val_test"], "split": "val"},
-                ),
-                datasets.SplitGenerator(
-                    name=datasets.Split.TEST, gen_kwargs={"archive_path": archive_path["test"], "split": "test"}
-                ),
-            ]
-        elif self.config.name == "ic":
-            archive_path = dl_manager.download_and_extract(self.config.data_url)
-            return [
-                datasets.SplitGenerator(
-                    name=datasets.Split.TRAIN,
-                    gen_kwargs={"archive_path": archive_path, "split": "train"},
-                ),
-                datasets.SplitGenerator(
-                    name=datasets.Split.VALIDATION,
-                    gen_kwargs={"archive_path": archive_path, "split": "valid"},
-                ),
-                datasets.SplitGenerator(
-                    name=datasets.Split.TEST, gen_kwargs={"archive_path": archive_path, "split": "test"}
-                ),
-            ]
-        elif self.config.name == "si":
-            manual_dir = os.path.abspath(os.path.expanduser(dl_manager.manual_dir))
-            return [
-                datasets.SplitGenerator(
-                    name=datasets.Split.TRAIN,
-                    gen_kwargs={"archive_path": manual_dir, "split": 1},
-                ),
-                datasets.SplitGenerator(
-                    name=datasets.Split.VALIDATION,
-                    gen_kwargs={"archive_path": manual_dir, "split": 2},
-                ),
-                datasets.SplitGenerator(name=datasets.Split.TEST, gen_kwargs={"archive_path": manual_dir, "split": 3}),
-            ]
-        elif self.config.name == "sd":
-            splits = ["train", "dev", "test"]
-            _DL_URLS = {
-                split: {
-                    filename: self.config.data_url.format(split=split, filename=filename)
-                    for filename in ["reco2dur", "segments", "utt2spk", "wav.zip"]
-                }
-                for split in splits
-            }
-            archive_path = dl_manager.download_and_extract(_DL_URLS)
-            return [
-                datasets.SplitGenerator(
-                    name=datasets.NamedSplit(split), gen_kwargs={"archive_path": archive_path[split], "split": split}
-                )
-                for split in splits
-            ]
-        elif self.config.name == "er":
-            manual_dir = os.path.abspath(os.path.expanduser(dl_manager.manual_dir))
-            return [
-                datasets.SplitGenerator(
-                    name=f"session{i}",
-                    gen_kwargs={"archive_path": manual_dir, "split": i},
-                )
-                for i in range(1, 6)
-            ]
-
-    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]]
-                        audio_path = os.path.join(transcript_dir_path, audio_file)
-                        yield key, {
-                            "id": id_,
-                            "speaker_id": speaker_id,
-                            "chapter_id": chapter_id,
-                            "file": audio_path,
-                            "audio": audio_path,
-                            "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, "audio": 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, "data", f"{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
-                    audio_path = os.path.join(root_path, file_path)
-                    yield key, {
-                        "file": audio_path,
-                        "audio": audio_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]
-                    audio_path = os.path.join(wav_path, file_path)
-                    yield key, {
-                        "file": audio_path,
-                        "audio": audio_path,
-                        "label": speaker_id,
-                    }
-        elif self.config.name == "sd":
-            data = SdData(archive_path)
-            args = SdArgs()
-            chunk_indices = _generate_chunk_indices(data, args, split=split)
-            if split != "test":
-                for key, (rec, st, ed) in enumerate(chunk_indices):
-                    speakers = _get_speakers(rec, data, args)
-                    yield key, {
-                        "record_id": rec,
-                        "file": data.wavs[rec],
-                        "audio": data.wavs[rec],
-                        "start": st,
-                        "end": ed,
-                        "speakers": speakers,
-                    }
-            else:
-                key = 0
-                for rec in chunk_indices:
-                    for rec, st, ed in chunk_indices[rec]:
-                        speakers = _get_speakers(rec, data, args)
-                        yield key, {
-                            "record_id": rec,
-                            "file": data.wavs[rec],
-                            "audio": data.wavs[rec],
-                            "start": st,
-                            "end": ed,
-                            "speakers": speakers,
-                        }
-                        key += 1
-        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"
-                        audio_path = os.path.join(wav_path, wav_subdir, filename)
-                        yield key, {
-                            "file": audio_path,
-                            "audio": audio_path,
-                            "label": emo.replace("exc", "hap"),
-                        }
-                        key += 1
-
-
-class SdData:
-    def __init__(self, data_dir):
-        """Load sd data."""
-        self.segments = self._load_segments_rechash(data_dir["segments"])
-        self.utt2spk = self._load_utt2spk(data_dir["utt2spk"])
-        self.wavs = self._load_wav_zip(data_dir["wav.zip"])
-        self.reco2dur = self._load_reco2dur(data_dir["reco2dur"])
-
-    def _load_segments_rechash(self, segments_file):
-        """Load segments file as dict with recid index."""
-        ret = {}
-        if not os.path.exists(segments_file):
-            return None
-        with open(segments_file, encoding="utf-8") as f:
-            for line in f:
-                utt, rec, st, et = line.strip().split()
-                if rec not in ret:
-                    ret[rec] = []
-                ret[rec].append({"utt": utt, "st": float(st), "et": float(et)})
-        return ret
-
-    def _load_wav_zip(self, wav_zip):
-        """Return dictionary { rec: wav_rxfilename }."""
-        wav_dir = os.path.join(wav_zip, "wav")
-        return {
-            os.path.splitext(filename)[0]: os.path.join(wav_dir, filename) for filename in sorted(os.listdir(wav_dir))
-        }
-
-    def _load_utt2spk(self, utt2spk_file):
-        """Returns dictionary { uttid: spkid }."""
-        with open(utt2spk_file, encoding="utf-8") as f:
-            lines = [line.strip().split(None, 1) for line in f]
-        return {x[0]: x[1] for x in lines}
-
-    def _load_reco2dur(self, reco2dur_file):
-        """Returns dictionary { recid: duration }."""
-        if not os.path.exists(reco2dur_file):
-            return None
-        with open(reco2dur_file, encoding="utf-8") as f:
-            lines = [line.strip().split(None, 1) for line in f]
-        return {x[0]: float(x[1]) for x in lines}
-
-
-@dataclass
-class SdArgs:
-    chunk_size: int = 2000
-    frame_shift: int = 160
-    subsampling: int = 1
-    label_delay: int = 0
-    num_speakers: int = 2
-    rate: int = 16000
-    use_last_samples: bool = True
-
-
-def _generate_chunk_indices(data, args, split=None):
-    chunk_indices = [] if split != "test" else {}
-    # make chunk indices: filepath, start_frame, end_frame
-    for rec in data.wavs:
-        data_len = int(data.reco2dur[rec] * args.rate / args.frame_shift)
-        data_len = int(data_len / args.subsampling)
-        if split == "test":
-            chunk_indices[rec] = []
-        if split != "test":
-            for st, ed in _gen_frame_indices(
-                data_len,
-                args.chunk_size,
-                args.chunk_size,
-                args.use_last_samples,
-                label_delay=args.label_delay,
-                subsampling=args.subsampling,
-            ):
-                chunk_indices.append((rec, st * args.subsampling, ed * args.subsampling))
-        else:
-            for st, ed in _gen_chunk_indices(data_len, args.chunk_size):
-                chunk_indices[rec].append((rec, st * args.subsampling, ed * args.subsampling))
-    return chunk_indices
-
-
-def _count_frames(data_len, size, step):
-    # no padding at edges, last remaining samples are ignored
-    return int((data_len - size + step) / step)
-
-
-def _gen_frame_indices(data_length, size=2000, step=2000, use_last_samples=False, label_delay=0, subsampling=1):
-    i = -1
-    for i in range(_count_frames(data_length, size, step)):
-        yield i * step, i * step + size
-    if use_last_samples and i * step + size < data_length:
-        if data_length - (i + 1) * step - subsampling * label_delay > 0:
-            yield (i + 1) * step, data_length
-
-
-def _gen_chunk_indices(data_len, chunk_size):
-    step = chunk_size
-    start = 0
-    while start < data_len:
-        end = min(data_len, start + chunk_size)
-        yield start, end
-        start += step
-
-
-def _get_speakers(rec, data, args):
-    return [
-        {
-            "speaker_id": data.utt2spk[segment["utt"]],
-            "start": round(segment["st"] * args.rate / args.frame_shift),
-            "end": round(segment["et"] * args.rate / args.frame_shift),
-        }
-        for segment in data.segments[rec]
-    ]
-
-
-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}