File size: 5,579 Bytes
729e200 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 | """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 # noqa: E402
from dsu_tokenizers import TOKENIZERS # noqa: E402
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()
|