Add methods `_remove_to_long_pauses` and `_filter_utterances_by_duration`

chall.py

@@ -20,14 +20,20 @@ logger = logging.get_logger(__name__)
 class ChallConfig(BuilderConfig):
 
     split_segments: bool = False
+
+    # settings that can only be used together with split_segments
     max_chunk_length: Union[float, None] = None
-    remove_trailing_pauses: bool = None
+    min_chunk_length: Union[float, None] = None
+    max_pause_length: Union[float, None] = None
+    remove_trailing_pauses: bool = False
 
     def __init__(self, **kwargs):
-        self.split_segments = kwargs.pop("split_segments", False)
-        # settings that can only be used together with split_segments
-        self.max_chunk_length = kwargs.pop("max_chunk_length", None)
-        self.remove_trailing_pauses = kwargs.pop("remove_trailing_pauses", False)
+        self.split_segments = kwargs.pop("split_segments", ChallConfig.split_segments)
+        self.remove_trailing_pauses = kwargs.pop("remove_trailing_pauses", ChallConfig.remove_trailing_pauses)
+        self.max_chunk_length = kwargs.pop("max_chunk_length", ChallConfig.max_chunk_length)
+        self.min_chunk_length = kwargs.pop("min_chunk_length", ChallConfig.min_chunk_length)
+        self.max_pause_length = kwargs.pop("max_pause_length", ChallConfig.max_pause_length)
+
         super(ChallConfig, self).__init__(**kwargs)
 
 
@@ -56,7 +62,10 @@ class Chall(GeneratorBasedBuilder):
         ChallConfig(
             name="asr_acl",
             split_segments=True,
+            max_pause_length=12,
             max_chunk_length=12,
+            min_chunk_length=0.5,
+            remove_trailing_pauses=True,
             description="Settings used for the paper."
         )
     ]
@@ -97,10 +106,14 @@ class Chall(GeneratorBasedBuilder):
 
     def _info(self) -> DatasetInfo:
         """
-        This method specifies the datasets.DatasetInfo object which contains informations and typings for the dataset
+        This method specifies the datasets.DatasetInfo object which contains information and typings for the dataset
         :return: The DatasetInfo object
         """
 
+        # todo text (make word = timestamps)
+        # todo duration
+        # todo tasks
+
         if self.config.split_segments:
             features = Features({
                 "audio_id": Value("string"),  # todo maybe shorten to id
@@ -234,12 +247,18 @@ class Chall(GeneratorBasedBuilder):
 
         segments = transcript.get("segments", [])
 
+        if self.config.max_pause_length:
+            segments = self._remove_to_long_pauses(segments)
+
         if self.config.max_chunk_length is not None:
             segments = self._split_long_utterances(segments)
 
         if self.config.remove_trailing_pauses:
             self._remove_trailing_pauses_in_segments(segments)
 
+        if self.config.max_pause_length is not None:
+            segments = self._filter_utterances_by_duration(segments, self.config.min_chunk_length, self.config.max_chunk_length)
+
         for segment_i, segment in enumerate(segments):
 
             id_ = f"{audio_id}_{str(segment_i).rjust(3, '0')}"
@@ -271,9 +290,15 @@ class Chall(GeneratorBasedBuilder):
 
             yield id_, data
 
-    def _remove_trailing_pauses_in_segments(self, segments: List[dict]) -> None:
+    @staticmethod
+    def _remove_trailing_pauses_in_segments(segments: List[dict]) -> None:
         """
         Removes pauses at the end/start of utterances in each segment to eliminate pauses between segments.
+
+        Example:
+            [["Hello", "World!", "(...)"]] --> [["Hello"], ["World!"]]
+            [["(...)", "Hello", "World!"]] --> [["Hello"], ["World!"]]
+
         :return: A list of Word objects representing the removed pause indicators from the segments.
         """
         for segment in segments:
@@ -286,9 +311,59 @@ class Chall(GeneratorBasedBuilder):
             if not segment["words"]:
                 segments.remove(segment)
 
+    def _remove_to_long_pauses(self, segments: List[dict]) -> List[dict]:
+        """
+        Remove to long pauses in a segment by splitting the segment in two segments and removing the filled pause.
+
+        Example (assuming (...) is longer than max_pause_length):
+            [["Hello", "(...)", "World!"]] --> [["Hello"], ["World!"]]
+
+        :return: List of segments with long pauses removed
+        """
+
+        split_segments = []
+        for segment in segments:
+            if any(w["end"]-w["start"] >= self.config.max_pause_length and w["text"].strip() == "(...)" for w in segment["words"]):
+                start_i = 0
+                for i, word in enumerate(segment["words"]):
+                    w_duration = word["end"] - word["start"]
+                    if w_duration >= self.config.max_pause_length and word["text"].strip() == "(...)":
+                        if len(segment["words"][start_i:i]) > 0:
+                            split_segments.append({"speaker": segment["speaker"], "words": segment["words"][start_i:i]})
+                        start_i = i+1
+
+                if len(segment["words"][start_i:]) > 0:
+                    split_segments.append({"speaker": segment["speaker"], "words": segment["words"][start_i:]})
+            else:
+                split_segments.append(segment)
+        return split_segments
+
+    @staticmethod
+    def _filter_utterances_by_duration(segments: List[dict], min_duration: float = None, max_duration: float = None, ):
+        """
+        Removes segments with invalid duration
+        :param min_duration: The minimum duration allowed for a segment.
+        :return: A list of removed short segments.
+        """
+
+        filtered_segments = []
+        for segment in segments:
+            duration = segment["words"][-1]["end"] - segment["words"][0]["start"]
+            if min_duration is not None and duration < min_duration:
+                continue
+            if max_duration is not None and duration > max_duration:
+                continue
+            filtered_segments.append(segment)
+
+        return filtered_segments
+
     def _split_long_utterances(self, segments: List[dict]) -> List[dict]:
         """
         Splits segments into smaller chunks if their duration exceeds the maximum chunk length specified in the config.
+
+        Example (assuming each word is longer than max_duration):
+            [["Hello", "World!"]] --> [["Hello"], ["World!"]]
+
         :param segments: List of original segments from the transcript.
         :return: List of adjusted segments, potentially split into smaller chunks.
         """