Delete peoples_speech.py

peoples_speech.py

@@ -1,225 +0,0 @@
-# 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 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(),
-                    "duration_ms": datasets.Value("int32"),
-                    "text": datasets.Value("string"),
-                }
-            ),
-            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[split]) 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"]
-                }