wav2vec2_optuna_job.py

# /// 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 wav2vec2 (CTC) + an n-gram LM decoder.

Mirrors the whisper-turbo-300 notebook (fixed 50-rec val, same search space,
max_steps=300 x 15 trials, best retrained 3000 steps), but for an encoder-only
CTC model. A domain KenLM n-gram (built from the user's phrases + dictation
history) is used at DECODE time via pyctcdecode — this is what closes wav2vec2's
WER gap. Objective = word accuracy (1 - WER) with LM decoding.

fp32 (not fp16): CTC's log-sum-exp overflows to nan in fp16. Runs on T4 at batch 4.
Output: best LoRA ADAPTER + the LM → HF_PUSH_REPO/subfolder (kept separate, swappable).
"""
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, 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", "wav2vec2-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-large-960h-lv60-self")
N_TRIALS    = int(os.environ.get("N_TRIALS", "15"))
TRIAL_STEPS = int(os.environ.get("TRIAL_STEPS", "300"))
FINAL_STEPS = int(os.environ.get("FINAL_STEPS", "3000"))
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)
processor = Wav2Vec2Processor.from_pretrained(BASE_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 tokenizer 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)
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)
    # Clone to a NON-'kenlm' dir so it can't shadow `import kenlm`. Build only lmplz (the CLI
    # that compiles the arpa); get the queryable python bindings from the official archive.
    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)
    # Install into THIS uv venv (plain `pip` hits the wrong env under `uv run --script`).
    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, ctc_loss_reduction="mean",
                                       pad_token_id=processor.tokenizer.pad_token_id)
    m.freeze_feature_encoder()
    return get_peft_model(m, LoraConfig(r=r, lora_alpha=r * 2, lora_dropout=dropout,
                                        target_modules=TARGET_PRESETS[modules_key], bias="none"))

def train_args(out, lr, warmup, wd, steps):
    # fp32 (CTC overflows in fp16); batch 4 x accum 4 (= effective 16) fits on a T4's 16GB.
    return TrainingArguments(output_dir=out, per_device_train_batch_size=4, gradient_accumulation_steps=4,
        learning_rate=lr, warmup_steps=warmup, weight_decay=wd, max_steps=steps,
        fp16=False, logging_steps=100, save_strategy="no",
        report_to=[], remove_unused_columns=False, label_names=["labels"])

# ── Optuna ────────────────────────────────────────────────────────────────────
def objective(trial):
    r       = trial.suggest_categorical("r", [8, 16, 32])
    dropout = trial.suggest_categorical("lora_dropout", [0.0, 0.05, 0.1])
    lr      = trial.suggest_float("learning_rate", 5e-5, 5e-4, log=True)
    modules = trial.suggest_categorical("target_modules", ["minimal", "attention", "full"])
    warmup  = trial.suggest_categorical("warmup_steps", [0, 50, 100])
    wd      = trial.suggest_categorical("weight_decay", [0.0, 0.01, 0.1])
    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="wav2vec2_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/w2v_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}")

SAVE = "/tmp/w2v_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})")