Datasets:
Tasks:
Automatic Speech Recognition
Languages:
Swedish
| # coding=utf-8 | |
| # Copyright 2021 The TensorFlow Datasets Authors and the HuggingFace Datasets Authors. | |
| # Copyright 2022, 2023 Jim O'Regan for Språkbanken Tal | |
| # | |
| # Licensed under the Apache License, Version 2.0 (the "License"); | |
| # you may not use this file except in compliance with the License. | |
| # You may obtain a copy of the License at | |
| # | |
| # http://www.apache.org/licenses/LICENSE-2.0 | |
| # | |
| # Unless required by applicable law or agreed to in writing, software | |
| # distributed under the License is distributed on an "AS IS" BASIS, | |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| # See the License for the specific language governing permissions and | |
| # limitations under the License. | |
| # Lint as: python3 | |
| """Datasets loader for Waxholm speech corpus""" | |
| from io import BytesIO | |
| import os | |
| import soundfile as sf | |
| from collections import namedtuple | |
| from copy import deepcopy | |
| from difflib import SequenceMatcher | |
| import datasets | |
| from datasets.tasks import AutomaticSpeechRecognition | |
| from datasets.features import Audio | |
| TRAIN_LIST = "alloktrainfiles" | |
| TEST_LIST = "testfiles" | |
| _DESCRIPTION = """\ | |
| The Waxholm corpus was collected in 1993 - 1994 at the department of Speech, Hearing and Music (TMH), KTH. | |
| """ | |
| _CITATION = """ | |
| @article{bertenstam1995spoken, | |
| title={Spoken dialogue data collected in the {W}axholm project}, | |
| author={Bertenstam, Johan and Blomberg, Mats and Carlson, Rolf and Elenius, Kjell and Granstr{\"o}m, Bj{\"o}rn and Gustafson, Joakim and Hunnicutt, Sheri and H{\"o}gberg, Jesper and Lindell, Roger and Neovius, Lennart and Nord, Lennart and de~Serpa-Leitao, Antonio and Str{\"o}m, Nikko}, | |
| journal={STH-QPSR, KTH}, | |
| volume={1}, | |
| pages={49--74}, | |
| year={1995} | |
| } | |
| @inproceedings{bertenstam1995waxholm, | |
| title={The {W}axholm application database.}, | |
| author={Bertenstam, J and Blomberg, Mats and Carlson, Rolf and Elenius, Kjell and Granstr{\"o}m, Bj{\"o}rn and Gustafson, Joakim and Hunnicutt, Sheri and H{\"o}gberg, Jesper and Lindell, Roger and Neovius, Lennart and Nord, Lennart and de~Serpa-Leitao, Antonio and Str{\"o}m, Nikko}, | |
| booktitle={EUROSPEECH}, | |
| year={1995} | |
| }""" | |
| _URL = "http://www.speech.kth.se/waxholm/waxholm2.html" | |
| class FRExpected(Exception): | |
| """Exception to raise when FR line was expected, but not read""" | |
| def __init__(self, line): | |
| msg = "Unknown line type (does not begin with 'FR'): " | |
| super().__init__(msg + line) | |
| class WaxholmDataset(datasets.GeneratorBasedBuilder): | |
| """Dataset script for Waxholm.""" | |
| VERSION = datasets.Version("1.1.0") | |
| BUILDER_CONFIGS = [ | |
| datasets.BuilderConfig(name="waxholm"), | |
| ] | |
| def _info(self): | |
| features = datasets.Features( | |
| { | |
| "id": datasets.Value("string"), | |
| "text": datasets.Value("string"), | |
| "phonemes": datasets.Sequence(datasets.Value("string")), | |
| "audio": datasets.Audio(sampling_rate=16_000) | |
| } | |
| ) | |
| return datasets.DatasetInfo( | |
| description=_DESCRIPTION, | |
| features=features, | |
| supervised_keys=None, | |
| homepage=_URL, | |
| citation=_CITATION, | |
| task_templates=[ | |
| AutomaticSpeechRecognition(audio_column="audio", transcription_column="text") | |
| ], | |
| ) | |
| def _split_generators(self, dl_manager): | |
| return [ | |
| datasets.SplitGenerator( | |
| name=datasets.Split.TRAIN, | |
| gen_kwargs={ | |
| "split": "train", | |
| "files": TRAIN_LIST | |
| }, | |
| ), | |
| datasets.SplitGenerator( | |
| name=datasets.Split.TEST, | |
| gen_kwargs={ | |
| "split": "test", | |
| "files": TEST_LIST | |
| }, | |
| ), | |
| ] | |
| def _generate_examples(self, split, files): | |
| with open(f"./waxholm/{files}") as input_file: | |
| for line in input_file.readlines(): | |
| line = line.strip() | |
| parts = line.split(".") | |
| subdir = parts[0] | |
| audio_file = f"./waxholm/scenes_formatted/{subdir}/{line}" | |
| if not os.path.exists(audio_file): | |
| print(f"{audio_file} does not exist: skipping") | |
| continue | |
| text_file = f"{audio_file}.mix" | |
| if not os.path.exists(text_file): | |
| print(f"{text_file} does not exist: skipping") | |
| continue | |
| mix = Mix(text_file) | |
| samples, sr = smp_read_sf(audio_file) | |
| buffer = BytesIO() | |
| sf.write(buffer, samples, sr, format="wav") | |
| blank = Audio() | |
| yield line, { | |
| "id": line, | |
| "text": mix.text, | |
| "phonemes": mix.get_phoneme_list(), | |
| "audio": { | |
| "bytes": buffer.getvalue(), | |
| "sampling_rate": sr, | |
| } | |
| } | |
| def fix_text(text: str) -> str: | |
| replacements = text.maketrans("{}|\\[]", "äåöÖÄÅ") | |
| return text.translate(replacements) | |
| Label = namedtuple('Label', ['start', 'end', 'label']) | |
| class FR: | |
| def __init__(self, text="", **kwargs): # C901 | |
| if text and text != "": | |
| self.from_text(text) | |
| else: | |
| for arg in kwargs: | |
| prms = ["pm", "pm_type", "type", "frame", | |
| "seconds", "phone", "phone_type", | |
| "word", "pseudoword"] | |
| if arg in prms: | |
| self.__dict__[arg] = kwargs[arg] | |
| else: | |
| print(f"Unrecognised argument: {arg}") | |
| def from_text(self, text: str): | |
| if not text.startswith("FR"): | |
| raise FRExpected(text) | |
| parts = [a.strip() for a in text.split("\t")] | |
| self.frame = parts[0][2:].strip() | |
| if parts[-1].strip().endswith(" sec"): | |
| self.seconds = parts[-1].strip()[0:-4] | |
| def split_phone(phone): | |
| if phone.startswith("$#"): | |
| phtype = 'I' | |
| phone_type = fix_text(phone[0:2]) | |
| phone_out = fix_text(phone[2:]) | |
| elif phone.startswith("$") or phone.startswith("#"): | |
| phtype = 'I' | |
| phone_type = fix_text(phone[0:1]) | |
| phone_out = fix_text(phone[1:]) | |
| else: | |
| print(phone) | |
| return None | |
| return { | |
| "type": phtype, | |
| "phone_type": phone_type, | |
| "phone": phone_out | |
| } | |
| for subpart in parts[1:-1]: | |
| subpart = subpart.strip() | |
| if subpart.startswith("$#") or subpart.startswith("$") or subpart.startswith("#"): | |
| phparts = split_phone(subpart) | |
| if phparts is not None: | |
| self.type = phparts['type'] | |
| self.phone_type = phparts['phone_type'] | |
| self.phone = phparts['phone'] | |
| elif subpart.startswith(">pm "): | |
| phparts = split_phone(subpart[4:]) | |
| if phparts is not None: | |
| self.pm_type = phparts['phone_type'] | |
| self.pm = phparts['phone'] | |
| elif subpart.startswith(">pm. "): | |
| phparts = split_phone(subpart[5:]) | |
| if phparts is not None: | |
| self.pm_type = phparts['phone_type'] | |
| self.pm = phparts['phone'] | |
| elif subpart.startswith(">w "): | |
| self.type = 'B' | |
| self.word = fix_text(subpart[3:]) | |
| self.pseudoword = False | |
| elif subpart.startswith(">w. "): | |
| self.type = 'B' | |
| self.word = fix_text(subpart[4:]) | |
| self.pseudoword = False | |
| elif subpart == "> XklickX" or subpart == "> XutandX": | |
| self.type = 'B' | |
| self.word = subpart[2:] | |
| self.pseudoword = True | |
| elif subpart.startswith("X"): | |
| if hasattr(self, 'type'): | |
| print(self.type, self.type == 'B') | |
| self.type = getattr(self, 'type', 'B') | |
| self.word = fix_text(subpart) | |
| self.pseudoword = True | |
| elif subpart == "OK": | |
| self.type = 'E' | |
| elif subpart == "PROBLEMS": | |
| self.type = 'E' | |
| def get_type(self): | |
| if "type" in self.__dict__: | |
| return self.type | |
| else: | |
| return "" | |
| def __repr__(self): | |
| parts = [] | |
| parts.append(f"type: {self.get_type()}") | |
| parts.append(f"frame: {self.frame}") | |
| if self.get_type() != 'E': | |
| parts.append(f"phone: {self.get_phone()}") | |
| if 'word' in self.__dict__: | |
| parts.append(f"word: {self.word}") | |
| if 'pm_type' in self.__dict__: | |
| parts.append(f"pm_type: {self.pm_type}") | |
| if 'pm' in self.__dict__: | |
| parts.append(f"pm: {self.pm}") | |
| if 'seconds' in self.__dict__: | |
| parts.append(f"sec: {self.seconds}") | |
| return "FR(" + ", ".join(parts) + ")" | |
| def fix_type(self): | |
| if self.is_type("B") and self.get_word() == "": | |
| self.pm_type = "$" | |
| self.phone_type = "$" | |
| self.type = "I" | |
| def get_phone(self, fix_accents=True): | |
| def fix_accents(phone, fix_accents=True): | |
| if not fix_accents: | |
| return phone | |
| return phone.replace("'", "ˈ").replace('"', "ˌ") | |
| if 'pm' in self.__dict__: | |
| return fix_accents(self.pm, fix_accents) | |
| elif 'phone' in self.__dict__: | |
| return fix_accents(self.phone, fix_accents) | |
| else: | |
| return None | |
| def is_silence_word(self, noise=False): | |
| if 'word' in self.__dict__: | |
| if not noise: | |
| return self.word == "XX" | |
| else: | |
| return self.word.startswith("X") and self.word.endswith("X") | |
| else: | |
| return False | |
| def is_type(self, type): | |
| if "type" in self.__dict__: | |
| return type == self.type | |
| else: | |
| return False | |
| def has_seconds(self): | |
| return "seconds" in self.__dict__ | |
| def get_seconds(self): | |
| if not self.has_seconds() and "frame" in self.__dict__: | |
| return int(self.frame) / 16000.0 | |
| else: | |
| return self.seconds | |
| def get_word(self): | |
| if self.has_word(): | |
| return self.word | |
| else: | |
| return "" | |
| def has_word(self): | |
| return "word" in self.__dict__ | |
| def has_pseudoword(self): | |
| return "pseudoword" in self.__dict__ | |
| def merge_frs(fr1, fr2, check_time=False): | |
| """ | |
| Merge FRS entries for plosives: by default, the | |
| period of glottal closure and the burst are separately | |
| annotated. | |
| """ | |
| if fr2.has_word(): | |
| return None | |
| if check_time: | |
| if fr1.get_seconds() != fr2.get_seconds(): | |
| return None | |
| if _is_glottal_closure(fr1.get_phone(), fr2.get_phone()): | |
| if not fr1.has_word(): | |
| return fr2 | |
| else: | |
| word = None | |
| if fr1.has_word(): | |
| word = fr1.word | |
| pword = None | |
| if fr1.has_pseudoword(): | |
| pword = fr1.pseudoword | |
| return FR(pm=fr2.pm, pm_type=fr2.pm_type, type=fr2.type, | |
| frame=fr2.frame, seconds=fr2.seconds, phone=fr2.phone, | |
| phone_type=fr2.phone_type, word=word, pseudoword=pword) | |
| SILS = { | |
| "K": "k", | |
| "G": "g", | |
| "T": "t", | |
| "D": "d", | |
| "2T": "2t", | |
| "2D": "2d", | |
| "P": "p", | |
| "B": "b" | |
| } | |
| def _is_glottal_closure(cur, next): | |
| return cur in SILS and next == SILS[cur] | |
| def _replace_glottal_closures(input): | |
| input += ' ' | |
| for sil in SILS: | |
| input = input.replace(f"{sil} {SILS[sil]} ", f"{SILS[sil]} ") | |
| return input[:-1] | |
| def _fix_duration_markers(input): | |
| input += ' ' | |
| input = input.replace(":+ ", ": ") | |
| return input[:-1] | |
| class Mix(): | |
| def __init__(self, filepath: str, stringfile=None, fix_type=True): | |
| self.fr = [] | |
| self.path = filepath | |
| if stringfile is None: | |
| with open(filepath) as inpf: | |
| self.read_data(inpf.readlines()) | |
| else: | |
| self.read_data(stringfile.split("\n")) | |
| if fix_type: | |
| for fr in self.fr: | |
| fr.fix_type() | |
| def read_data(self, inpf): # C901 | |
| """read data from text of a .mix file""" | |
| saw_text = False | |
| saw_phoneme = False | |
| saw_labels = False | |
| for line in inpf: | |
| if line.startswith("Waxholm dialog."): | |
| self.filepath = line[15:].strip() | |
| if line.startswith("TEXT:"): | |
| saw_text = True | |
| continue | |
| if saw_text: | |
| self.text = fix_text(line.strip()) | |
| saw_text = False | |
| if line.startswith("PHONEME:"): | |
| saw_phoneme = True | |
| self.phoneme = fix_text(line[8:].strip()) | |
| if line[8:].strip().endswith("."): | |
| saw_phoneme = False | |
| continue | |
| if saw_phoneme: | |
| self.phoneme = fix_text(line.strip()) | |
| if line[8:].strip().endswith("."): | |
| saw_phoneme = False | |
| if line.startswith("FR "): | |
| if saw_labels: | |
| saw_labels = False | |
| self.fr.append(FR(text=line)) | |
| if line.startswith("Labels: "): | |
| self.labels = line[8:].strip() | |
| saw_labels = True | |
| if saw_labels and line.startswith(" "): | |
| self.labels += line.strip() | |
| def check_fr(self, verbose=False) -> bool: | |
| """ | |
| Simple sanity check: that there were FR lines, | |
| and that the first was a start type, and | |
| last was an end type. | |
| """ | |
| if 'fr' not in self.__dict__: | |
| return False | |
| if len(self.fr) == 0: | |
| return False | |
| start_end = self.fr[0].is_type("B") and self.fr[-1].is_type("E") | |
| if verbose and not start_end: | |
| if not self.fr[0].is_type("B"): | |
| print(f"{self.path}: missing start type") | |
| if not self.fr[-1].is_type("E"): | |
| print(f"{self.path}: missing end type") | |
| return start_end | |
| def get_times(self, as_frames=False): | |
| """ | |
| get the times of each phoneme | |
| """ | |
| if not self.check_fr(verbose=True): | |
| return [] | |
| if as_frames: | |
| times = [int(x.frame) for x in self.fr] | |
| else: | |
| times = [float(x.seconds) for x in self.fr] | |
| return times | |
| def get_time_pairs(self, as_frames=False): | |
| """ | |
| get a list of tuples containing start and end times | |
| By default, the times are in seconds; if `as_frames` | |
| is set, the number of frames are returned instead. | |
| """ | |
| times = self.get_times(as_frames=as_frames) | |
| starts = times[0:-1] | |
| ends = times[1:] | |
| return [x for x in zip(starts, ends)] | |
| def prune_empty_presilences(self, verbose=False, include_noises=False): | |
| """ | |
| Remove empty silence markers (i.e., those with no distinct duration) | |
| """ | |
| self.orig_fr = deepcopy(self.fr) | |
| i = 0 | |
| warned = False | |
| def check_cur(cur, next): | |
| if verbose and not cur.has_seconds(): | |
| print(f"Missing seconds: {self.path}\nLine: {cur}") | |
| if verbose and not next.has_seconds(): | |
| print(f"Missing seconds: {self.path}\nLine: {next}") | |
| return cur.get_seconds() == next.get_seconds() and cur.is_silence_word() | |
| todel = [] | |
| while i < len(self.fr) - 1: | |
| if check_cur(self.fr[i], self.fr[i + 1]): | |
| if verbose: | |
| if not warned: | |
| warned = True | |
| print(f"Empty silence in {self.path}:") | |
| print(self.fr[i]) | |
| todel.append(i) | |
| i += 1 | |
| if todel is not None and todel != []: | |
| for chaff in todel.reverse(): | |
| del(self.fr[chaff]) | |
| def prune_empty_postsilences(self, verbose=False, include_noises=False): | |
| """ | |
| Remove empty silence markers (i.e., those with no distinct duration) | |
| """ | |
| if not "orig_fr" in self.__dict__: | |
| self.orig_fr = deepcopy(self.fr) | |
| i = 1 | |
| warned = False | |
| def check_cur(cur, prev): | |
| if verbose and not cur.has_seconds(): | |
| print(f"Missing seconds: {self.path}\nLine: {cur}") | |
| if verbose and not prev.has_seconds(): | |
| print(f"Missing seconds: {self.path}\nLine: {prev}") | |
| return cur.get_seconds() == prev.get_seconds() and cur.is_silence_word() | |
| todel = [] | |
| while i < len(self.fr): | |
| if check_cur(self.fr[i], self.fr[i - 1]): | |
| if verbose: | |
| if not warned: | |
| warned = True | |
| print(f"Empty silence in {self.path}:") | |
| print(self.fr[i]) | |
| todel.append(i) | |
| i += 1 | |
| if todel is not None and todel != []: | |
| for chaff in todel.reverse(): | |
| del(self.fr[chaff]) | |
| def prune_empty_segments(self, verbose=False): | |
| """ | |
| Remove empty segments (i.e., those with no distinct duration) | |
| """ | |
| if not "orig_fr" in self.__dict__: | |
| self.orig_fr = deepcopy(self.fr) | |
| times = self.get_time_pairs(as_frames=True) | |
| if len(times) != (len(self.fr) - 1): | |
| print("Uh oh: time pairs and items don't match") | |
| else: | |
| keep = [] | |
| for fr in zip(self.fr[:-1], times): | |
| cur_time = fr[1] | |
| if cur_time[0] == cur_time[1]: | |
| if verbose: | |
| print(f"Empty segment {fr[0].get_phone()} ({cur_time[0]} --> {cur_time[1]})") | |
| else: | |
| keep.append(fr[0]) | |
| keep.append(self.fr[-1]) | |
| self.fr = keep | |
| def prune_empty_silences(self, verbose = False): | |
| self.prune_empty_presilences(verbose) | |
| self.prune_empty_postsilences(verbose) | |
| def merge_plosives(self, verbose=False): | |
| """ | |
| Merge plosives in FRs | |
| (in Waxholm, as in TIMIT, the silence before the burst and the burst | |
| are annotated separately). | |
| """ | |
| if not "orig_fr" in self.__dict__: | |
| self.orig_fr = deepcopy(self.fr) | |
| tmp = [] | |
| i = 0 | |
| while i < len(self.fr)-1: | |
| merged = merge_frs(self.fr[i], self.fr[i+1]) | |
| if merged is not None: | |
| if verbose: | |
| print(f"Merging {self.fr[i]} and {self.fr[i+1]}") | |
| i += 1 | |
| tmp.append(merged) | |
| else: | |
| tmp.append(self.fr[i]) | |
| i += 1 | |
| tmp.append(self.fr[-1]) | |
| self.fr = tmp | |
| def get_phone_label_tuples(self, as_frames=False, fix_accents=True): | |
| times = self.get_time_pairs(as_frames=as_frames) | |
| if self.check_fr(): | |
| labels = [fr.get_phone(fix_accents) for fr in self.fr[0:-1]] | |
| else: | |
| labels = [] | |
| if len(times) == len(labels): | |
| out = [] | |
| for z in zip(times, labels): | |
| out.append((z[0][0], z[0][1], z[1])) | |
| return out | |
| else: | |
| return [] | |
| def get_merged_plosives(self, noop=False, prune_empty=True): | |
| """ | |
| Returns a list of phones with plosives merged | |
| (in Waxholm, as in TIMIT, the silence before the burst and the burst | |
| are annotated separately). | |
| If `noop` is True, it simply returns the output of `prune_empty_labels()` | |
| """ | |
| if noop: | |
| if not prune_empty: | |
| print("Warning: not valid to set noop to True and prune_empty to false") | |
| print("Ignoring prune_empty") | |
| return self.prune_empty_labels() | |
| i = 0 | |
| out = [] | |
| if prune_empty: | |
| labels = self.prune_empty_labels() | |
| else: | |
| labels = self.get_phone_label_tuples() | |
| while i < len(labels)-1: | |
| cur = labels[i] | |
| next = labels[i+1] | |
| if _is_glottal_closure(cur[2], next[2]): | |
| tmp = Label(start = cur[0], end = next[1], label = next[2]) | |
| out.append(tmp) | |
| i += 2 | |
| else: | |
| tmp = Label(start = cur[0], end = cur[1], label = cur[2]) | |
| out.append(tmp) | |
| i += 1 | |
| return out | |
| def get_word_label_tuples(self, verbose=True): | |
| times = self.get_time_pairs() | |
| if len(times) == len(self.fr[0:-1]): | |
| out = [] | |
| labels_raw = [x for x in zip(times, self.fr[0:-1])] | |
| i = 0 | |
| cur = None | |
| while i < len(labels_raw) - 1: | |
| if labels_raw[i][1].is_type("B"): | |
| if cur is not None: | |
| out.append(cur) | |
| if labels_raw[i+1][1].is_type("B"): | |
| if verbose and labels_raw[i][1].get_word() == "": | |
| print("Expected word", labels_raw[i][1]) | |
| out.append((labels_raw[i][0][0], labels_raw[i][0][1], labels_raw[i][1].get_word())) | |
| cur = None | |
| i += 1 | |
| continue | |
| else: | |
| if verbose and labels_raw[i][1].get_word() == "": | |
| print("Expected word", labels_raw[i][1]) | |
| cur = (labels_raw[i][0][0], labels_raw[i][0][1], labels_raw[i][1].get_word()) | |
| if labels_raw[i+1][1].is_type("B"): | |
| if cur is not None: | |
| cur = (cur[0], labels_raw[i][0][1], cur[2]) | |
| i += 1 | |
| out.append(cur) | |
| return out | |
| else: | |
| return [] | |
| def get_dictionary(self, fix_accents=True): | |
| """ | |
| Get pronunciation dictionary entries from the .mix file. | |
| These entries are based on the corrected pronunciations; for | |
| the lexical pronunciations, use the `phoneme` property. | |
| """ | |
| output = {} | |
| current_phones = [] | |
| prev_word = '' | |
| for fr in self.fr: | |
| if 'word' in fr.__dict__: | |
| phone = fr.get_phone(fix_accents) | |
| if prev_word != "": | |
| if prev_word not in output: | |
| output[prev_word] = [] | |
| output[prev_word].append(current_phones.copy()) | |
| current_phones.clear() | |
| prev_word = fr.word | |
| current_phones.append(phone) | |
| elif fr.is_type("I"): | |
| phone = fr.get_phone(fix_accents) | |
| current_phones.append(phone) | |
| else: | |
| if prev_word not in output: | |
| output[prev_word] = [] | |
| output[prev_word].append(current_phones.copy()) | |
| return output | |
| def get_dictionary_list(self, fix_accents=True): | |
| """ | |
| Get pronunciation dictionary entries from the .mix file. | |
| These entries are based on the corrected pronunciations; for | |
| the lexical pronunciations, use the `phoneme` property. | |
| This version creates a list of tuples (word, phones) that | |
| preserves the order of the entries. | |
| """ | |
| output = [] | |
| current_phones = [] | |
| prev_word = '' | |
| for fr in self.fr: | |
| if 'word' in fr.__dict__: | |
| phone = fr.get_phone(fix_accents) | |
| if prev_word != "": | |
| output.append((prev_word, " ".join(current_phones))) | |
| current_phones.clear() | |
| prev_word = fr.word | |
| current_phones.append(phone) | |
| elif fr.is_type("I"): | |
| phone = fr.get_phone(fix_accents) | |
| current_phones.append(phone) | |
| else: | |
| output.append((prev_word, " ".join(current_phones))) | |
| return output | |
| def get_phoneme_string(self, insert_pauses=True, fix_accents=True): | |
| """ | |
| Get an opinionated phoneme string | |
| Args: | |
| insert_pauses (bool, optional): Insert pauses between words. Defaults to True. | |
| fix_accents (bool, optional): IPA-ify accents. Defaults to True. | |
| """ | |
| dict_list = self.get_dictionary_list(fix_accents) | |
| skip = ['p:', '.'] | |
| if insert_pauses: | |
| phone_strings = [x[1] for x in dict_list if x[1] not in skip] | |
| joined = ' p: '.join(phone_strings) | |
| else: | |
| phone_strings = [x[1] for x in dict_list if x[1] != "."] | |
| joined = ' '.join(phone_strings) | |
| joined = _replace_glottal_closures(joined) | |
| joined = _fix_duration_markers(joined) | |
| return joined | |
| def get_phoneme_list(self, insert_pauses=True, fix_accents=True): | |
| return self.get_phoneme_string(insert_pauses, fix_accents).split(' ') | |
| def get_compare_dictionary(self, fix_accents=True, merge_plosives=True, only_changed=True): | |
| """ | |
| Get pronunciation dictionary for comparision: i.e., where there is a difference | |
| between the canonical pronunciation and what was spoken | |
| """ | |
| if merge_plosives: | |
| self.merge_plosives() | |
| orig = self.get_dictionary_list(fix_accents) | |
| self.prune_empty_segments() | |
| new = self.get_dictionary_list(fix_accents) | |
| if len(orig) != len(new): | |
| words_orig = [w[0] for w in orig] | |
| words_new = [w[0] for w in new] | |
| skippables = [] | |
| for tag, i, j, _, _ in SequenceMatcher(None, words_orig, words_new).get_opcodes(): | |
| if tag in ('delete', 'replace'): | |
| skippables += [a for a in range(i, j)] | |
| for c in skippables.reverse(): | |
| del(orig[c]) | |
| out = [] | |
| i = 0 | |
| while i < len(orig): | |
| if orig[i][0] == new[i][0]: | |
| if orig[i][1] == new[i][1]: | |
| if not only_changed: | |
| out.append(orig) | |
| else: | |
| out.append((orig[i][0], orig[i][1], new[i][1])) | |
| i += 1 | |
| return out | |
| def smp_probe(filename: str) -> bool: | |
| with open(filename, "rb") as f: | |
| return f.read(9) == b"file=samp" | |
| def smp_headers(filename: str): | |
| with open(filename, "rb") as f: | |
| f.seek(0) | |
| raw_headers = f.read(1024) | |
| raw_headers = raw_headers.rstrip(b'\x00') | |
| asc_headers = raw_headers.decode("ascii") | |
| asc_headers.rstrip('\x00') | |
| tmp = [a for a in asc_headers.split("\r\n")] | |
| back = -1 | |
| while abs(back) > len(tmp) + 1: | |
| if tmp[back] == '=': | |
| break | |
| back -= 1 | |
| tmp = tmp[0:back-1] | |
| return dict(a.split("=") for a in tmp) | |
| def smp_read_sf(filename: str): | |
| headers = smp_headers(filename) | |
| if headers["msb"] == "last": | |
| ENDIAN = "LITTLE" | |
| else: | |
| ENDIAN = "BIG" | |
| data, sr = sf.read(filename, channels=int(headers["nchans"]), | |
| samplerate=16000, endian=ENDIAN, start=512, | |
| dtype="int16", format="RAW", subtype="PCM_16") | |
| return (data, sr) | |
| def _write_wav(filename, arr): | |
| import wave | |
| with wave.open(filename, "w") as f: | |
| f.setnchannels(1) | |
| f.setsampwidth(2) | |
| f.setframerate(16000) | |
| f.writeframes(arr) | |
| #arr, sr = smp_read_sf("/Users/joregan/Playing/waxholm/scenes_formatted//fp2060/fp2060.pr.09.smp") | |
| #write_wav("out.wav", arr) | |