Datasets:
Tasks:
Automatic Speech Recognition
Languages:
Swedish
# coding=utf-8 | |
# Copyright 2021 The TensorFlow Datasets Authors and the HuggingFace Datasets Authors. | |
# Copyright 2022 Jim O'Regan | |
# | |
# 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 | |
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 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"), | |
"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_file_path_column="path", 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() | |
audio_to_pass = blank.encode_example(value = {"bytes": buffer.getvalue(), "sampling_rate": sr, }) | |
yield line, { | |
"id": line, | |
"text": mix.text, | |
"audio": audio_to_pass | |
} | |
def fix_text(text: str) -> str: | |
replacements = text.maketrans("{}|\\", "äåöÖ") | |
return text.translate(replacements) | |
class FR: | |
def __init__(self, text: str): | |
if not text.startswith("FR"): | |
raise IOError("Unknown line type (does not begin with 'FR'): " + 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] | |
for subpart in parts[1:-1]: | |
if subpart.startswith("$#"): | |
self.type = 'I' | |
self.phone_type = fix_text(subpart[0:2]) | |
self.phone = fix_text(subpart[2:]) | |
elif subpart.startswith("$"): | |
self.type = 'I' | |
self.phone_type = fix_text(subpart[0:2]) | |
self.phone = fix_text(subpart[2:]) | |
elif subpart.startswith("#"): | |
self.type = 'B' | |
self.phone_type = fix_text(subpart[0:2]) | |
self.phone = fix_text(subpart[2:]) | |
elif subpart.startswith(">pm "): | |
self.pm_type = fix_text(subpart[4:5]) | |
self.pm = fix_text(subpart[5:]) | |
elif subpart.startswith(">pm. "): | |
self.pm_type = fix_text(subpart[4:5]) | |
self.pm = fix_text(subpart[5:]) | |
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.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' | |
def __repr__(self): | |
parts = [] | |
parts.append(f"type: {self.type}") | |
parts.append(f"frame: {self.frame}") | |
if self.type != 'E': | |
parts.append(f"phone: {self.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}") | |
parts.append(f"sec: {self.seconds}") | |
return f"FR(" + ", ".join(parts) + ")" | |
class Mix(): | |
def __init__(self, filepath: str): | |
self.fr = [] | |
with open(filepath) as inpf: | |
saw_text = False | |
saw_phoneme = False | |
saw_labels = False | |
for line in inpf.readlines(): | |
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("FR "): | |
if saw_labels: | |
saw_labels = False | |
self.fr.append(FR(line)) | |
if line.startswith("Labels: "): | |
self.labels = line[8:].strip() | |
saw_labels = True | |
if saw_labels and line.startswith(" "): | |
self.labels += line.strip() | |
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) | |