update loading script

voxpopuli.py

@@ -1,8 +1,7 @@
 from collections import defaultdict
 import os
-import glob
+import json
 import csv
-from tqdm.auto import tqdm
 
 import datasets
 
@@ -39,15 +38,6 @@ _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"
@@ -56,39 +46,16 @@ _ASR_ACCENTED_LANGUAGES = [
     "en_accented"
 ]
 
-_YEARS = list(range(2009, 2020 + 1))
-
-# unnecessary
-_CONFIG_TO_LANGS = {
-    "400k": _LANGUAGES,
-    "100k": _LANGUAGES,
-    "10k": _LANGUAGES,
-    "asr": _ASR_LANGUAGES,  # + _ASR_ACCENTED_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
-    # _CONFIG_TO_YEARS[lang] = [2020]
-
-for lang in _LANGUAGES_V2:
-    _CONFIG_TO_YEARS[lang] = _YEARS + [f"{y}_2" for y in _YEARS]
-
+_LANGUAGES = _ASR_LANGUAGES + _ASR_ACCENTED_LANGUAGES
 
-_BASE_URL = "https://dl.fbaipublicfiles.com/voxpopuli/"
 
-_DATA_URL = _BASE_URL + "audios/{lang}_{year}.tar"
+_BASE_DATA_DIR = "https://huggingface.co/datasets/polinaeterna/voxpopuli/resolve/main/data/"
 
-_ASR_DATA_URL = _BASE_URL + "audios/original_{year}.tar"
+_N_SHARDS_FILE = _BASE_DATA_DIR + "n_files.json"
 
-_UNLABELLED_META_URL = _BASE_URL + "annotations/unlabelled_v2.tsv.gz"
+_AUDIO_ARCHIVE_PATH = _BASE_DATA_DIR + "{lang}/{split}/{split}_part_{n_shard}.tar.gz"
 
-_ASR_META_URL = _BASE_URL + "annotations/asr/asr_{lang}.tsv.gz"
+_METADATA_PATH = _BASE_DATA_DIR + "{lang}/asr_{split}.tsv"
 
 
 class VoxpopuliConfig(datasets.BuilderConfig):
@@ -101,44 +68,32 @@ class VoxpopuliConfig(datasets.BuilderConfig):
           **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]
+        self.languages = _LANGUAGES if name == "all" else [name]
+        # self.data_root_dis = {lang: _DATA_DIR.format(lang) for lang in self.languages}
 
 
 class Voxpopuli(datasets.GeneratorBasedBuilder):
     """The VoxPopuli dataset."""
 
-    VERSION = datasets.Version("1.3.0")  # not sure
+    VERSION = datasets.Version("1.3.0")  # TODO: version
     BUILDER_CONFIGS = [
         VoxpopuliConfig(
             name=name,
             version=datasets.Version("1.3.0"),
             )
-        for name in _LANGUAGES + _LANGUAGES_V2 + ["10k", "100k", "400k"]
+        for name in _LANGUAGES + ["all"]
     ]
-    # DEFAULT_CONFIG_NAME = "400k"
     DEFAULT_WRITER_BATCH_SIZE = 256  # SET THIS TO A LOWER VALUE IF IT USES TOO MUCH RAM SPACE
 
     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"),
+                "raw_text": datasets.Value("string"),
+                "normalized_text": datasets.Value("string"),
                 "audio": datasets.Audio(sampling_rate=16_000),
-                "segment_id": datasets.Value("int16"),
+                # "segment_id": datasets.Value("int16"),  # TODO
             }
         )
         return datasets.DatasetInfo(
@@ -149,80 +104,80 @@ class Voxpopuli(datasets.GeneratorBasedBuilder):
             citation=_CITATION,
         )
 
