|
from collections import defaultdict |
|
import os |
|
import glob |
|
import csv |
|
from tqdm.auto import tqdm |
|
|
|
import datasets |
|
|
|
|
|
_DESCRIPTION = """ |
|
A large-scale multilingual speech corpus for representation learning, semi-supervised learning and interpretation. |
|
""" |
|
|
|
_CITATION = """ |
|
@inproceedings{wang-etal-2021-voxpopuli, |
|
title = "{V}ox{P}opuli: A Large-Scale Multilingual Speech Corpus for Representation Learning, |
|
Semi-Supervised Learning and Interpretation", |
|
author = "Wang, Changhan and |
|
Riviere, Morgane and |
|
Lee, Ann and |
|
Wu, Anne and |
|
Talnikar, Chaitanya and |
|
Haziza, Daniel and |
|
Williamson, Mary and |
|
Pino, Juan and |
|
Dupoux, Emmanuel", |
|
booktitle = "Proceedings of the 59th Annual Meeting of the Association for Computational Linguistics |
|
and the 11th International Joint Conference on Natural Language Processing (Volume 1: Long Papers)", |
|
month = aug, |
|
year = "2021", |
|
publisher = "Association for Computational Linguistics", |
|
url = "https://aclanthology.org/2021.acl-long.80", |
|
doi = "10.18653/v1/2021.acl-long.80", |
|
pages = "993--1003", |
|
} |
|
""" |
|
|
|
_HOMEPAGE = "https://github.com/facebookresearch/voxpopuli" |
|
|
|
_LICENSE = "CC0, also see https://www.europarl.europa.eu/legal-notice/en/" |
|
|
|
|
|
_LANGUAGES = sorted( |
|
[ |
|
"en", "de", "fr", "es", "pl", "it", "ro", "hu", "cs", "nl", "fi", "hr", |
|
"sk", "sl", "et", "lt", "pt", "bg", "el", "lv", "mt", "sv", "da" |
|
] |
|
) |
|
_LANGUAGES_V2 = [f"{x}_v2" for x in _LANGUAGES] |
|
|
|
_ASR_LANGUAGES = [ |
|
"en", "de", "fr", "es", "pl", "it", "ro", "hu", "cs", "nl", "fi", "hr", |
|
"sk", "sl", "et", "lt" |
|
] |
|
_ASR_ACCENTED_LANGUAGES = [ |
|
"en_accented" |
|
] |
|
|
|
_YEARS = list(range(2009, 2020 + 1)) |
|
|
|
|
|
_CONFIG_TO_LANGS = { |
|
"400k": _LANGUAGES, |
|
"100k": _LANGUAGES, |
|
"10k": _LANGUAGES, |
|
"asr": _ASR_LANGUAGES, |
|
} |
|
|
|
_CONFIG_TO_YEARS = { |
|
"400k": _YEARS + [f"{y}_2" for y in _YEARS], |
|
"100k": _YEARS, |
|
"10k": [2019, 2020], |
|
"asr": _YEARS, |
|
} |
|
for lang in _LANGUAGES: |
|
_CONFIG_TO_YEARS[lang] = _YEARS |
|
|
|
|
|
for lang in _LANGUAGES_V2: |
|
_CONFIG_TO_YEARS[lang] = _YEARS + [f"{y}_2" for y in _YEARS] |
|
|
|
|
|
_BASE_URL = "https://dl.fbaipublicfiles.com/voxpopuli/" |
|
|
|
_DATA_URL = _BASE_URL + "audios/{lang}_{year}.tar" |
|
|
|
_ASR_DATA_URL = _BASE_URL + "audios/original_{year}.tar" |
|
|
|
_UNLABELLED_META_URL = _BASE_URL + "annotations/unlabelled_v2.tsv.gz" |
|
|
|
_ASR_META_URL = _BASE_URL + "annotations/asr/asr_{lang}.tsv.gz" |
|
|
|
|
|
class VoxpopuliConfig(datasets.BuilderConfig): |
|
"""BuilderConfig for VoxPopuli.""" |
|
|
|
def __init__(self, name, **kwargs): |
|
""" |
|
Args: |
|
name: `string`, name of dataset config |
|
**kwargs: keyword arguments forwarded to super. |
|
""" |
|
super().__init__(name=name, **kwargs) |
|
name = name.split("_")[0] |
|
self.languages = [name] if name in _LANGUAGES else _CONFIG_TO_LANGS[name] |
|
self.years = _CONFIG_TO_YEARS[name] |
|
|
|
|
|
class Voxpopuli(datasets.GeneratorBasedBuilder): |
|
"""The VoxPopuli dataset.""" |
|
|
|
VERSION = datasets.Version("1.3.0") |
|
BUILDER_CONFIGS = [ |
|
VoxpopuliConfig( |
|
name=name, |
|
version=datasets.Version("1.3.0"), |
|
) |
|
for name in _LANGUAGES + _LANGUAGES_V2 + ["10k", "100k", "400k"] |
|
] |
|
|
|
DEFAULT_WRITER_BATCH_SIZE = 256 |
|
|
|
def _info(self): |
|
try: |
|
import torch |
|
import torchaudio |
|
except ImportError as e: |
|
raise ValueError( |
|
f"{str(e)}.\n" + |
|
"Loading voxpopuli requires `torchaudio` to be installed." |
|
"You can install torchaudio with `pip install torchaudio`." |
|
) |
|
global torchaudio |
|
|
|
features = datasets.Features( |
|
{ |
|
"path": datasets.Value("string"), |
|
"language": datasets.ClassLabel(names=_LANGUAGES), |
|
"year": datasets.Value("int16"), |
|
"audio": datasets.Audio(sampling_rate=16_000), |
|
"segment_id": datasets.Value("int16"), |
|
} |
|
) |
|
return datasets.DatasetInfo( |
|
description=_DESCRIPTION, |
|
features=features, |
|
homepage=_HOMEPAGE, |
|
license=_LICENSE, |
|
citation=_CITATION, |
|
) |
|
|
|
def _read_metadata_unlabelled(self, metadata_path): |
|
|
|
def predicate(id_): |
|
is_plenary = id_.find("PLENARY") > -1 |
|
if self.config.name == "10k": |
|
return is_plenary and 20190101 <= int(id_[:8]) < 20200801 |
|
elif self.config.name == "100k": |
|
return is_plenary |
|
elif self.config.name in _LANGUAGES: |
|
return is_plenary and id_.endswith(self.config.name) |
|
elif self.config.name in _LANGUAGES_V2: |
|
return id_.endswith(self.config.name.split("_")[0]) |
|
return True |
|
|
|
metadata = defaultdict(list) |
|
|
|
with open(metadata_path, encoding="utf-8") as csv_file: |
|
csv_reader = csv.reader(csv_file, delimiter="\t") |
|
for i, row in tqdm(enumerate(csv_reader)): |
|
if i == 0: |
|
continue |
|
event_id, segment_id, start, end = row |
|
_, lang = event_id.rsplit("_", 1)[-2:] |
|
if lang in self.config.languages and predicate(event_id): |
|
metadata[event_id].append((float(start), float(end))) |
|
|
|
return metadata |
|
|
|
def _read_metadata_asr(self, metadata_paths): |
|
pass |
|
|
|
def _split_generators(self, dl_manager): |
|
metadata_path = dl_manager.download_and_extract(_UNLABELLED_META_URL) |
|
|
|
urls = [_DATA_URL.format(lang=language, year=year) for language in self.config.languages for year in self.config.years] |
|
dl_manager.download_config.num_proc = len(urls) |
|
data_dirs = dl_manager.download_and_extract(urls) |
|
|
|
return [ |
|
datasets.SplitGenerator( |
|
name=datasets.Split.TRAIN, |
|
gen_kwargs={ |
|
"data_dirs": data_dirs, |
|
"metadata_path": metadata_path, |
|
} |
|
), |
|
] |
|
|
|
def _generate_examples(self, data_dirs, metadata_path): |
|
metadata = self._read_metadata(metadata_path) |
|
|
|
for data_dir in data_dirs: |
|
for file in glob.glob(f"{data_dir}/**/*.ogg", recursive=True): |
|
path_components = file.split(os.sep) |
|
language, year, audio_filename = path_components[-3:] |
|
audio_id, _ = os.path.splitext(audio_filename) |
|
if audio_id not in metadata: |
|
continue |
|
timestamps = metadata[audio_id] |
|
|
|
waveform, sr = torchaudio.load(file) |
|
duration = waveform.size(1) |
|
|
|
|
|
for segment_id, (start, stop) in enumerate(timestamps): |
|
segment = waveform[:, int(start * sr): min(int(stop * sr), duration)] |
|
|
|
yield f"{audio_filename}_{segment_id}", { |
|
"path": file, |
|
"language": language, |
|
"year": year, |
|
"audio": { |
|
"array": segment[0], |
|
"sampling_rate": 16_000 |
|
}, |
|
"segment_id": segment_id, |
|
} |
|
|
