Update `num_to_words`, `filter_and_clean_text` & `preprocess_text` and add `map_special_terms`

chall.py

@@ -1,12 +1,13 @@
 import json
 import os
-from typing import Union, List
+import re
+import string
+from typing import Union, List, Dict
 from datasets import DatasetInfo, BuilderConfig, GeneratorBasedBuilder, Version, Features, Value, Audio, SplitGenerator, Split, logging
 from datasets.features import Sequence
 import soundfile as sf
 import importlib.util
 
-
 _SAMPLE_RATE = 16000
 
 _DESCRIPTION = "tbd"
@@ -22,17 +23,32 @@ class ChallConfig(BuilderConfig):
     split_segments: bool = False
 
     # settings that can only be used together with split_segments
-    max_chunk_length: Union[float, None] = None
-    min_chunk_length: Union[float, None] = None
-    max_pause_length: Union[float, None] = None
+    max_chunk_length: Union[float, None]
+    min_chunk_length: Union[float, None]
+    max_pause_length: Union[float, None]
     remove_trailing_pauses: bool = False
 
+    lowercase: bool
+    num_to_words: bool
+    allowed_chars: set
+    special_terms_mapping: dict
+
     def __init__(self, **kwargs):
-        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)
+        self.split_segments = kwargs.pop("split_segments", False)
+        self.remove_trailing_pauses = kwargs.pop("remove_trailing_pauses", False)
+
+        self.max_chunk_length = kwargs.pop("max_chunk_length", None)
+        self.min_chunk_length = kwargs.pop("min_chunk_length", None)
+        self.max_pause_length = kwargs.pop("max_pause_length", None)
+
+        self.lowercase = kwargs.pop("lowercase", True)
+        self.num_to_words = kwargs.pop("num_to_words", True)
+        self.special_terms_mapping = kwargs.pop("special_terms_mapping", {})
+
+        if self.lowercase:
+            self.allowed_chars = set(string.ascii_lowercase + " äöü'")
+        else:
+            self.allowed_chars: set = set(string.ascii_lowercase + string.ascii_uppercase + " ÄÖÜäöü'")
 
         super(ChallConfig, self).__init__(**kwargs)
 
@@ -66,6 +82,8 @@ class Chall(GeneratorBasedBuilder):
             max_chunk_length=12,
             min_chunk_length=0.5,
             remove_trailing_pauses=True,
+            lowercase=True,
+            num_to_words=True,
             description="Settings used for the paper."
         )
     ]
@@ -86,7 +104,6 @@ class Chall(GeneratorBasedBuilder):
         """
         self._check_dependencies()
         super().__init__(**kwargs)
-        print(self.config)
 
     @staticmethod
     def _check_dependencies() -> None:
@@ -122,6 +139,8 @@ class Chall(GeneratorBasedBuilder):
                 "area_of_school_code": Value("int32"),
                 "background_noise": Value("bool"),
                 "speaker": Value("string"),
+                "raw_text": Value("string"),
+                "clear_text": Value("string"),
                 "words": Sequence(
                     {
                         "start": Value("float"),
@@ -138,6 +157,8 @@ class Chall(GeneratorBasedBuilder):
                 "intervention": Value("int32"),
                 "school_grade": Value("string"),
                 "area_of_school_code": Value("int32"),
+                "raw_text": Value("string"),
+                "clear_text": Value("string"),
                 "participants": Sequence(
                     {
                         "pseudonym": Value("string"),
@@ -243,8 +264,7 @@ class Chall(GeneratorBasedBuilder):
                 else:
                     yield from self._generate_transcript_examples(audio_id, str(audio_file_path), row, transcript)
 
-    @staticmethod
-    def _generate_transcript_examples(audio_id: str, audio_file_path: str, data: dict, transcript: dict):
+    def _generate_transcript_examples(self, audio_id: str, audio_file_path: str, data: dict, transcript: dict):
         """
         Generates examples based on the entire audio file and its associated transcript metadata. This method reads the
         entire audio file, extracts speaker and segment information from the transcript, and packages these along with
@@ -261,6 +281,9 @@ class Chall(GeneratorBasedBuilder):
         transcript_data["speakers"] = transcript.get("speakers", [])
         transcript_data["segments"] = transcript.get("segments", [])
 
