from peoples speech

peoples_speech-clean.py

@@ -0,0 +1,227 @@
+# Copyright 2020 The HuggingFace Datasets Authors and the current dataset script contributor.
+#
+# 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.
+
+import json
+import os
+
+import datasets
+from datasets.tasks import AutomaticSpeechRecognition
+from tqdm.auto import tqdm
+
+
+# Find for instance the citation on arxiv or on the dataset repo/website
+_CITATION = """\
+@article{DBLP:journals/corr/abs-2111-09344,
+  author    = {Daniel Galvez and
+               Greg Diamos and
+               Juan Ciro and
+               Juan Felipe Ceron and
+               Keith Achorn and
+               Anjali Gopi and
+               David Kanter and
+               Maximilian Lam and
+               Mark Mazumder and
+               Vijay Janapa Reddi},
+  title     = {The People's Speech: A Large-Scale Diverse English Speech Recognition
+               Dataset for Commercial Usage},
+  journal   = {CoRR},
+  volume    = {abs/2111.09344},
+  year      = {2021},
+  url       = {https://arxiv.org/abs/2111.09344},
+  eprinttype = {arXiv},
+  eprint    = {2111.09344},
+  timestamp = {Mon, 22 Nov 2021 16:44:07 +0100},
+  biburl    = {https://dblp.org/rec/journals/corr/abs-2111-09344.bib},
+  bibsource = {dblp computer science bibliography, https://dblp.org}
+}
+"""
+
+# You can copy an official description
+_DESCRIPTION = """\
+The People's Speech is a free-to-download 30,000-hour and growing supervised 
+conversational English speech recognition dataset licensed for academic and 
+commercial usage under CC-BY-SA (with a CC-BY subset).
+"""
+
+_HOMEPAGE = "https://mlcommons.org/en/peoples-speech/"
+
+_LICENSE = [
+    "cc-by-2.0", "cc-by-2.5", "cc-by-3.0", "cc-by-4.0", "cc-by-sa-2.5",
+    "cc-by-sa-3.0", "cc-by-sa-4.0"
+]
+
+_BASE_URL = "https://huggingface.co/datasets/MLCommons/peoples_speech/resolve/main/"
+
+# relative path to data inside dataset's repo
+_DATA_URL = _BASE_URL + "{split}/{config}/{config}_{archive_id:06d}.tar"
+
+# relative path to file containing number of audio archives inside dataset's repo
+_N_SHARDS_URL = _BASE_URL + "n_shards.json"
+
+# relative path to metadata inside dataset's repo
+_MANIFEST_URL = _BASE_URL + "{split}/{config}.json"
+
+
+class PeoplesSpeechConfig(datasets.BuilderConfig):
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+
+class PeoplesSpeech(datasets.GeneratorBasedBuilder):
+    """The People's Speech dataset."""
+
+    VERSION = datasets.Version("1.1.0")
+    BUILDER_CONFIGS = [
+        PeoplesSpeechConfig(name="microset", version=VERSION, description="Small subset of clean data for example pusposes."),
+        PeoplesSpeechConfig(name="clean", version=VERSION, description="Clean, CC-BY licensed subset."),
+        PeoplesSpeechConfig(name="dirty", version=VERSION, description="Dirty, CC-BY licensed subset."),
+        PeoplesSpeechConfig(name="clean_sa", version=VERSION, description="Clean, CC-BY-SA licensed subset."),
+        PeoplesSpeechConfig(name="dirty_sa", version=VERSION, description="Dirty, CC-BY-SA licensed subset."),
+        PeoplesSpeechConfig(name="test", version=VERSION, description="Only test data."),
+        PeoplesSpeechConfig(name="validation", version=VERSION, description="Only validation data."),
+    ]
+    DEFAULT_CONFIG_NAME = "clean"
+    DEFAULT_WRITER_BATCH_SIZE = 512
+
+    def _info(self):
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=datasets.Features(
+                {
+                    "id": datasets.Value("string"),
+                    "audio": datasets.Audio(sampling_rate=16_000),
+                    "duration_ms": datasets.Value("int32"),
+                    "text": datasets.Value("string"),
+                }
+            ),
+            task_templates=[AutomaticSpeechRecognition()],
+            homepage=_HOMEPAGE,
+            license="/".join(_LICENSE),  # license must be a string
+            citation=_CITATION,
+        )
+
+    def _split_generators(self, dl_manager):
+
+        if self.config.name == "microset":
+            # take only first data archive for demo purposes
+            url = [_DATA_URL.format(split="train", config="clean", archive_id=0)]
+            archive_path = dl_manager.download(url)
+            local_extracted_archive_path = dl_manager.extract(archive_path) if not dl_manager.is_streaming else [None]
+            manifest_url = _MANIFEST_URL.format(split="train", config="clean_000000")  # train/clean_000000.json
+            manifest_path = dl_manager.download_and_extract(manifest_url)
+
+            return [
+                datasets.SplitGenerator(
+                    name=datasets.Split.TRAIN,
+                    gen_kwargs={
+                        "local_extracted_archive_paths": local_extracted_archive_path,
+                        # use iter_archive here to access the files in the TAR archives:
+                        "archives": [dl_manager.iter_archive(path) for path in archive_path],
+                        "manifest_path": manifest_path,
+                    },
+                ),
+            ]
+
+        n_shards_path = dl_manager.download_and_extract(_N_SHARDS_URL)
+        with open(n_shards_path, encoding="utf-8") as f:
+            n_shards = json.load(f)
+
+        if self.config.name in ["validation", "test"]:
+            splits_to_configs = {self.config.name: self.config.name}
+        else:
+            splits_to_configs = {
+                "train": self.config.name,
+                "validation": "validation",
+                "test": "test"
+            }
+
+        audio_urls = {
+            split: [
+                _DATA_URL.format(split=split, config=config, archive_id=i) for i in range(n_shards[split][config])
+            ] for split, config in splits_to_configs.items()
+        }
+        audio_archive_paths = dl_manager.download(audio_urls)
+
+        # In non-streaming mode, we extract the archives to have the data locally:
+        local_extracted_archive_paths = dl_manager.extract(audio_archive_paths) \
+            if not dl_manager.is_streaming else \
+            {split: [None] * len(audio_archive_paths) for split in splits_to_configs}
+
+        manifest_urls = {
+            split: _MANIFEST_URL.format(split=split, config=config) for split, config in splits_to_configs.items()
+        }
+        manifest_paths = dl_manager.download_and_extract(manifest_urls)
+
+        # To access the audio data from the TAR archives using the download manager,
+        # we have to use the dl_manager.iter_archive method
+        #
+        # This is because dl_manager.download_and_extract
+        # doesn't work to stream TAR archives in streaming mode.
+        # (we have to stream the files of a TAR archive one by one)
+        #
+        # The iter_archive method returns an iterable of (path_within_archive, file_obj) for every
+        # file in a TAR archive.
+        splits_to_names = {
+            "train": datasets.Split.TRAIN,
+            "validation": datasets.Split.VALIDATION,
+            "test": datasets.Split.TEST,
+        }
+        split_generators = []
+        for split in splits_to_configs:
+            split_generators.append(
+                datasets.SplitGenerator(
+                    name=splits_to_names[split],
+                    gen_kwargs={
+                        "local_extracted_archive_paths": local_extracted_archive_paths[split],
+                        # use iter_archive here to access the files in the TAR archives:
+                        "archives": [dl_manager.iter_archive(path) for path in audio_archive_paths[split]],
+                        "manifest_path": manifest_paths[split],
+                    }
+                )
+            )
+
+        return split_generators
+
+    def _generate_examples(self, local_extracted_archive_paths, archives, manifest_path):
+        meta = dict()
+        with open(manifest_path, "r", encoding="utf-8") as f:
+            for line in tqdm(f, desc="reading metadata file"):
+                sample_meta = json.loads(line)
+                _id = sample_meta["audio_document_id"]
+                texts = sample_meta["training_data"]["label"]
+                audio_filenames = sample_meta["training_data"]["name"]
+                durations = sample_meta["training_data"]["duration_ms"]
+                for audio_filename, text, duration in zip(audio_filenames, texts, durations):
+                    audio_filename = audio_filename.lstrip("./")
+                    meta[audio_filename] = {
+                        "audio_document_id": _id,
+                        "text": text,
+                        "duration_ms": duration
+                    }
+
+        for local_extracted_archive_path, archive in zip(local_extracted_archive_paths, archives):
+            # Here we iterate over all the files within the TAR archive:
+            for audio_filename, audio_file in archive:
+                audio_filename = audio_filename.lstrip("./")
+                # if an audio file exists locally (i.e. in default, non-streaming mode) set the full path to it
+                # joining path to directory that the archive was extracted to and audio filename.
+                path = os.path.join(local_extracted_archive_path, audio_filename) if local_extracted_archive_path \
+                    else audio_filename
+                yield audio_filename, {
+                    "id": audio_filename,
+                    "audio": {"path": path, "bytes": audio_file.read()},
+                    "text": meta[audio_filename]["text"],
+                    "duration_ms": meta[audio_filename]["duration_ms"]
+                }