-    def _read_metadata_unlabelled(self, metadata_path):
-        #  from https://github.com/facebookresearch/voxpopuli/blob/main/voxpopuli/get_unlabelled_data.py#L34
-        def predicate(id_):
-            is_plenary = id_.find("PLENARY") > -1
-            if self.config.name == "10k":  # in {"10k", "10k_sd"}
-                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)
+        n_shards_path = dl_manager.download_and_extract(_N_SHARDS_FILE)
+        with open(n_shards_path) as f:
+            n_shards = json.load(f)
+
+        audio_urls = defaultdict(dict)
+        for lang in self.config.languages:
+            for split in ["train", "test", "dev"]:
+                audio_urls[split][lang] = [_AUDIO_ARCHIVE_PATH.format(lang=lang, split=split, n_shard=i) for i in range(n_shards[lang][split])]
+
+        meta_urls = defaultdict(dict)
+        for split in ["train", "test", "dev"]:
+            meta_urls[split][lang] = _METADATA_PATH.format(lang=lang, split=split)
 
-        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)
+        # dl_manager.download_config.num_proc = len(urls)
+
+        meta_paths = dl_manager.download_and_extract(meta_urls)
+        audio_paths = dl_manager.download(audio_urls)
+
+        local_extracted_audio_paths = (
+            dl_manager.extract(audio_paths) if not dl_manager.is_streaming else
+            {
+                "train": [None] * len(audio_paths["train"]),
+                "dev": [None] * len(audio_paths["dev"]),
+                "test": [None] * len(audio_paths["test"]),
+            }
+        )
 
         return [
             datasets.SplitGenerator(
                 name=datasets.Split.TRAIN,
                 gen_kwargs={
-                    "data_dirs": data_dirs,
-                    "metadata_path": metadata_path,
+                    "audio_archives": {lang: [dl_manager.iter_archive(archive) for archive in lang_archives] for lang, lang_archives
+                                       in audio_paths["train"].items()},
+                    "local_extracted_audio_archives_paths": local_extracted_audio_paths["train"] if local_extracted_audio_paths else None,
+                    "metadata_paths": meta_paths["train"],
+                }
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.VALIDATION,
+                gen_kwargs={
+                    "audio_archives": {lang: [dl_manager.iter_archive(archive) for archive in lang_archives] for lang, lang_archives
+                                       in audio_paths["dev"].items()},
+                    "local_extracted_audio_archives_paths": local_extracted_audio_paths["dev"] if local_extracted_audio_paths else None,
+                    "metadata_paths": meta_paths["dev"],
+                }
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.TEST,
+                gen_kwargs={
+                    "audio_archives": {lang: [dl_manager.iter_archive(archive) for archive in lang_archives] for lang, lang_archives
+                                       in audio_paths["test"].items()},
+                    "local_extracted_audio_archives_paths": local_extracted_audio_paths["test"] if local_extracted_audio_paths else None,
+                    "metadata_paths": meta_paths["test"],
                 }
             ),
         ]
 
-    def _generate_examples(self, data_dirs, metadata_path):
-        metadata = self._read_metadata_unlabelled(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)
-
-                # split audio on the fly and yield segments as arrays - they will be converted to bytes by Audio feature
-                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],  # segment is a 2-dim array
-                            "sampling_rate": 16_000
-                        },
-                        "segment_id": segment_id,
-                    }
+    def _generate_examples(self, audio_archives, local_extracted_audio_archives_paths, metadata_paths):
+        assert len(metadata_paths) == len(audio_archives)
+
+        for lang in self.config.languages:
+            meta_path = metadata_paths[lang]
+            with open(meta_path) as f:
+                metadata = {x["id"]: x for x in csv.DictReader(f, delimiter="\t")}
+
+            for audio_archive, local_extracted_audio_archive_path in zip(audio_archives[lang], local_extracted_audio_archives_paths[lang]):
+                for audio_filename, audio_file in audio_archive:
+                    audio_id = audio_filename.split(os.sep)[-1].split(".wav")[0]
+                    path = os.path.join(local_extracted_audio_archive_path, audio_filename) if local_extracted_audio_archive_path else audio_filename
+                    yield audio_id, {
+                        "path": path,
+                        "language": lang,
+                        "raw_text": metadata[audio_id]["raw_text"],
+                        "normalized_text": metadata[audio_id]["normalized_text"],
+                        "audio": {"path": path, "bytes": audio_file.read()}
+                    }