inital commit

bu_radio.py

@@ -0,0 +1,194 @@
+"""(BURN) Boston University Radio News Corpus."""
+
+import os
+from pathlib import Path
+import hashlib
+import pickle
+
+import datasets
+import pandas as pd
+import numpy as np
+from tqdm.contrib.concurrent import process_map
+from tqdm.auto import tqdm
+from multiprocessing import cpu_count
+# from phones.convert import Converter
+import torchaudio
+import torchaudio.transforms as AT
+from functools import lru_cache
+
+logger = datasets.logging.get_logger(__name__)
+
+_PHONESET = "arpabet"
+
+_MAX_WORKERS = os.environ.get("BURN_MAX_WORKERS", cpu_count())
+_PATH = os.environ.get("BURN_PATH", None)
+
+_VERSION = "0.0.1"
+
+_CITATION = """\
+@article{ostendorf1995boston,
+  title={The Boston University radio news corpus},
+  author={Ostendorf, Mari and Price, Patti J and Shattuck-Hufnagel, Stefanie},
+  journal={Linguistic Data Consortium},
+  pages={1--19},
+  year={1995}
+}
+"""
+
+_DESCRIPTION = """\
+The Boston University Radio Speech Corpus was collected primarily to support research in text-to-speech synthesis, particularly generation of prosodic patterns. The corpus consists of professionally read radio news data, including speech and accompanying annotations, suitable for speech and language research. 
+"""
+
+_URL = "https://catalog.ldc.upenn.edu/LDC96S36"
+
+
+class BURNConfig(datasets.BuilderConfig):
+    """BuilderConfig for BURN."""
+
+    def __init__(self, sampling_rate=16000, hop_length=256, win_length=1024, **kwargs):
+        """BuilderConfig for BURN.
+
+        Args:
+          **kwargs: keyword arguments forwarded to super.
+        """
+        super(BURNConfig, self).__init__(**kwargs)
+
+        self.sampling_rate = sampling_rate
+        self.hop_length = hop_length
+        self.win_length = win_length
+        self.seconds_per_frame = hop_length / sampling_rate
+        
+        if _PATH is None:
+            raise ValueError("Please set the environment variable BURN_PATH to point to the BURN dataset directory.")
+        
+class BURN(datasets.GeneratorBasedBuilder):
+    """BURN dataset."""
+
+    BUILDER_CONFIGS = [
+        BURNConfig(
+            name="burn",
+            version=datasets.Version(_VERSION, ""),
+        ),
+    ]
+
+    def _info(self):
+        features = {
+            "speaker": datasets.Value("string"),
+            "words": datasets.Sequence(datasets.Value("string")),
+            "word_durations": datasets.Sequence(datasets.Value("int32")),
+            "prominence": datasets.Sequence(datasets.Value("bool")),
+            "break": datasets.Sequence(datasets.Value("bool")),
+            "audio": datasets.Value("string"),
+        }
+
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=datasets.Features(features),
+            supervised_keys=["prominence", "break"],
+            homepage="https://catalog.ldc.upenn.edu/LDC96S36",
+            citation=_CITATION,
+            task_templates=None,
+        )
+
+    def _split_generators(self, dl_manager):
+        """Returns SplitGenerators."""
+        return [
+            datasets.SplitGenerator(
+                name="train",
+                gen_kwargs={
+                    "speakers": ["f1a", "f3a", "m1b", "m2b", "m3b", "m4b"],
+                }
+            ),
+            datasets.SplitGenerator(
+                name="dev",
+                gen_kwargs={
+                    "speakers": [],
+                }
+            ),
+        ]
+
+    def _generate_example(self, file):
+        words = []
+        word_ts = []
+        word_durations = []
+        if not file.with_suffix(".ton").exists():
+            return None
+        if not file.with_suffix(".brk").exists():
+            return None
+        if not file.with_suffix(".wrd").exists():
+            return None
+        with open(file.with_suffix(".wrd"), "r") as f:
+            lines = f.readlines()
+            lines = [line for line in lines if line != "\n"]
+            # get index of "#\n" line
+            idx = lines.index("#\n")
+            lines = lines[idx+1:]
+            lines = [tuple(line.strip().split()) for line in lines]
+            # remove lines with no word
+            lines = [line for line in lines if len(line) == 3]
+            word_ts = np.array([float(start) for start, _, _ in lines])
+            words = [word for _, _, word in lines]
+        prominence = np.zeros(len(words))
+        boundary = np.zeros(len(words))
+        if len(words) <= 1:
+            return None
+        with open(file.with_suffix(".ton"), "r") as f:
+            lines = f.readlines()
+            lines = [line for line in lines if line != "\n"]
+            wrd_idx = 0
+            idx = lines.index("#\n")
+            lines = lines[idx+1:]
+            lines = [tuple(line.strip().split()[:3]) for line in lines]
+            # remove lines with no word
+            lines = [line for line in lines if len(line) == 3]
+            for start, _, accent in lines:
+                # find word index
+                while float(start) > word_ts[wrd_idx]:
+                    wrd_idx += 1
+                    if wrd_idx >= len(word_ts):
+                        # warning
+                        logger.warning(f"Word index {wrd_idx} out of bounds for file {file}")
+                        return None
+                if accent in ['H*', 'L*', 'L*+H', 'L+H*', 'H+', '!H*']:
+                    prominence[wrd_idx] = 1
+        with open(file.with_suffix(".brk"), "r") as f:
+            lines = f.readlines()
+            lines = [line for line in lines if line != "\n"]
+            wrd_idx = 0
+            idx = lines.index("#\n")
+            lines = lines[idx+1:]
+            lines = [tuple(line.strip().split()) for line in lines]
+            if np.abs(len(lines) - len(words)) > 2:
+                logger.warning(f"Word count mismatch for file {file}")
+                return None
+            for l in lines:
+                if len(l) < 3:
+                    continue
+                score = l[2]
+                start = float(l[0])
+                # find word index, by finding the start value closest to word_ts
+                wrd_idx = np.argmin(np.abs(word_ts - start))
+                if "3" in score or "4" in score:
+                    boundary[wrd_idx] = 1
+        # compute word durations using self.config.seconds_per_frame
+        word_diff = np.concatenate([[word_ts[0]], np.diff(word_ts)])
+        word_durations = np.round(word_diff / self.config.seconds_per_frame).astype(np.int32)
+        return {
+            "words": words,
+            "word_durations": word_durations,
+            "prominence": prominence,
+            "break": boundary,
+            "audio": str(file),
+        }
+
+    def _generate_examples(self, speakers):
+        files = list((Path(_PATH)).glob(f"**/*.sph"))
+        speakers = [str(file).replace(_PATH, "").split("/")[1] for file in files]
+        #speaker_list.extend([speaker] * len(speaker_sph_files))
+        j = 0
+        for i, file in enumerate(files):
+            example = self._generate_example(file)
+            if example is not None:
+                example["speaker"] = speakers[i]
+                yield j, example
+                j += 1

test.py

@@ -0,0 +1,23 @@
+from datasets import load_dataset
+import numpy as np
+
+ds = load_dataset("bu_radio.py")
+
+prominence = ds["train"]["prominence"]
+boundary = ds["train"]["break"]
+audio = ds["train"]["audio"]
+
+audio_names = [a.split("/")[-1] for a in audio]
+print(len(audio_names), len(set(audio_names)))
+
+# flatten
+prominence = np.concatenate(prominence)
+boundary = np.concatenate(boundary)
+
+prom_true = np.sum(prominence==True)
+prom_false = np.sum(prominence==False)
+bound_true = np.sum(boundary==True)
+bound_false = np.sum(boundary==False)
+
+print("prominence:", prom_true, prom_false, np.round(prom_false/(prom_true+prom_false)*100,1), (prom_true+prom_false))
+print("break:     ", bound_true, bound_false, np.round(bound_false/(bound_true+bound_false)*100,1), (bound_true+bound_false))