Update multilingual-TEDX-fr.py

multilingual-TEDX-fr.py

@@ -1,19 +1,20 @@
-import os
 import re
 from ctypes import Array
 from itertools import cycle
 from dataclasses import dataclass
 from typing import List, Tuple
 from pathlib import Path
-import xml.etree.ElementTree as ET
 import csv
 import datasets
 import numpy as np
+
 try:
     import ffmpeg
+
     FFMPEG_AVAILABLE = True
 except (ImportError, ModuleNotFoundError):
     import librosa
+
     FFMPEG_AVAILABLE = False
 
 _CITATION = """\
@@ -30,6 +31,7 @@ French subpart of the multilingual TEDX dataset
 """
 SAMPLING_RATE = 16_000
 
+
 @dataclass
 class Utterance:
     speaker_id: str
@@ -51,30 +53,33 @@ class TEDXConfig(datasets.BuilderConfig):
         super(TEDXConfig, self).__init__(
             version=datasets.Version("2.14.5", ""), name=name, **kwargs
         )
-        self.single_samples = (name == "single_samples")
         self.max = (name == "max")
-        self.random = (name == "random_merge")
-        if not self.single_samples and not self.max and not self.random:
+        self.single_samples = (name == "single_samples")
+        self.all_merge = (name == "all_merge")
+        if not self.max and not self.all_merge and not self.single_samples:
             self.max_duration = float(name.split("=")[1][:-1])
+        else:
+            self.max_duration = np.inf
+
 
 class TEDX(datasets.GeneratorBasedBuilder):
-    
     random_max_durations = cycle([8, 4, 10, 5, 13, 23, 6, 19, 24, 7, 26, 27, 20, 14, 1, 25, 21, 22,
                                   9, 12, 11, 2, 30, 15, 28, 17, 18, 29, 16, 3])
 
     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."
+        TEDXConfig(name="max=30s", description="(sliding window) 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"
+        TEDXConfig(name="max=10s", description="(sliding window) samples are merged in order to reach a max duration "
+                                               "of 10 seconds"
                                                "Does not remove single utterances that may exceed "
                                                "the maximum duration"),
-        TEDXConfig(name="random_merge", description="samples are merged in order to reach a random max duration between 1 and 30 seconds"
-                                       "Does not remove single utterances that may exceed "
-                                       "the maximum duration"),
+        TEDXConfig(name="all_merge",
+                    description="all consecutive samples are merged, this greatly increases dataset size"),
     ]
 
     DEFAULT_CONFIG_NAME = "single_samples"
@@ -90,33 +95,37 @@ class TEDX(datasets.GeneratorBasedBuilder):
                     "speaker_id": datasets.Value("string"),
                     "start_timestamp": datasets.Value("float"),
                     "end_timestamp": datasets.Value("float"),
-                    "index": datasets.Value("int32"),
+                    "start_index": datasets.Value("int32"),
+                    "end_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]]]:
+    @staticmethod
+    def _split_by_audio_file(segments_path: str, sentences_path: str, split_name: str) -> Tuple[
+        List[str], List[List[Utterance]]]:
         speaker_paths = []
         seen_ids = set()
         segments_by_speaker = []
         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"])
+            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"))
+                    speaker_paths.append(
+                        Path("data") / Path(split_name) / Path("wav") / Path(f"{segment['speaker_id']}.flac"))
                     segments_by_speaker.append([])
                 segments_by_speaker[-1].append(Utterance(speaker_id=segment["speaker_id"],
-                                              index=int(segment["segment_id"].split("_")[-1]),
-                                              sentence=sentence,
-                                              start_timestamp=float(segment["start_timestamp"]),
-                                              end_timestamp=float(segment["end_timestamp"])
-                                              ))
+                                                         index=int(segment["segment_id"].split("_")[-1]),
+                                                         sentence=sentence,
+                                                         start_timestamp=float(segment["start_timestamp"]),
+                                                         end_timestamp=float(segment["end_timestamp"])
+                                                         ))
         return speaker_paths, segments_by_speaker
-                
-
 
     def _split_generators(self, dl_manager):
         segments = {
@@ -139,12 +148,12 @@ class TEDX(datasets.GeneratorBasedBuilder):
             splitted_dataset[split] = {
                 "audios_path": audios_path,
                 "utterances": utterances
-                }
+            }
 
         splits = [
             datasets.SplitGenerator(
                 name=datasets.Split.TRAIN,
-                gen_kwargs= splitted_dataset["train"]
+                gen_kwargs=splitted_dataset["train"]
             ),
             datasets.SplitGenerator(
                 name=datasets.Split.TEST,
@@ -157,50 +166,36 @@ class TEDX(datasets.GeneratorBasedBuilder):
         ]
 
         return splits
-        
-    def get_max_duration(self) -> float:
-        if self.config.max:
-            return np.inf
-        if self.config.random:
-            return next(self.random_max_durations)
-        return self.config.max_duration
-        
+
     @staticmethod
     def merge_utterances(utterance1: Utterance, utterance2: Utterance) -> Utterance:
-        assert(utterance1.speaker_id == utterance2.speaker_id)
-        assert(utterance2.index > utterance1.index)
+        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
+            index=utterance1.index
         )
 
-
-
-    def _merged_utterances_iterator(self, utterances: List[Utterance]):
-        utterances = iter(utterances)
-        if self.config.single_samples:
-            yield from utterances
-            return
-        merged_utterance = next(utterances)
-        start_time = merged_utterance.start_timestamp
-        while True:
-            try:
-                new_utterance = next(utterances)
-            except StopIteration:
-                yield merged_utterance
-                return
-            end_time = new_utterance.end_timestamp
-            if end_time - start_time > self.get_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)
-
-
+    def _merged_utterances_iterator(self, samples: List[Utterance]):
+        for i, start_sample in enumerate(samples):
+            merged_sample = start_sample
+            if self.config.single_samples:
+                yield start_sample
+                continue
+            for j, other_sample in enumerate(samples[i + 1:]):
+                new_duration = other_sample.end_timestamp - merged_sample.start_timestamp
+                if self.config.all_merge:
+                    yield merged_sample
+                if new_duration > self.config.max_duration:
+                    yield merged_sample
+                    break
+                merged_sample = TEDX.merge_utterances(merged_sample, other_sample)
+            if self.config.max:
+                yield merged_sample
+                break
 
     @staticmethod
     def load_audio(file: str, sr: int = SAMPLING_RATE):
@@ -215,8 +210,8 @@ class TEDX(datasets.GeneratorBasedBuilder):
         -------
         A NumPy array containing the audio waveform, in float32 dtype.
         """
-        #import librosa
-        #with open(file, "rb") as f:
+        # import librosa
+        # with open(file, "rb") as f:
         #    return librosa.load(f, sr=sr)
         if FFMPEG_AVAILABLE:
             try:
@@ -234,7 +229,6 @@ class TEDX(datasets.GeneratorBasedBuilder):
             with open(file, "rb") as f:
                 return librosa.load(f, sr=sr)[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]
@@ -255,5 +249,5 @@ class TEDX(datasets.GeneratorBasedBuilder):
                     "end_timestamp": end_timestamp,
                     "speaker_id": utterance.speaker_id,
                     "audio": {"path": transcript_name,
-                                "array": self._cut_audio(audio, start_timestamp, end_timestamp),
-                                "sampling_rate": SAMPLING_RATE}}
+                              "array": self._cut_audio(audio, start_timestamp, end_timestamp),
+                              "sampling_rate": SAMPLING_RATE}}