Upload xlsr1b_optuna_job.py with huggingface_hub

xlsr1b_optuna_job.py

@@ -0,0 +1,263 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#   "torch", "transformers", "datasets", "peft", "accelerate",
+#   "jiwer", "evaluate", "optuna", "pyctcdecode",
+#   "soundfile", "librosa", "huggingface_hub", "requests", "numpy",
+# ]
+# ///
+"""
+Optuna LoRA search for XLS-R 1B (CTC) + an n-gram LM decoder.
+
+Same recipe as wav2vec2_optuna_job.py — same data, same fixed 50-rec val split,
+same KenLM domain decoder, same objective (word accuracy with LM decoding) — on
+a 3x larger encoder. wav2vec2-large-960h-lv60-self is 317M and got WER 0.24;
+xls-r-1b is 965M. This is the "does scale help" experiment, run so the ONLY
+variable is the base model.
+
+THREE things make this more than a BASE_MODEL swap:
+
+1. XLS-R ships no tokenizer and no CTC head. It is a pretrained encoder only —
+   960 hours of nothing, in 128 languages. So the head is randomly initialised
+   here and MUST be trained: `modules_to_save=["lm_head"]` puts it alongside the
+   LoRA weights in the adapter. The vocab is lifted verbatim from the 960h model
+   so every downstream stage (clean(), the tokenizer, the pyctcdecode labels)
+   behaves exactly as it did in the run we're comparing against.
+
+2. A randomly initialised head is a real risk to this whole experiment. In the
+   317M run LoRA nudged a head that already knew English; here it has to teach
+   one from 255 clips. If XLS-R underperforms, "the head never converged" and
+   "the model is wrong for dysarthric speech" look identical from the outside —
+   so the search space goes up to r=64, and the final run gets more steps.
+
+3. Memory. 965M params in fp32 (CTC's log-sum-exp overflows in fp16, measured in
+   the 317M run) does not train on a T4's 16GB. Gradient checkpointing, batch 1
+   x accum 16, and a 24GB flavor.
+
+SpecAugment is OFF. It cost us NaNs in the 317M search, and masking augmentation
+earns its keep on large corpora, not on 255 recordings from one speaker.
+
+Output: best LoRA adapter (with the trained lm_head) + the LM -> HF_PUSH_REPO.
+"""
+import os, re, gc, sys, random, subprocess, tempfile, logging
+import numpy as np
+import requests, soundfile as sf, librosa, torch
+from pathlib import Path
+import evaluate
+from datasets import Dataset
+from transformers import (Wav2Vec2ForCTC, Wav2Vec2Processor, Wav2Vec2CTCTokenizer,
+                          Wav2Vec2FeatureExtractor, Trainer, TrainingArguments)
+from peft import LoraConfig, get_peft_model
+import optuna
+from huggingface_hub import HfApi, login
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(message)s")
+log = logging.getLogger(__name__)
+subprocess.run(["apt-get", "update", "-q"], check=True)
+subprocess.run(["apt-get", "install", "-y", "-q", "ffmpeg"], check=True)
+
+HF_TOKEN          = os.environ["HF_TOKEN"]
+HF_PUSH_REPO      = os.environ.get("HF_PUSH_REPO", "logosaccessibleexpression/training-scripts")
+HF_PUSH_SUBFOLDER = os.environ.get("HF_PUSH_SUBFOLDER", "xlsr1b-lora-d43df745")
+SUPABASE_URL      = os.environ["SUPABASE_URL"]
+SERVICE_ROLE_KEY  = os.environ["SUPABASE_SERVICE_ROLE_KEY"]
+USER_ID           = os.environ["USER_ID"]
+BASE_MODEL        = os.environ.get("BASE_MODEL", "facebook/wav2vec2-xls-r-1b")
+# Where the character vocab comes from. Keeping the 960h vocab means the LM
+# decoder, the label cleaning and the reported WER are all directly comparable
+# with the 317M run — the point of the experiment.
+VOCAB_MODEL       = os.environ.get("VOCAB_MODEL", "facebook/wav2vec2-large-960h-lv60-self")
+# Fewer, longer trials than the 317M search: a 1B step costs ~3x, and an
+# undertrained random head is the failure mode we most need to rule out.
+N_TRIALS    = int(os.environ.get("N_TRIALS", "8"))
+TRIAL_STEPS = int(os.environ.get("TRIAL_STEPS", "400"))
+FINAL_STEPS = int(os.environ.get("FINAL_STEPS", "4000"))
+N_VAL       = int(os.environ.get("N_VAL", "50"))
+LM_ORDER    = int(os.environ.get("LM_ORDER", "3"))
+
+TARGET_PRESETS = {
+    "minimal":   ["q_proj", "v_proj"],
+    "attention": ["q_proj", "k_proj", "v_proj", "out_proj"],
+    "full":      ["q_proj", "k_proj", "v_proj", "out_proj", "intermediate_dense", "output_dense"],
+}
+
+login(token=HF_TOKEN)
+# XLS-R's own feature extractor (it normalises and returns an attention mask,
+# which the layer-norm architecture needs); the 960h tokenizer for the vocab.
+processor = Wav2Vec2Processor(
+    feature_extractor=Wav2Vec2FeatureExtractor.from_pretrained(BASE_MODEL),
+    tokenizer=Wav2Vec2CTCTokenizer.from_pretrained(VOCAB_MODEL),
+)
+log.info(f"base={BASE_MODEL} vocab={len(processor.tokenizer)} from {VOCAB_MODEL}")
+wer_metric = evaluate.load("wer")
+
+# ── Data ──────────────────────────────────────────────────────────────────────
+hdrs = {"apikey": SERVICE_ROLE_KEY, "Authorization": f"Bearer {SERVICE_ROLE_KEY}"}
+def sb_get(table, select, filters=None):
+    p = {"select": select}; p.update(filters or {})
+    r = requests.get(f"{SUPABASE_URL}/rest/v1/{table}", headers=hdrs, params=p); r.raise_for_status()
+    return r.json()
+
+recs = sb_get("training_recordings", "audio_url,phrase_id", {"user_id": f"eq.{USER_ID}"})
+pmap = {p["id"]: p["text"] for p in sb_get("training_phrases", "id,text")}
+rows = [{"audio_url": r["audio_url"], "text": pmap[r["phrase_id"]]} for r in recs if r["phrase_id"] in pmap]
+log.info(f"Found {len(rows)} recordings")
+
+WAV_DIR = Path(tempfile.mkdtemp())
+def download_audio(url, idx):
+    r = requests.get(url.replace("/object/public/", "/object/"), headers=hdrs)
+    if not r.ok: return None
+    ext = url.split("?")[0].rsplit(".", 1)[-1].lower()
+    raw = WAV_DIR / f"{idx}.{ext}"; raw.write_bytes(r.content)
+    if ext != "wav":
+        wav = WAV_DIR / f"{idx}.wav"
+        if subprocess.run(["ffmpeg","-y","-i",str(raw),"-ac","1","-ar","16000","-sample_fmt","s16",str(wav)],
+                          capture_output=True).returncode != 0: return None
+        raw = wav
+    try: audio, sr = sf.read(str(raw))
+    except Exception: return None
+    if audio.ndim > 1: audio = audio.mean(axis=1)
+    if sr != 16000: audio = librosa.resample(audio, orig_sr=sr, target_sr=16000)
+    return audio.astype(np.float32)
+
+clean = lambda t: re.sub(r"[^A-Z' ]", "", t.upper()).strip()    # 960h vocab is uppercase A-Z + |
+data = []
+for i, row in enumerate(rows):
+    a = download_audio(row["audio_url"], i); txt = clean(row["text"])
+    if a is None or len(a) < 800 or not txt: continue
+    data.append({"audio": a, "ref": txt})
+log.info(f"Usable: {len(data)}")
+
+random.seed(42); random.shuffle(data)   # same seed as the 317M run == same split
+val_data, train_raw = data[:N_VAL], data[N_VAL:]
+def featurize(d):
+    return {"input_values": processor(d["audio"], sampling_rate=16000).input_values[0],
+            "labels": processor.tokenizer(d["ref"]).input_ids}
+train_ds = Dataset.from_list([featurize(d) for d in train_raw])
+log.info(f"Train {len(train_ds)}  Val {len(val_data)}")
+
+# ── Build the domain n-gram LM decoder (KenLM + pyctcdecode) ───────────────────
+def build_lm_decoder():
+    texts = set()
+    for p in pmap.values():
+        c = clean(p).lower()
+        if c: texts.add(c)
+    try:
+        for h in sb_get("transcription_history", "transcript", {"user_id": f"eq.{USER_ID}"}):
+            c = clean(h.get("transcript", "")).lower()
+            if len(c.split()) >= 2: texts.add(c)         # skip 1-word interim-flush fragments
+    except Exception as e:
+        log.info(f"history fetch skipped: {e}")
+    Path("/tmp/corpus.txt").write_text("\n".join(sorted(texts)))
+    log.info(f"LM corpus: {len(texts)} lines, {LM_ORDER}-gram")
+    subprocess.run("apt-get install -y -q build-essential cmake git "
+                   "libboost-all-dev libbz2-dev liblzma-dev zlib1g-dev", shell=True, check=True)
+    subprocess.run("git clone --depth 1 https://github.com/kpu/kenlm.git /tmp/klm", shell=True, check=True)
+    subprocess.run("cmake -S /tmp/klm -B /tmp/klm/build -DCMAKE_BUILD_TYPE=Release && "
+                   "cmake --build /tmp/klm/build -j4 --target lmplz build_binary", shell=True, check=True)
+    subprocess.run(["uv", "pip", "install", "--python", sys.executable,
+                    "https://github.com/kpu/kenlm/archive/master.zip"], check=True)
+    subprocess.run(f"/tmp/klm/build/bin/lmplz -o {LM_ORDER} --discount_fallback "
+                   f"< /tmp/corpus.txt > /tmp/lm.arpa", shell=True, check=True)
+    from pyctcdecode import build_ctcdecoder
+    vocab = {k.lower(): v for k, v in sorted(processor.tokenizer.get_vocab().items(), key=lambda x: x[1])}
+    return build_ctcdecoder(labels=list(vocab.keys()), kenlm_model_path="/tmp/lm.arpa")
+
+decoder = build_lm_decoder()
+
+class CTCCollator:
+    def __call__(self, feats):
+        inp = processor.feature_extractor.pad([{"input_values": f["input_values"]} for f in feats], return_tensors="pt")
+        lab = processor.tokenizer.pad([{"input_ids": f["labels"]} for f in feats], return_tensors="pt")
+        inp["labels"] = lab["input_ids"].masked_fill(lab.attention_mask.ne(1), -100)
+        return inp
+collator = CTCCollator()
+
+def score(model):
+    """Word accuracy (0-1) on the fixed val set, decoded WITH the n-gram LM."""
+    model.eval(); preds, refs = [], []
+    dev = next(model.parameters()).device
+    with torch.no_grad():
+        for d in val_data:
+            iv = processor(d["audio"], sampling_rate=16000, return_tensors="pt").input_values.to(dev)
+            logits = model(iv).logits[0].cpu().numpy().astype("float32")
+            preds.append(decoder.decode(logits).lower().strip())
+            refs.append(d["ref"].lower())
+    w = wer_metric.compute(predictions=preds, references=refs)
+    return max(0.0, 1.0 - w), w
+
+def build(r, dropout, modules_key):
+    m = Wav2Vec2ForCTC.from_pretrained(
+        BASE_MODEL,
+        vocab_size=len(processor.tokenizer),      # XLS-R has no head; this makes one
+        ctc_loss_reduction="mean",
+        # Long input, short label -> infinite loss. Zeroing those keeps one bad
+        # clip from poisoning the whole run, which matters more here because a
+        # random head produces garbage alignments for the first few hundred steps.
+        ctc_zero_infinity=True,
+        apply_spec_augment=False,                 # cost us NaNs at 317M; useless at n=255
+        pad_token_id=processor.tokenizer.pad_token_id,
+        ignore_mismatched_sizes=True,
+    )
+    m.freeze_feature_encoder()
+    m.config.ctc_zero_infinity = True
+    peft = get_peft_model(m, LoraConfig(
+        r=r, lora_alpha=r * 2, lora_dropout=dropout,
+        target_modules=TARGET_PRESETS[modules_key], bias="none",
+        # The head is randomly initialised, so it is not a thing LoRA can adapt —
+        # it has to be trained and saved outright, or the adapter is useless on
+        # its own.
+        modules_to_save=["lm_head"],
+    ))
+    # Gradient checkpointing needs an input that requires grad, and a frozen
+    # feature encoder doesn't give it one.
+    peft.enable_input_require_grads()
+    return peft
+
+def train_args(out, lr, warmup, wd, steps):
+    # fp32 (CTC overflows in fp16). 965M params only fits with checkpointing and
+    # batch 1; accum 16 keeps the effective batch at the 317M run's 16.
+    return TrainingArguments(out, per_device_train_batch_size=1, gradient_accumulation_steps=16,
+        learning_rate=lr, warmup_steps=warmup, weight_decay=wd, max_steps=steps,
+        fp16=False, gradient_checkpointing=True, logging_steps=100, save_strategy="no",
+        report_to=[], remove_unused_columns=False, label_names=["labels"])
+
+# ── Optuna ────────────────────────────────────────────────────────────────────
+def objective(trial):
+    # r goes to 64 here: the 317M search liked r=32 with an English head already
+    # in place, and this one is also paying for a head from scratch.
+    r       = trial.suggest_categorical("r", [16, 32, 64])
+    dropout = trial.suggest_categorical("lora_dropout", [0.0, 0.05])
+    lr      = trial.suggest_float("learning_rate", 5e-5, 5e-4, log=True)
+    modules = trial.suggest_categorical("target_modules", ["attention", "full"])
+    warmup  = trial.suggest_categorical("warmup_steps", [50, 100])
+    wd      = trial.suggest_categorical("weight_decay", [0.0, 0.01])
+    log.info(f"=== Trial {trial.number} r={r} drop={dropout} lr={lr:.2e} mods={modules} warm={warmup} wd={wd}")
+    m = build(r, dropout, modules)
+    Trainer(model=m, args=train_args(f"/tmp/t{trial.number}", lr, warmup, wd, TRIAL_STEPS),
+            train_dataset=train_ds, data_collator=collator).train()
+    acc, w = score(m)
+    log.info(f"Trial {trial.number} -> acc={acc:.3f} WER={w:.3f}  (n-gram LM)")
+    del m; gc.collect(); torch.cuda.empty_cache()
+    return acc
+
+optuna.logging.set_verbosity(optuna.logging.WARNING)
+study = optuna.create_study(direction="maximize", study_name="xlsr1b_lora_ngram")
+study.optimize(objective, n_trials=N_TRIALS)
+best = study.best_params
+log.info(f"BEST acc={study.best_value:.3f} params={best}")
+
+# ── Final: best config, FINAL_STEPS on ALL data; push adapter + LM ────────────
+full_ds = Dataset.from_list([featurize(d) for d in data])
+m = build(best["r"], best["lora_dropout"], best["target_modules"])
+Trainer(model=m, args=train_args("/tmp/xlsr_best", best["learning_rate"], best["warmup_steps"],
+        best["weight_decay"], FINAL_STEPS), train_dataset=full_ds, data_collator=collator).train()
+acc, w = score(m)
+log.info(f"final acc={acc:.3f} WER={w:.3f}   (317M reference: WER 0.24)")
+
+SAVE = "/tmp/xlsr_adapter"
+m.save_pretrained(SAVE); processor.save_pretrained(SAVE)
+import shutil; shutil.copy("/tmp/lm.arpa", f"{SAVE}/lm.arpa")   # ship the LM with the adapter
+HfApi(token=HF_TOKEN).upload_folder(folder_path=SAVE, repo_id=HF_PUSH_REPO,
+        repo_type="dataset", path_in_repo=HF_PUSH_SUBFOLDER)
+log.info(f"Pushed adapter + LM to {HF_PUSH_REPO}/{HF_PUSH_SUBFOLDER}  (val acc {acc:.3f} WER {w:.3f})")