Add the ReazonSpeech recipe

docs/corpus.rst

@@ -165,6 +165,8 @@ a CLI tool that create the manifests given a corpus directory.
  - :func:`lhotse.recipes.prepare_nsc`
  * - People's Speech
  - :func:`lhotse.recipes.prepare_peoples_speech`
+ * - ReazonSpeech
+ - :func:`lhotse.recipes.prepare_reazonspeech`
  * - RIRs and Noises Corpus (OpenSLR 28)
  - :func:`lhotse.recipes.prepare_rir_noise`
  * - Speech Commands

lhotse/bin/modes/recipes/__init__.py

@@ -63,6 +63,7 @@
 from .nsc import *
 from .peoples_speech import *
 from .primewords import *
+from .reazonspeech import *
 from .rir_noise import *
 from .slu import *
 from .speechcommands import *

lhotse/bin/modes/recipes/reazonspeech.py

@@ -0,0 +1,52 @@
+import logging
+from typing import List
+
+import click
+
+from lhotse.bin.modes import download, prepare
+from lhotse.recipes.reazonspeech import (
+ REAZONSPEECH,
+ download_reazonspeech,
+ prepare_reazonspeech,
+)
+from lhotse.utils import Pathlike
+
+__all__ = ["reazonspeech"]
+
+
+@prepare.command(context_settings=dict(show_default=True))
+@click.argument("corpus_dir", type=click.Path(exists=True, dir_okay=True))
+@click.argument("output_dir", type=click.Path())
+@click.option(
+ "-j",
+ "--num-jobs",
+ type=int,
+ default=1,
+ help="How many threads to use (can give good speed-ups with slow disks).",
+)
+def reazonspeech(
+ corpus_dir: Pathlike,
+ output_dir: Pathlike,
+ num_jobs: int,
+):
+ """ReazonSpeech ASR data preparation."""
+ logging.basicConfig(level=logging.INFO)
+ prepare_reazonspeech(corpus_dir, output_dir=output_dir, num_jobs=num_jobs)
+
+
+@download.command(context_settings=dict(show_default=True))
+@click.argument("target_dir", type=click.Path())
+@click.option(
+ "--subset",
+ type=click.Choice(("auto",) + REAZONSPEECH),
+ multiple=True,
+ default=["auto"],
+ help="List of dataset parts to prepare (default: small-v1). To prepare multiple parts, pass each with `--subset` "
+ "Example: `--subset all",
+)
+def reazonspeech(target_dir: Pathlike, subset: List[str]):
+ """ReazonSpeech download."""
+ logging.basicConfig(level=logging.INFO)
+ if "auto" in subset:
+ subset = "auto"
+ download_reazonspeech(target_dir, dataset_parts=subset)

lhotse/recipes/__init__.py

@@ -64,6 +64,7 @@
 from .musan import download_musan, prepare_musan
 from .nsc import prepare_nsc
 from .peoples_speech import prepare_peoples_speech
+from .reazonspeech import download_reazonspeech, prepare_reazonspeech
 from .rir_noise import download_rir_noise, prepare_rir_noise
 from .slu import prepare_slu
 from .speechcommands import download_speechcommands, prepare_speechcommands
@@ -180,6 +181,8 @@
  "prepare_musan",
  "prepare_nsc",
  "prepare_peoples_speech",
+ "download_reazonspeech",
+ "prepare_reazonspeech",
  "download_rir_noise",
  "prepare_rir_noise",
  "prepare_slu",

lhotse/recipes/reazonspeech.py

