chall / chall.py
mict-zhaw's picture
Filter empty `clear_text`
5464bfa
raw
history blame
28.9 kB
import json
import os
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"
_CITATION = "tbd"
_METAFILE = "chall_metadata.json"
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]
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
stratify_column: Union[None, str]
folds: Union[None, Dict[str, List]]
def __init__(self, **kwargs):
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 + " ÄÖÜäöü'")
self.stratify_column = kwargs.pop("stratify_column", None)
self.folds = kwargs.pop("folds", None)
super(ChallConfig, self).__init__(**kwargs)
class Chall(GeneratorBasedBuilder):
VERSION = Version("1.0.0")
BUILDER_CONFIG_CLASS = ChallConfig
DEFAULT_CONFIG_NAME = "original"
BUILDER_CONFIGS = [
ChallConfig(
name="original",
split_segments=False,
description="The 'original' configuration uses data in its raw, unmodified form while ensuring all participant "
"information is anonymized. This setup includes the preservation of data's original structure without "
"segmentation, filtering, or other preprocessing techniques. Although participant information is available, "
"it cannot be mapped back to individual speakers in the transcripts."
),
ChallConfig(
name="asr",
split_segments=True,
description="tbd"
),
ChallConfig(
name="asr_acl",
split_segments=True,
max_pause_length=12,
max_chunk_length=12,
min_chunk_length=0.5,
remove_trailing_pauses=True,
lowercase=True,
num_to_words=True,
stratify_column="intervention",
folds={
"fold0": ["17", "15", "1"],
"fold1": ["13", "7", "10"],
"fold2": ["4", "8", "6", "14"],
"fold3": ["12", "16", "5", "19"],
"fold4": ["9", "2", "3", "18", "11"]
},
description="Settings used for the paper."
)
]
@property
def manual_download_instructions(self):
return (
"To use the chall dataset you have to download it manually. "
"TBD Download Instructions. " # todo
"Please extract all files in one folder and load the dataset with: "
"`datasets.load_dataset('chall', data_dir='path/to/folder/folder_name')`"
)
def __init__(self, **kwargs):
"""
Initializes the dataset builder class and checks for all required dependencies.
:param kwargs: Arbitrary keyword arguments passed to the parent class's constructor
"""
self._check_dependencies()
super().__init__(**kwargs)
@staticmethod
def _check_dependencies() -> None:
"""
Checks if all required libraries are installed and available for the dataset processing.
"""
required_libraries = ["soundfile"]
missing_libraries = []
for library in required_libraries:
if importlib.util.find_spec(library) is None:
missing_libraries.append(library)
if missing_libraries:
missing_str = ", ".join(missing_libraries)
raise ImportError(f"Missing dependencies: {missing_str}. Please install them using 'pip install {missing_str}'")
def _info(self) -> DatasetInfo:
"""
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
"intervention": Value("int32"),
"school_grade": Value("string"),
"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"),
"end": Value("float"),
"duration": Value("float"),
"text": Value("string"),
}
),
"audio": Audio(sampling_rate=_SAMPLE_RATE)
})
else:
features = Features({
"audio_id": Value("string"), # todo maybe shorten to id
"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"),
"gender": Value("string"),
"year_of_birth": Value("int32"),
"school_grade": Value("int32"),
"languages": Value("string"),
"estimated_l2_proficiency": Value("string")
}, length=-1
),
"background_noise": Value("bool"),
"speakers": Sequence(
{
"spkid": Value("string"),
"name": Value("string")
}
),
"segments": Sequence(
{
"speaker": Value("string"),
"words": Sequence(
{
"start": Value("float"),
"end": Value("float"),
"duration": Value("float"),
"text": Value("string")
}
),
}
),
"audio": Audio(sampling_rate=_SAMPLE_RATE)
})
return DatasetInfo(
description=_DESCRIPTION,
features=features,
supervised_keys=None,
homepage="",
citation=_CITATION,
)
def _split_generators(self, dl_manager):
"""
This method is tasked with downloading/extracting the data and defining the splits depending on the configuration.
As this dataset requires manual download due to licensing, data must be downloaded first and then extracted.
:param dl_manager: dl_manager is a datasets.download.DownloadManager that can be used to download and extract URLS
:return:
"""
# todo define splits?
data_dir = os.path.abspath(os.path.expanduser(dl_manager.manual_dir))
# todo read ids for splits as we do not separate them by folder
if not os.path.exists(data_dir):
raise FileNotFoundError(
f"{data_dir} does not exist. Make sure you insert a manual dir via `datasets.load_dataset('chall', data_dir=...)` "
f"that includes files unzipped from the chall zip. Manual download instructions: {self.manual_download_instructions}"
)
# kFold Strategy
if self.config.folds and self.config.stratify_column:
return [
SplitGenerator(
name=fold_name,
gen_kwargs={
"filepath": os.path.join(data_dir, "data"),
"metafile": os.path.join(data_dir, _METAFILE),
"stratify_column": self.config.stratify_column,
"fold": fold
},
)
for (fold_name, fold) in self.config.folds.items()]
# Train Only Strategy
else:
return [
SplitGenerator(
name=Split.TRAIN,
gen_kwargs={
"filepath": os.path.join(data_dir, "data"),
"metafile": os.path.join(data_dir, _METAFILE),
},
),
# datasets.SplitGenerator(
# name=datasets.Split.TEST,
# gen_kwargs={"filepath": os.path.join(data_dir, "data"), "metafile": os.path.join(data_dir, _METAFILE)},
# ),
# datasets.SplitGenerator(
# name=datasets.Split.VALIDATION,
# gen_kwargs={"filepath": os.path.join(data_dir, "data"), "metafile": os.path.join(data_dir, _METAFILE)},
# ),
]
def _generate_examples(self, filepath, metafile, stratify_column: str = None, fold: List = None):
"""
This method handles input defined in _split_generators to yield (key, example) tuples from the dataset.
:param filepath: The path where the data is located.
:param metafile: The metafile describing the chall data
:param stratify_column: The meta column to stratify by.
:param fold: A list of values do define splits. Only works in combination with `stratify_column`
:return:
"""
logger.info("generating examples from = %s", filepath)
with open(metafile, 'r') as file:
metadata = json.load(file)
for row in metadata["data"]:
# define splits if set
if stratify_column and str(row[stratify_column]) not in fold:
continue
# load transcript
transcript_file = os.path.join(filepath, row["transcript_file"])
with open(transcript_file, 'r') as transcript:
transcript = json.load(transcript)
audio_id = row['audio_id']
audio_file_path = os.path.join(filepath, row["audio_file"])
if self.config.split_segments:
yield from self._generate_utterance_examples(audio_id, str(audio_file_path), row, transcript)
else:
yield from self._generate_transcript_examples(audio_id, str(audio_file_path), row, transcript)
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
the audio data into a dictionary that is then yielded.
:param audio_id: A unique identifier for the audio file.
:param audio_file_path: The file system path to the audio file.
:param data: A dictionary of the metadata.
:param transcript: A dictionary containing details of the transcript, including speakers and segments.
:return: Yields a tuple containing the audio ID and the enriched transcript dictionary.
"""
transcript_data = data.copy() # Create a fresh copy of data to ensure no side effects
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')
transcript_data["audio"] = {"path": audio_file_path, "array": audio, "sampling_rate": _SAMPLE_RATE}
yield audio_id, transcript_data
def _generate_utterance_examples(self, audio_id: str, audio_file_path: str, data: dict, transcript: dict):
"""
Generates examples from audio segments based on the transcript provided. Each segment is processed to produce
an utterance which includes the audio slice and metadata.
:param audio_id: A unique identifier for the audio file.
:param audio_file_path: The filesystem path to the audio file.
:param data: A dictionary containing the segments to be processed
:param transcript: A dictionary containing transcript details with segments of spoken words.
:return: Yields a tuple containing the audio ID and the enriched utterance dictionary.
"""
segments = transcript.get("segments", [])
segments = self._process_segments(segments)
with sf.SoundFile(audio_file_path) as track:
if not track.seekable():
raise ValueError("Audio file is not seekable.")
for segment_i, segment in enumerate(segments):
segment_data = data.copy() # Create a fresh copy of data for each segment
segment_id = f"{audio_id}_{str(segment_i).rjust(3, '0')}"
segment_data["audio_id"] = segment_id
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)
if not segment_data["clear_text"].strip():
continue
start_time = segment["words"][0]["start"]
end_time = segment["words"][-1]["end"]
start_frame = int(_SAMPLE_RATE * start_time)
frames_to_read = int(_SAMPLE_RATE * (end_time - start_time))
track.seek(start_frame)
audio = track.read(frames_to_read)
segment_data["audio"] = {"path": audio_file_path, "array": audio, "sampling_rate": _SAMPLE_RATE}
yield segment_id, segment_data
def _process_segments(self, segments):
"""
Processes the list of segments based on configured rules.
:param segments: A list of segment dictionaries
:return: A list of processed segment dictionaries after applying all the filtering and splitting rules.
"""
if self.config.max_pause_length:
segments = self._split_and_remove_long_pauses(segments)
if self.config.max_chunk_length is not None:
segments = self._split_long_segments(segments)
if self.config.remove_trailing_pauses:
segments = self._remove_trailing_pauses(segments)
if self.config.max_pause_length is not None:
segments = self._filter_segments_by_duration(segments, self.config.min_chunk_length, self.config.max_chunk_length)
return segments
@staticmethod
def _remove_trailing_pauses(segments: List[dict]) -> List[dict]:
"""
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:
if len(segment["words"]) > 0 and segment["words"][-1]["text"].strip() == "(...)":
segment["words"] = segment["words"][:-1]
if len(segment["words"]) > 0 and segment["words"][0]["text"].strip() == "(...)":
segment["words"] = segment["words"][1:]
# Remove segment if no words left
if not segment["words"]:
segments.remove(segment)
return segments
def _split_and_remove_long_pauses(self, segments: List[dict]) -> List[dict]:
"""
Remove too 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_segments_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_segments(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.
"""
chunked_segments = []
for segment in segments:
segment_start = segment["words"][0]["start"]
segment_end = segment["words"][-1]["end"]
duration = segment_end - segment_start
if duration >= self.config.max_chunk_length:
chunks = self._create_chunks(segment)
for chunk in chunks:
if len(chunk) > 0:
chunked_segments.append({"speaker": segment["speaker"], "words": chunk})
else:
chunked_segments.append(segment)
return chunked_segments
def _create_chunks(self, segment: dict):
"""
Splits a given segment into chunks of words, each with a maximum length.
:param segment: The segment to be divided into chunks.
:return: A list of chunks, where each chunk is a list of words.
"""
list_of_chunks = []
chunk_start = segment["words"][0]["start"]
chunk_words = []
for word in segment["words"]:
if (word["end"] - chunk_start) >= self.config.max_chunk_length:
list_of_chunks.append(chunk_words)
chunk_start = word["start"]
chunk_words = []
chunk_words.append(word)
# Add final chunk
if len(chunk_words) > 0:
list_of_chunks.append(chunk_words)
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