+        transcript_data["raw_text"] = raw_text = self.get_raw_text([word for segment in transcript["segments"] for word in segment["words"]])
+        transcript_data["clear_text"] = self.get_clear_text(raw_text)
+
         with sf.SoundFile(audio_file_path) as audio_file:
             audio = audio_file.read(dtype='float32')
 
@@ -295,6 +318,9 @@ class Chall(GeneratorBasedBuilder):
                 segment_data["speaker_id"] = segment["speaker"]
                 segment_data["words"] = segment["words"]
 
+                segment_data["raw_text"] = raw_text = self.get_raw_text(segment["words"])
+                segment_data["clear_text"] = self.get_clear_text(raw_text)
+
                 start_time = segment["words"][0]["start"]
                 end_time = segment["words"][-1]["end"]
                 start_frame = int(_SAMPLE_RATE * start_time)
@@ -443,4 +469,176 @@ class Chall(GeneratorBasedBuilder):
 
         return list_of_chunks
 
+    @staticmethod
+    def get_raw_text(words: List[Dict]) -> str:
+        """
+
+        """
+        raw_text = " ".join([word["text"] for word in words])
+        return raw_text
+
+    def get_clear_text(self, raw_text: str) -> str:
+        """
+        Processes the raw text to produce a clear, cleaned version by removing annotations,
+        preprocessing the text, converting numbers to words, mapping special terms,
+        converting to lowercase, and filtering allowed characters.
+
+        :param raw_text: The raw input text to be processed.
+        :return: A string representing the processed clear text.
+        """
+
+        clear_text = self.remove_annotations(raw_text)
+        clear_text = self.preprocess_text(clear_text)
+
+        if self.config.num_to_words:
+            clear_text = self.num_to_words(clear_text)
+
+        if self.config.special_terms_mapping:
+            self.map_special_terms(clear_text, special_terms_mapping=self.config.special_terms_mapping)
+
+        if self.config.lowercase:
+            clear_text = clear_text.lower()
+
+        if self.config.allowed_chars:
+            clear_text = self.filter_and_clean_text(clear_text, allowed_chars=self.config.allowed_chars)
+
+        return clear_text
+
+    @staticmethod
+    def preprocess_text(transcript: str) -> str:
+        """
+        Preprocesses the text by removing words between brackets and parentheses,
+        standardizing spaces before apostrophes, removing commas between digits,
+        and replacing special characters.
+
+        :param transcript: The input transcript to preprocess.
+        :return: The preprocessed transcript with various text normalization applied.
+        """
+
+        transcript = re.sub(r"[<\[][^>\]]*[>\]]", "", transcript)  # remove words between brackets
+        transcript = re.sub(r"\(([^)]+?)\)", "", transcript)  # remove words between parenthesis
+        transcript = re.sub(r"\s+'", "'", transcript)  # standardize when there's a space before an apostrophe
+        transcript = re.sub(r"(\d),(\d)", r"\1\2", transcript)  # remove commas between digits
+        transcript = re.sub(r"\.([^0-9]|$)", r" \1", transcript)  # remove periods not followed by numbers
+
+        # Replace special characters
+        special_chars = {
+            'ß': 'ss', 'ç': 'c', 'á': 'a', 'à': 'a', 'â': 'a', 'é': 'e', 'è': 'e', 'ê': 'e', 'í': 'i', 'ì': 'i', 'î': 'i',
+            'ó': 'o', 'ò': 'o', 'ô': 'o', 'ú': 'u', 'ù': 'u', 'û': 'u', '-': ' ', '\u2013': ' ', '\xad': ' ', '/': ' '
+        }
+        for char, replacement in special_chars.items():
+            transcript = transcript.replace(char, replacement)
+
+        # Normalize whitespace
+        transcript = re.compile(r'[ \t]+').sub(' ', transcript)
+
+        return transcript
+
+    @staticmethod
+    def remove_annotations(transcript: str) -> str:
+        """
+        Removes specific annotations and conventions from the transcript
+
+        :param transcript: The transcript to preprocess.
+        :return: The preprocessed transcript with conventions and annotations removed.
+        """
+        transcript = transcript.replace('@g', '')  # (Swiss-)German words
+        transcript = transcript.replace('@?', '')  # best guess
+        transcript = transcript.replace('@!', '')  # Errors
+        transcript = transcript.replace('-', '')  # Repetitions
+        transcript = transcript.replace('--', '')  # Reformulations
+        transcript = transcript.replace('(...)', '')  # Long pauses
+        transcript = transcript.replace('(Whispering)', '')  # Whispering
+        transcript = transcript.replace('(whispers)', '')  # Whispering
+        transcript = transcript.replace('(whispering)', '')  # Whispering
+        transcript = transcript.replace('(unv.)', '')  # ?
+        transcript = transcript.replace('(laughing)', '')  # Laughing
+        transcript = transcript.replace('(laughs)', '')  # Laughing
+        transcript = transcript.replace('(Laughter)', '')  # Laughing
+        return transcript
+
+    @staticmethod
+    def num_to_words(transcript: str) -> str:
+        """
+        Converts numerical expressions in the transcript to their word equivalents using the num2words library.
+
+        :param transcript: The input transcript containing numerical expressions.
+        :return: The transcript with numerical expressions converted to words.
+        """
+
+        from num2words import num2words
+
+        def replace(match):
+            number_str = match.group(0)
+            if re.match(r'\d+\.', number_str):
+                # Check if this is an ordinal context by looking at the following character
+                next_char_index = match.end()
+                if next_char_index < len(transcript) and transcript[next_char_index].islower():
+                    # Convert to ordinal if followed by a lowercase letter
+                    number = int(number_str[:-1])  # Remove the period
+                    return num2words(number, to='ordinal')
+                else:
+                    # Treat as the end of a sentence, return as is
+                    return number_str
+
+            elif re.match(r'\d{4}s', number_str):
+                # Convert decades
+                number = int(number_str[:-1])
+                return num2words(number, to='year') + "s"
+
+            elif re.match(r'\d+m\b', number_str):
+                # Convert numbers with 'm' (meters) suffix
+                number = int(number_str[:-1])
+                return num2words(number) + " meters"
+
+            elif number_str[-2:] in ['st', 'nd', 'rd', 'th']:
+                # Convert ordinal numbers with suffix
+                number = int(re.match(r'\d+', number_str).group(0))
+
+                return num2words(number, to='ordinal')
+
+            else:
+                # Convert cardinal numbers
+                return num2words(number_str)
+
+        # Regular expression to find numbers, ordinals, ordinals with period, decades, and numbers with 'm' suffix
+        pattern = re.compile(r'\b\d+(\.\d+)?\b|\b\d+(st|nd|rd|th)\b|\b\d+\.\b|\b\d{4}s\b|\b\d+m\b')
+
+        # Substitute numbers with their word equivalent
+        new_sentence = pattern.sub(replace, transcript)
+
+        return new_sentence
+
+    @staticmethod
+    def map_special_terms(transcript: str, special_terms_mapping: dict):
+        """
+        Maps special terms in the transcript to their corresponding replacements using dictionary of pairs
+
+        :param transcript: The input transcript containing special terms to be mapped.
+        :param special_terms_mapping: A dictionary where keys are special terms and values are their replacements.
+        :return: The transcript with special terms replaced.
+        """
+
+        for term, replacement in special_terms_mapping.items():
+            transcript = re.sub(r'\b' + re.escape(term) + r'\b', replacement, transcript, flags=re.IGNORECASE)
+        return transcript
+
+    @staticmethod
+    def filter_and_clean_text(transcript: str, allowed_chars: set = None):
+        """
+        Filters the transcript to include only the allowed characters and normalizes
+        whitespace by removing extra spaces and trimming the text.
+
+        :param transcript: The input transcript to be filtered and cleaned.
+        :param allowed_chars: A set of allowed characters. If provided, only these characters will be retained in the transcript.
+        :return: The filtered and cleaned transcript.
+        """
+
+        # Filter allowed characters
+        if allowed_chars is not None:
+            transcript = ''.join([char for char in transcript if char in allowed_chars])
+
+        # Normalize whitespace
+        transcript = re.compile(r'[ \t]+').sub(' ', transcript).strip()
 
+        return transcript