@@ -0,0 +1,243 @@
+"""
+ReazonSpeech is an open-source dataset that contains a diverse set of natural Japanese speech,
+collected from terrestrial television streams. It contains more than 35,000 hours of audio.
+
+The dataset is available on Hugging Face. For more details, please visit:
+
+Dataset: https://huggingface.co/datasets/reazon-research/reazonspeech
+Paper: https://research.reazon.jp/_static/reazonspeech_nlp2023.pdf
+"""
+
+import json
+import logging
+import re
+from collections import defaultdict
+from pathlib import Path
+from typing import Any, Dict, Optional, Sequence, Tuple, Union
+
+from tqdm.auto import tqdm
+
+from lhotse import CutSet, fix_manifests, validate_recordings_and_supervisions
+from lhotse.audio import Recording, RecordingSet
+from lhotse.parallel import parallel_map
+from lhotse.recipes.utils import manifests_exist, read_manifests_if_cached
+from lhotse.supervision import SupervisionSegment, SupervisionSet
+from lhotse.utils import Pathlike, is_module_available
+
+REAZONSPEECH = (
+ "tiny",
+ "small",
+ "medium",
+ "large",
+ "all",
+ "small-v1",
+ "medium-v1",
+ "all-v1",
+)
+
+PUNCTUATIONS = {ord(x): "" for x in "、。「」『』，,？！!!?!?"}
+ZENKAKU = "ａｂｃｄｅｆｇｈｉｊｋｌｍｎｏｐｑｒｓｔｕｖｗｘｙｚＡＢＣＤＥＦＧＨＩＪＫＬＭＮＯＰＱＲＳＴＵＶＷＸＹＺ０１２３４５６７８９"
+HANKAKU = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
+ZEN2HAN = str.maketrans(ZENKAKU, HANKAKU)
+
+
+def normalize(s):
+ """
+ Convert full-width characters to half-width, and remove punctuations.
+ :param s: str, input string.
+ :return: str, normalized string.
+ """
+ if is_module_available("num2words"):
+ import num2words
+ else:
+ raise ImportError(
+ "To process the ReazonSpeech corpus, please install optional dependency: pip install num2words"
+ )
+ s = s.translate(PUNCTUATIONS).translate(ZEN2HAN)
+ conv = lambda m: num2words.num2words(m.group(0), lang="ja")
+ return re.sub(r"\d+\.?\d*", conv, s)
+
+
+def write_to_json(data, filename):
+ """
+ Writes data to a JSON file.
+ :param data: The data to write.
+ :param filename: The name of the file to write to.
+ """
+
+ with open(filename, "w", encoding="utf-8") as f:
+ json.dump(data, f, ensure_ascii=False, indent=4)
+
+
+def download_reazonspeech(
+ target_dir: Pathlike = ".",
+ dataset_parts: Optional[Union[str, Sequence[str]]] = "auto",
+) -> Path:
+ """
+ Download the ReazonSpeech dataset.
+ :param target_dir: Pathlike, the path of the dir to storage the dataset.
+ :param dataset_parts: the parts of the dataset to download (e.g. small, medium, or large).
+ :return: the path to downloaded data and the JSON file.
+ """
+ if is_module_available("datasets"):
+ from datasets import load_dataset
+ else:
+ raise ImportError(
+ "To process the ReazonSpeech corpus, please install optional dependency: pip install datasets"
+ )
+ target_dir = Path(target_dir)
+ target_dir.mkdir(parents=True, exist_ok=True)
+ corpus_dir = target_dir / "ReazonSpeech"
+
+ if dataset_parts == "auto":
+ dataset_parts = ("small-v1",)
+ elif isinstance(dataset_parts, str):
+ dataset_parts = [dataset_parts]
+
+ for part in dataset_parts:
+ logging.info(f"Downloading ReazonSpeech part: {part}")
+ ds = load_dataset(
+ "reazon-research/reazonspeech",
+ part,
+ trust_remote_code=True,
+ cache_dir=corpus_dir,
+ )["train"]
+
+ # Prepare data for JSON export
+ data_for_json = []
+ idx = 0
+ for item in ds:
+ # Calculate the duration of the audio file
+ audio_array = item["audio"]["array"]
+ sampling_rate = item["audio"]["sampling_rate"]
+ duration = len(audio_array) / float(sampling_rate)
+
+ # Create a dictionary for the current record
+ record = {
+ "id": str(idx),
+ "audio_filepath": item["audio"]["path"],
+ "text": normalize(item["transcription"]),
+ "duration": duration,
+ }
+
+ # Append the record to the list
+ data_for_json.append(record)
+ idx += 1
+
+ # Write data to a JSON file
+ write_to_json(data_for_json, corpus_dir / "dataset.json")
+
+ return corpus_dir
+
+
+def prepare_reazonspeech(
+ corpus_dir: Pathlike,
+ output_dir: Optional[Pathlike],
+ num_jobs: int = 1,
+) -> Dict[str, Dict[str, Union[RecordingSet, SupervisionSet]]]:
+ """
+ Returns the manifests which consist of the Recordings and Supervisions.
+ When all the manifests are available in the ``output_dir``, it will simply read and return them.
+ :param corpus_dir: Pathlike, the path of the data dir.
+ :param output_dir: Pathlike, the path where to write the manifests.
+ :param num_jobs: int, number of parallel threads used for 'parse_utterance' calls.
+ :return: a Dict whose key is the dataset part, and the value is Dicts with the keys 'audio' and 'supervisions'.
+ """
+ corpus_dir = Path(corpus_dir)
+ assert corpus_dir.is_dir(), f"No such directory: {corpus_dir}"
+
+ # Split the dataset into train, dev, and test
+ with open(corpus_dir / "dataset.json", "r", encoding="utf-8") as file:
+ full = json.load(file)
+ dev = full[:1000]
+ test = full[1000:1100]
+ train = full[1100:]
+
+ write_to_json(train, corpus_dir / "train.json")
+ write_to_json(dev, corpus_dir / "dev.json")
+ write_to_json(test, corpus_dir / "test.json")
+
+ parts = ("train", "dev", "test")
+
+ output_dir = Path(output_dir)
+ output_dir.mkdir(parents=True, exist_ok=True)
+ # Maybe some manifests already exist: we can read them and save a bit of preparation time.
+ manifests = read_manifests_if_cached(
+ dataset_parts=parts,
+ output_dir=output_dir,
+ prefix="reazonspeech",
+ suffix="jsonl.gz",
+ lazy=True,
+ )
+
+ for part in parts:
+ logging.info(f"Processing ReazonSpeech subset: {part}")
+ if manifests_exist(
+ part=part, output_dir=output_dir, prefix="reazonspeech", suffix="jsonl.gz"
+ ):
+ logging.info(f"ReazonSpeech subset: {part} already prepared - skipping.")
+ continue
+
+ filename = corpus_dir / f"{part}.json"
+ with open(filename, "r", encoding="utf-8") as file:
+ items = json.load(file)
+
+ with RecordingSet.open_writer(
+ output_dir / f"reazonspeech_recordings_{part}.jsonl.gz"
+ ) as rec_writer, SupervisionSet.open_writer(
+ output_dir / f"reazonspeech_supervisions_{part}.jsonl.gz"
+ ) as sup_writer, CutSet.open_writer(
+ output_dir / f"reazonspeech_cuts_{part}.jsonl.gz"
+ ) as cut_writer:
+ for recording, segment in tqdm(
+ parallel_map(
+ parse_utterance,
+ items,
+ num_jobs=num_jobs,
+ ),
+ desc="Processing reazonspeech JSON entries",
+ ):
+ # Fix and validate the recording + supervisions
+ recordings, segments = fix_manifests(
+ recordings=RecordingSet.from_recordings([recording]),
+ supervisions=SupervisionSet.from_segments([segment]),
+ )
+ validate_recordings_and_supervisions(
+ recordings=recordings, supervisions=segments
+ )
+ # Create the cut since most users will need it anyway.
+ # There will be exactly one cut since there's exactly one recording.
+ cuts = CutSet.from_manifests(
+ recordings=recordings, supervisions=segments
+ )
+ # Write the manifests
+ rec_writer.write(recordings[0])
+ sup_writer.write(segments[0])
+ cut_writer.write(cuts[0])
+
+ manifests[part] = {
+ "recordings": RecordingSet.from_jsonl_lazy(rec_writer.path),
+ "supervisions": SupervisionSet.from_jsonl_lazy(sup_writer.path),
+ "cuts": CutSet.from_jsonl_lazy(cut_writer.path),
+ }
+
+ return dict(manifests)
+
+
+def parse_utterance(item: Any) -> Optional[Tuple[Recording, SupervisionSegment]]:
+ """
+ Process a single utterance from the ReazonSpeech dataset.
+ :param item: The utterance to process.
+ :return: A tuple containing the Recording and SupervisionSegment.
+ """
+ recording = Recording.from_file(item["audio_filepath"], recording_id=item["id"])
+ segments = SupervisionSegment(
+ id=item["id"],
+ recording_id=item["id"],
+ start=0.0,
+ duration=item["duration"],
+ channel=0,
+ language="Japanese",
+ text=item["text"],
+ )
+ return recording, segments