# coding=utf-8 # Copyright 2022 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 """Multilingual Librispeech automatic speech recognition dataset.""" from functools import partial import os import datasets from datasets.streaming import xopen _CITATION = """\ @article{Pratap2020MLSAL, title={MLS: A Large-Scale Multilingual Dataset for Speech Research}, author={Vineel Pratap and Qiantong Xu and Anuroop Sriram and Gabriel Synnaeve and Ronan Collobert}, journal={ArXiv}, year={2020}, volume={abs/2012.03411} } """ _DESCRIPTION = """\ This is a streamable version of the Multilingual LibriSpeech (MLS) dataset. The data archives were restructured from the original ones from [OpenSLR](http://www.openslr.org/94) to make it easier to stream. MLS dataset is a large multilingual corpus suitable for speech research. The dataset is derived from read audiobooks from LibriVox and consists of 8 languages: English, German, Dutch, Spanish, French, Italian, Portuguese, Polish. """ _URL = "http://www.openslr.org/94" _DL_URL_FORMAT = "data/mls_{name}" class MultilingualLibrispeechConfig(datasets.BuilderConfig): """BuilderConfig for MultilingualLibrispeech.""" def __init__(self, name, **kwargs): """ Args: name: `string`, name of dataset config (=language) **kwargs: keyword arguments forwarded to super. """ super(MultilingualLibrispeechConfig, self).__init__( version=datasets.Version("2.1.0", ""), name=name, **kwargs ) # relative path to full data inside a repo (for example `data/mls_german`) self.data_root_dir = _DL_URL_FORMAT.format(name=name) class MultilingualLibrispeech(datasets.GeneratorBasedBuilder): """Multilingual Librispeech dataset.""" BUILDER_CONFIGS = [ MultilingualLibrispeechConfig(name="german", description="German LibriSpeech dataset"), MultilingualLibrispeechConfig(name="dutch", description="Dutch LibriSpeech dataset"), MultilingualLibrispeechConfig(name="french", description="French LibriSpeech dataset"), MultilingualLibrispeechConfig(name="spanish", description="Spanish LibriSpeech dataset"), MultilingualLibrispeechConfig(name="italian", description="Italian LibriSpeech dataset"), MultilingualLibrispeechConfig(name="portuguese", description="Portuguese LibriSpeech dataset"), MultilingualLibrispeechConfig(name="polish", description="Polish LibriSpeech dataset"), ] def _info(self): return datasets.DatasetInfo( description=_DESCRIPTION, features=datasets.Features( { "file": datasets.Value("string"), "audio": datasets.features.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"), homepage=_URL, citation=_CITATION, task_templates=None, ) def _split_generators(self, dl_manager): download_kwargs = { "dl_manager": dl_manager, "root_dir": self.config.data_root_dir } download_transcript = partial( download_extract_transcript, **download_kwargs ) download_audio_non_streaming = partial( download_extract_audio_archives, **download_kwargs ) download_audio_streaming = partial( download_audio_archives, **download_kwargs ) download_limited_ids = partial( download_extract_limited_ids, **download_kwargs ) train_kwargs = { "transcript_path": download_transcript(split="train"), "audio_archives": download_audio_streaming(split="train"), "local_audio_archives_paths": download_audio_non_streaming(split="train") if not dl_manager.is_streaming else None } train_splits = [ datasets.SplitGenerator( name=datasets.Split.TRAIN, gen_kwargs=train_kwargs ), datasets.SplitGenerator( name="train.9h", gen_kwargs={ **train_kwargs, "limited_ids_paths": download_limited_ids(sub_folder="limited_supervision/9hr"), }, ), datasets.SplitGenerator( name="train.1h", gen_kwargs={ **train_kwargs, "limited_ids_paths": download_limited_ids(sub_folder="limited_supervision/1hr"), }, ), ] return train_splits + [ datasets.SplitGenerator( name=datasets.Split.VALIDATION, gen_kwargs={ "transcript_path": download_transcript(split="dev"), "audio_archives": download_audio_streaming(split="dev"), "local_audio_archives_paths": download_audio_non_streaming(split="dev") if not dl_manager.is_streaming else None } ), datasets.SplitGenerator( name=datasets.Split.TEST, gen_kwargs={ "transcript_path": download_transcript(split="test"), "audio_archives": download_audio_streaming(split="test"), "local_audio_archives_paths": download_audio_non_streaming(split="test") if not dl_manager.is_streaming else None } ), ] def _generate_examples(self, transcript_path, audio_archives, local_audio_archives_paths, limited_ids_paths=None): """Generate examples from a Multilingual LibriSpeech data dir.""" transcripts = dict() with open(transcript_path, "r", encoding="utf-8") as file: for line in file: audio_id, transcript = line.strip().split("\t") transcripts[audio_id] = transcript limited_ids, limited_ids_archives_names = [], [] if limited_ids_paths: for path in limited_ids_paths: with open(path, "r", encoding="utf-8") as file: limited_ids.extend([line.strip() for line in file.readlines()]) limited_ids = set(limited_ids) for archive_idx, audio_archive in enumerate(audio_archives): # TODO: check that archive doesn't contain needed ids # if limited_ids and audio_archive not in limited_ids_archives_names: # continue for audio_filename, file in audio_archive: speaker_id, chapter_id = audio_filename.split("_")[:2] speaker_id, chapter_id = int(speaker_id), int(chapter_id) audio_id = audio_filename.split(".flac")[0] audio_transcript = transcripts[audio_id] if limited_ids and audio_id not in limited_ids: # this only can be true in limited supervision sets ("train.9h" and "train.1h") continue path = os.path.join(local_audio_archives_paths[archive_idx], audio_filename)\ if local_audio_archives_paths else audio_filename yield audio_filename, { "file": path if local_audio_archives_paths else None, "audio": {"path": path, "bytes": file.read()}, "text": audio_transcript, "speaker_id": speaker_id, "chapter_id": chapter_id, "id": audio_id } def download_extract_limited_ids(dl_manager, root_dir, sub_folder): """Download handles.txt files containing ids for limited supervision train sets. """ sub_path = os.path.join(root_dir, "train", sub_folder) if sub_folder.endswith("9hr"): limited_ids_paths = [os.path.join(sub_path, "handles.txt")] else: # => sub_folder.endswith("1hr") # in case of 1 hour limited supervision ("train.1h") there are always 6 subfolders like: # "limited_supervision/1h/0/handles.txt", "limited_supervision/1h/1/handles.txt", ... limited_ids_paths = [os.path.join(sub_path, str(i), "handles.txt") for i in range(6)] limited_ids_paths = dl_manager.download(limited_ids_paths) return limited_ids_paths def download_extract_transcript(dl_manager, root_dir, split): """ Download file with audio transcriptions. Return: path (str): path to locally extracted `transcripts.txt` file """ transcript_path = os.path.join(root_dir, split, "transcripts.txt") return dl_manager.download(transcript_path) def download_audio_archive_paths(dl_manager, root_dir, split): # each split contains many .tar.gz archives with its audio files # audio_filenames.txt contains the names of these archives split_dir = os.path.join(root_dir, split) audio_filenames_path = dl_manager.download(os.path.join(split_dir, "audio_filenames.txt")) with open(audio_filenames_path, "r", encoding="utf-8") as file: audio_filenames = [line.strip() for line in file.readlines()] return dl_manager.download([os.path.join(split_dir, "audio", filename) for filename in audio_filenames]) # for non-streaming case def download_extract_audio_archives(dl_manager, root_dir, split): """ Download and extract audio archives locally. Return: archive_paths (List `str`): paths to locally extracted archives """ archive_paths = download_audio_archive_paths(dl_manager, root_dir, split) return [dl_manager.extract(archive_path) for archive_path in archive_paths] # for streaming case def download_audio_archives(dl_manager, root_dir, split): """Prepare archives with audio files for iterating over them. Return: audio_archives (List `Generator`): list of generators to iterate over files in each audio archive. """ archive_paths = download_audio_archive_paths(dl_manager, root_dir, split) return [dl_manager.iter_archive(archive_path) for archive_path in archive_paths]