Create multilingual-TEDX-fr

multilingual-TEDX-fr

@@ -0,0 +1,232 @@
+import os
+import re
+from ctypes import Array
+from dataclasses import dataclass
+from typing import List, Tuple
+from pathlib import Path
+import xml.etree.ElementTree as ET
+import ffmpeg
+import csv
+import datasets
+import numpy as np
+
+_CITATION = """\
+  @inproceedings{salesky2021mtedx,
+    title={Multilingual TEDx Corpus for Speech Recognition and Translation},
+    author={Elizabeth Salesky and Matthew Wiesner and Jacob Bremerman and Roldano Cattoni and Matteo Negri and Marco Turchi and Douglas W. Oard and Matt Post},
+    booktitle={Proceedings of Interspeech},
+    year={2021},
+  }
+"""
+
+_DESCRIPTION = """\
+French subpart of the multilingual TEDX dataset 
+"""
+SAMPLING_RATE = 16_000
+
+@dataclass
+class Utterance:
+    speaker_id: str
+    index: int
+    sentence: str
+    start_timestamp: float
+    end_timestamp: float
+
+
+class TEDXConfig(datasets.BuilderConfig):
+    """BuilderConfig for TEDX."""
+
+    def __init__(self, name, **kwargs):
+        """
+        Args:
+          name: `string`, name of dataset config (=language)
+          **kwargs: keyword arguments forwarded to super.
+        """
+        super(TEDXConfig, self).__init__(
+            version=datasets.Version("2.14.5", ""), name=name, **kwargs
+        )
+        self.single_samples = (name == "single_samples")
+        self.max = (name == "max")
+        if not self.single_samples and not self.max:
+            self.max_duration = float(name.split("=")[1][:-1])
+        else:
+            self.max_duration = np.inf
+
+
+class TEDX(datasets.GeneratorBasedBuilder):
+
+    BUILDER_CONFIGS = [
+        TEDXConfig(name="single_samples", description="all samples taken separately, can be very short and imprecise"),
+        TEDXConfig(name="max", description="all samples of a talk are merged together"),
+        TEDXConfig(name="max=30s", description="samples are merged in order to reach a max duration of 30 seconds."
+                                               "Does not remove single utterances that may exceed "
+                                               "the maximum duration"),
+
+        TEDXConfig(name="max=10s", description="samples are merged in order to reach a max duration of 10 seconds"
+                                               "Does not remove single utterances that may exceed "
+                                               "the maximum duration"),
+    ]
+
+    DEFAULT_CONFIG_NAME = "single_samples"
+
+    def _info(self):
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=datasets.Features(
+                {
+                    "file": datasets.Value("string"),
+                    "audio": datasets.features.Audio(sampling_rate=SAMPLING_RATE),
+                    "sentence": datasets.Value("string"),
+                    "speaker_id": datasets.Value("string"),
+                    "start_timestamp": datasets.Value("float"),
+                    "end_timestamp": datasets.Value("float"),
+                    "index": datasets.Value("int32"),
+                }
+            ),
+            citation=_CITATION,
+        )
+
+    def _split_by_audio_file(self, segments_path: str, sentences_path: str, split_name: str) -> Tuple[List[str], List[List[Utterance]]]:
+        speaker_paths = []
+        seen_ids = {}
+        segments = []
+        with open(segments_path, "r") as segments, open(sentences_path) as sentences:
+            segments_reader = csv.DictReader(segments, delimiter=' ', fieldnames=["segment_id", "speaker_id", "start_timestamp", "end_timestamp"])
+            sentences_list = sentences.readlines()
+            for segment, sentence in zip(segments_reader, sentences_list):
+                if segment["speaker_id"] not in seen_ids:
+                    seen_ids.add(segment["speaker_id"])
+                    speaker_paths.append(Path("data") / Path(split_name) / Path("wav") / Path(f"{segment['speaker_id']}.flac"))
+                    segments.append([])
+                segments[-1].append(Utterance(speaker_id=segment["speaker_id"],
+                                              index=int(segment["segment_id"].split("_")[1]),
+                                              sentence=sentence,
+                                              start_timestamp=segment["segment_start_timestamp"],
+                                              end_timestamp=segment["segment_end_timestamp"]
+                                              ))
+        return speaker_paths, segments
+                
+
+
+    def _split_generators(self, dl_manager):
+        segments = {
+            "train": dl_manager.download("data/train/txt/segments"),
+            "test": dl_manager.download("data/test/txt/segments"),
+            "dev": dl_manager.download("data/dev/txt/segments")
+        }
+        sentences = {
+            "train": dl_manager.download("data/train/txt/train.fr"),
+            "test": dl_manager.download("data/test/txt/test.fr"),
+            "dev": dl_manager.download("data/dev/txt/dev.fr"),
+        }
+
+        splitted_dataset = {}
+        segments = dl_manager.download(segments)
+        sentences = dl_manager.download(sentences)
+        print(segments)
+        for split in segments:
+            audios_path, utterances = self._split_by_audio_file(segments[split], sentences[split], split)
+            audios_path = dl_manager.download(audios_path)
+            splitted_dataset[split] = {
+                "audios_path": audios_path,
+                "utterances": utterances
+                }
+
+        splits = [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs= splitted_dataset["train"]
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.TEST,
+                gen_kwargs=splitted_dataset["test"]
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.VALIDATION,
+                gen_kwargs=splitted_dataset["test"]
+            ),
+        ]
+
+        return splits
+    
+    @staticmethod
+    def merge_utterances(utterance1: Utterance, utterance2: Utterance) -> Utterance:
+        assert(utterance1.speaker_id == utterance2.speaker_id)
+        assert(utterance2.index > utterance1.index)
+        return Utterance(
+            speaker_id=utterance1.speaker_id,
+            sentence=re.sub(r"\s+", " ", utterance1.sentence + " " + utterance2.sentence),
+            start_timestamp=utterance1.start_timestamp,
+            end_timestamp=utterance2.end_timestamp,
+            index = utterance1.index
+        )
+
+
+
+    def _merged_utterances_iterator(self, utterances: List[Utterance]):
+        utterances = iter(utterances)
+        if self.config.single_samples:
+            yield from utterances
+        merged_utterance = next(utterances)
+        start_time = merged_utterance.start_timestamp
+        while True:
+            try:
+                new_utterance = next(utterances)
+            except StopIteration:
+                yield merged_utterance
+                break
+            end_time = new_utterance.end_timestamp
+            if end_time - start_time > self.config.max_duration:
+                yield merged_utterance
+                merged_utterance = new_utterance
+                start_time = merged_utterance.start_timestamp
+            else:
+                merged_utterance = TEDX.merge_utterances(merged_utterance, new_utterance)
+
+
+
+    @staticmethod
+    def load_audio(file: str, sr: int = SAMPLING_RATE):
+        """
+        Open an audio file and read as mono waveform, resampling as necessary
+        Parameters
+        ----------
+        file:vThe audio file to read
+        sr: int
+            The sample rate to resample the audio if necessary
+        Returns
+        -------
+        A NumPy array containing the audio waveform, in float32 dtype.
+        """
+        try:
+            # This launches a subprocess to decode audio while down-mixing and resampling as necessary.
+            # Requires the ffmpeg CLI and `ffmpeg-python` package to be installed.
+            out, _ = (
+                ffmpeg.input(file)
+                .output('-', format='s16le', acodec='pcm_s16le', ac=1, ar=sr)
+                .run(capture_stdout=True, capture_stderr=True)
+            )
+        except ffmpeg.Error as e:
+            raise RuntimeError(f"Failed to load audio: {e.stderr.decode()}") from e
+        return np.frombuffer(out, np.int16).flatten().astype(np.float32) / 32768.0
+
+    @staticmethod
+    def _cut_audio(audio: Array, start_timestamp: float, end_timestamp: float):
+        return audio[int(round(start_timestamp * SAMPLING_RATE)): int(round(end_timestamp * SAMPLING_RATE)) + 1]
+
+    def _generate_examples(self, audios_path: List[str], utterances: List[List[Utterance]]):
+        """Generate examples from a Multilingual LibriSpeech data dir."""
+        for audio_path, utterances in zip(audios_path, utterances):
+            audio = self.load_audio(audio_path)
+            for utterance in self._merged_utterances_iterator(utterances):
+                transcript_name = f"{utterance.speaker_id}-{utterance.index}"
+                yield transcript_name, {
+                    "file": transcript_name,
+                    "index": utterance.index,
+                    "sentence": utterance.sentence,
+                    "start_timestamp": utterance.start_timestamp,
+                    "end_timestamp": utterance.end_timestamp,
+                    "speaker_id": utterance.speaker_id,
+                    "audio": {"path": transcript_name,
+                                "array": self._cut_audio(audio, utterance.start_timestamp, utterance.end_timestamp),
+                                "sampling_rate": SAMPLING_RATE}}