Removed options that altered text or removed samples, added an option to merge utterances

ESLO.py

@@ -236,28 +236,28 @@ class ESLOConfig(datasets.BuilderConfig):
         super(ESLOConfig, self).__init__(
             version=datasets.Version("2.11.0", ""), name=name, **kwargs
         )
-        if "no_overlap" in name:
-            self.overlap = False
+        self.single_samples = (name == "single_samples")
+        if not self.single_samples:
+            self.max_duration = float(name.split("=")[1][:-1])
         else:
-            self.overlap = True
-        if "no_hesitation" in name:
-            self.hesitation = False
-        else:
-            self.hesitation = True
+            self.max_duration = None
 
 
 class ESLO(datasets.GeneratorBasedBuilder):
     """ESLO dataset."""
 
     BUILDER_CONFIGS = [
-        ESLOConfig(name="no_overlap_no_hesitation", description="ESLO dataset, removed hesitations from samples"
-                                                                " and all samples with overlap"),
-        ESLOConfig(name="no_hesitation", description="ESLO dataset, removed hesitations from samples"),
-        ESLOConfig(name="no_overlap", description="ESLO dataset, removed all samples with overlap"),
-        ESLOConfig(name="raw", description="ESLO dataset"),
+        ESLOConfig(name="single_samples", description="all samples taken separately, can be very short and imprecise"),
+        ESLOConfig(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"),
+
+        ESLOConfig(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 = "no_overlap_no_hesitation"
+    DEFAULT_CONFIG_NAME = "single_samples"
 
     def _info(self):
         return datasets.DatasetInfo(
@@ -319,19 +319,8 @@ class ESLO(datasets.GeneratorBasedBuilder):
                 text += child.tail
         return text
 
-    def clean_text(self, text: str) -> str:
-        def replace_uppercase(match):
-            """replaces BRUNO spelling  by B R U N O"""
-            return ' '.join(match.group(1))
-
-        text = re.sub(r"\bNPERS\b", "", text)
-        text = re.sub(r'\bOK\b', 'ok', text)
-        text = re.sub(r'\b([A-Z]+)\b', replace_uppercase, text)
-        if not self.config.hesitation:
-            text = re.sub(r"(euh)|(hm)|(\b\w*\-\s)", "", text)
-        return re.sub(r" +", " ", text).strip()
-
-    def load_one(self, file) -> List[Utterance]:
+    @staticmethod
+    def load_one(file) -> List[Utterance]:
         first_line = file.readline().decode()
         encoding = re.search(r'encoding=["\']([^"]+)["\']', first_line).group(1)
         text_content = file.read().decode(encoding)
@@ -344,7 +333,6 @@ class ESLO(datasets.GeneratorBasedBuilder):
             start_time = float(turn.get('startTime'))
             end_time = float(turn.get('endTime'))
             text = re.sub(r"[\r\n\s]+", " ", ESLO.extract_text(turn).strip())
-            text = self.clean_text(text)
             if any(c.isalnum() for c in text):
                 utts.append(Utterance(
                     speaker=speaker,
@@ -380,6 +368,34 @@ class ESLO(datasets.GeneratorBasedBuilder):
             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 merge_utterances(utterance1: Utterance, utterance2: Utterance) -> Utterance:
+        return Utterance(
+            speaker="merged",
+            sentence=re.sub(r"\s+", " ", utterance1.sentence + " " + utterance2.sentence),
+            start_timestamp=utterance1.start_timestamp,
+            end_timestamp=utterance2.end_timestamp,
+            overlap=utterance1.overlap or utterance2.overlap
+        )
+
+    def _merged_utterances_iterator(self, utterance_iterator):
+        if self.config.single_samples:
+            yield from utterance_iterator
+        merged_utterance = next(utterance_iterator)
+        start_time = merged_utterance.start_timestamp
+        while True:
+            try:
+                new_utterance = next(utterance_iterator)
+            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
+            else:
+                merged_utterance = ESLO.merge_utterances(merged_utterance, new_utterance)
+
     @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]
@@ -390,9 +406,7 @@ class ESLO(datasets.GeneratorBasedBuilder):
             transcript_name = os.path.splitext(os.path.basename(path))[0]
             audio = self.load_audio(audio_files[transcript_name])
             with open(path, "rb") as file:
-                for utterance in self.load_one(file):
-                    if not self.config.overlap and utterance.overlap:
-                        continue
+                for utterance in self._merged_utterances_iterator(ESLO.load_one(file)):
                     yield f"{transcript_name}_{utterance.start_timestamp}-{utterance.end_timestamp}", {
                         "file": transcript_name,
                         "sentence": utterance.sentence,