| """Tokenize LibriSpeech dev-clean and dev-other (OpenSLR FLAC release) with the four DSU tokenizers. |
| |
| Analysis audio for the unit-representation analyses (plans/Plan - Ablations and Unit Embedding Analyses, section 3.0). |
| Same pipeline and settings as build_dsu_asr_eval_sets.py (decode_16k, the tokenizer wrappers in dsu_tokenizers.py, |
| fp32, one utterance at a time, no padding), but the audio comes from the extracted OpenSLR tarballs in |
| downloads/librispeech_dev/LibriSpeech/<split>/ instead of HF parquet, and the device is the first visible GPU (the |
| queue sets CUDA_VISIBLE_DEVICES) rather than the hard-wired GPU 3. |
| |
| One HF dataset per tokenizer at <out-root>/librispeech-<dev_clean|dev_other>/<tokenizer>/ with the eval-set columns |
| ID (str), transcript (str, OpenSLR text unmodified), speech_tokens (list[int64]), duration (float, s) |
| and identical row order (sorted by ID) across tokenizers. Word and phone alignments are joined separately by the |
| speech-integration repo (scripts/data/build_analysis_alignments.py), so this script needs no repo code. |
| |
| CUDA_VISIBLE_DEVICES=0 HF_HUB_OFFLINE=1 .venv-tokenizers/bin/python -I \ |
| scripts/build_librispeech_dev_sets.py --splits dev-clean dev-other |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import glob |
| import json |
| import os |
| import sys |
| import time |
|
|
| import torch |
| from datasets import Dataset |
|
|
|
|
| sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) |
| from build_dsu_asr_eval_sets import FEATURES, decode_16k |
| from dsu_tokenizers import TOKENIZERS |
|
|
|
|
| ROOT = "/home/anilkeshwani/scratch/speech-integration/eval_data" |
| AUDIO_ROOT = os.path.join(ROOT, "downloads", "librispeech_dev", "LibriSpeech") |
| SPLITS = {"dev-clean": "librispeech-dev_clean", "dev-other": "librispeech-dev_other"} |
| OPENSLR_MD5 = {"dev-clean": "42e2234ba48799c1f50f24a7926300a1", "dev-other": "c8d0bcc9cca99d4f8b62fcc847357931"} |
|
|
|
|
| def read_split(split: str) -> list[tuple[str, str, str]]: |
| """(ID, transcript, flac path) for every utterance of an extracted OpenSLR split, sorted by ID.""" |
| rows = [] |
| for trans in sorted(glob.glob(os.path.join(AUDIO_ROOT, split, "*", "*", "*.trans.txt"))): |
| with open(trans) as f: |
| for line in f: |
| uid, text = line.rstrip("\n").split(" ", 1) |
| path = os.path.join(os.path.dirname(trans), f"{uid}.flac") |
| if not os.path.isfile(path): |
| raise FileNotFoundError(path) |
| rows.append((uid, text, path)) |
| if not rows: |
| raise FileNotFoundError(f"No transcripts under {os.path.join(AUDIO_ROOT, split)}") |
| rows.sort(key=lambda r: r[0]) |
| if len({r[0] for r in rows}) != len(rows): |
| raise ValueError(f"{split}: duplicate IDs") |
| return rows |
|
|
|
|
| def build(split: str, tokenizers: dict, out_root: str, limit: int | None) -> dict: |
| name = SPLITS[split] |
| rows = read_split(split)[:limit] |
| ids, transcripts, durations = [], [], [] |
| tokens = {t: [] for t in tokenizers} |
| t0 = time.time() |
| for i, (uid, text, path) in enumerate(rows): |
| with open(path, "rb") as f: |
| wav, dur = decode_16k(f.read()) |
| ids.append(uid) |
| transcripts.append(text) |
| durations.append(float(dur)) |
| for t, tok in tokenizers.items(): |
| tokens[t].append(tok.encode(wav)) |
| if (i + 1) % 500 == 0: |
| print(f"[{name}] {i + 1} rows, {sum(durations) / 3600:.2f} h, {time.time() - t0:.0f} s", flush=True) |
| for t in tokenizers: |
| ds = Dataset.from_dict( |
| {"ID": ids, "transcript": transcripts, "speech_tokens": tokens[t], "duration": durations}, |
| features=FEATURES, |
| ) |
| out = os.path.join(out_root, name, t) |
| ds.save_to_disk(out) |
| print(f"[{name}] saved {len(ds)} rows to {out}", flush=True) |
| meta = { |
| "eval_set": name, |
| "source": f"https://www.openslr.org/resources/12/{split}.tar.gz", |
| "source_md5": OPENSLR_MD5[split], |
| "transcript_field": "OpenSLR *.trans.txt", |
| "row_order": "sorted by ID", |
| "n_rows": len(ids), |
| "total_hours": sum(durations) / 3600, |
| "max_duration_s": max(durations), |
| "limit": limit, |
| "tokenizers": {t: {"n_tokens": int(sum(map(len, tokens[t])))} for t in tokenizers}, |
| "elapsed_s": time.time() - t0, |
| } |
| with open(os.path.join(out_root, name, "build_info.json"), "w") as f: |
| json.dump(meta, f, indent=2) |
| return meta |
|
|
|
|
| def main() -> None: |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--splits", nargs="+", default=list(SPLITS), choices=list(SPLITS)) |
| ap.add_argument("--tokenizers", nargs="+", default=list(TOKENIZERS), choices=list(TOKENIZERS)) |
| ap.add_argument("--out-root", default=ROOT) |
| ap.add_argument("--limit", type=int, default=None, help="Only the first N rows (smoke test)") |
| ap.add_argument("--device", default=None, help="Default: cuda:0 (first visible GPU) if available, else cpu") |
| args = ap.parse_args() |
| device = torch.device(args.device or ("cuda:0" if torch.cuda.is_available() else "cpu")) |
| print(f"device {device}, CUDA_VISIBLE_DEVICES={os.environ.get('CUDA_VISIBLE_DEVICES')!r}", flush=True) |
| tokenizers = {t: TOKENIZERS[t](device) for t in args.tokenizers} |
| for split in args.splits: |
| meta = build(split, tokenizers, args.out_root, args.limit) |
| print(json.dumps(meta), flush=True) |
| if torch.cuda.is_available(): |
| print(f"peak GPU memory {torch.cuda.max_memory_allocated() / 2**30:.2f} GiB", flush=True) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
