logos_reward_ft_job.py

# /// script
# requires-python = ">=3.10"
# dependencies = [
#   "torch",
#   "transformers",
#   "datasets",
#   "peft",
#   "accelerate",
#   "jiwer",
#   "syllapy",
#   "soundfile",
#   "librosa",
#   "huggingface_hub",
#   "requests",
#   "numpy",
# ]
# ///
"""
Logos Whisper Tiny — Reward-Weighted LoRA Fine-Tuning
HuggingFace Job script (uv run --script)

Scores each training example against the *existing* fine-tuned model
(logos-voice-tiny-d43df745 checkpoint-3000), so the reward signal is
discriminative: examples the current model handles well get low weight,
hard/hallucinated ones get up to 3× weight.

Fine-tuning starts from the same merged fine-tuned checkpoint and adds a
fresh LoRA delta. The final merged model (base + old LoRA + reward LoRA)
is pushed as a dataset repo (org token lacks model-create permission).

Environment variables (set as job secrets/env):
  HF_TOKEN                  — HuggingFace write token
  HF_PUSH_REPO              — dataset repo to push the trained model to
  HF_FINETUNE_REPO          — adapter repo to score/start from
  HF_FINETUNE_SUBFOLDER     — checkpoint subfolder (default: checkpoint-3000)
  SUPABASE_URL              — Supabase project URL
  SUPABASE_KEY              — Supabase anon/publishable key
  SUPABASE_SERVICE_ROLE_KEY — long-lived service role JWT (preferred over REFRESH_TOKEN)
  REFRESH_TOKEN             — Supabase session refresh token (fallback)
  USER_ID                   — Supabase user UUID
"""

import os, re, subprocess, tempfile, logging
import numpy as np
import requests
import soundfile as sf
import librosa
import syllapy
import torch
import torch.nn.functional as F
from pathlib import Path
from jiwer import process_words
from datasets import Dataset
from transformers import (
    WhisperProcessor,
    WhisperForConditionalGeneration,
    Trainer,
    TrainingArguments,
)
from peft import LoraConfig, PeftModel, get_peft_model, TaskType
from huggingface_hub import HfApi, login

logging.basicConfig(level=logging.INFO, format="%(asctime)s %(message)s")
log = logging.getLogger(__name__)

# Install system deps not present in the uv base image.
subprocess.run(["apt-get", "update", "-q"], check=True)
subprocess.run(["apt-get", "install", "-y", "-q", "ffmpeg"], check=True)

# ── Config ────────────────────────────────────────────────────────────────────
HF_TOKEN          = os.environ["HF_TOKEN"]
HF_PUSH_REPO      = os.environ.get("HF_PUSH_REPO", "logosaccessibleexpression/logos-whisper-tiny-reward-ft")
HF_FINETUNE_REPO  = os.environ.get("HF_FINETUNE_REPO", "logosaccessibleexpression/logos-voice-tiny-d43df745")
HF_FINETUNE_SUB   = os.environ.get("HF_FINETUNE_SUBFOLDER", "checkpoint-3000")
SUPABASE_URL      = os.environ["SUPABASE_URL"]
SUPABASE_KEY      = os.environ["SUPABASE_KEY"]
SERVICE_ROLE_KEY  = os.environ.get("SUPABASE_SERVICE_ROLE_KEY")
REFRESH_TOKEN     = os.environ.get("REFRESH_TOKEN")
USER_ID           = os.environ["USER_ID"]

WHISPER_BASE  = "openai/whisper-tiny"
LORA_R        = 16
LORA_ALPHA    = 32
LORA_DROPOUT  = 0.05
# Match target modules from logos-voice-tiny-d43df745 for maximum coverage.
LORA_TARGETS  = ["q_proj", "k_proj", "v_proj", "out_proj", "fc1", "fc2"]

REWARD_ALPHA  = 1.0   # WER
REWARD_BETA   = 0.5   # positional tail penalty
REWARD_GAMMA  = 0.5   # per-substitution syllable match
REWARD_DELTA  = 0.5   # total syllable count match
LOSS_SCALE    = 2.0   # max additional loss multiplier (worst → 3×, best → 1×)

BEAM_N        = 5
TRAIN_EPOCHS  = 5
BATCH_SIZE    = 8
LEARNING_RATE = 1e-4
SAVE_STEPS    = 50
OUTPUT_DIR    = "/tmp/logos_reward_ft"

# ── Supabase auth ─────────────────────────────────────────────────────────────
if SERVICE_ROLE_KEY:
    ACCESS_TOKEN = SERVICE_ROLE_KEY
    SUPABASE_KEY = SERVICE_ROLE_KEY
else:
    r = requests.post(
        f"{SUPABASE_URL}/auth/v1/token?grant_type=refresh_token",
        headers={"apikey": SUPABASE_KEY, "Content-Type": "application/json"},
        json={"refresh_token": REFRESH_TOKEN},
    )
    r.raise_for_status()
    ACCESS_TOKEN = r.json()["access_token"]
log.info("Supabase auth OK")

def sb_get(table, select="*", filters=None):
    headers = {"apikey": SUPABASE_KEY, "Authorization": f"Bearer {ACCESS_TOKEN}"}
    params  = {"select": select}
    if filters:
        params.update(filters)
    r = requests.get(f"{SUPABASE_URL}/rest/v1/{table}", headers=headers, params=params)
    r.raise_for_status()
    return r.json()

# ── Load recordings + phrase texts ───────────────────────────────────────────
recordings = sb_get("training_recordings", select="audio_url,phrase_id",
                    filters={"user_id": f"eq.{USER_ID}"})
phrases    = sb_get("training_phrases", select="id,text")
phrase_map = {p["id"]: p["text"] for p in phrases}

dataset_raw = [
    {"audio_url": r["audio_url"], "text": phrase_map[r["phrase_id"]]}
    for r in recordings if r["phrase_id"] in phrase_map
]
log.info(f"Found {len(dataset_raw)} recordings")

# ── Download + decode audio ───────────────────────────────────────────────────
WAV_DIR = Path(tempfile.mkdtemp())

def download_audio(url: str, idx: int) -> np.ndarray | None:
    auth_url = url.replace("/object/public/", "/object/")
    r = requests.get(auth_url, headers={
        "Authorization": f"Bearer {ACCESS_TOKEN}",
        "apikey": SUPABASE_KEY,
    })
    if not r.ok:
        return None

    ext      = url.split("?")[0].rsplit(".", 1)[-1].lower()
    raw_path = WAV_DIR / f"{idx}.{ext}"
    raw_path.write_bytes(r.content)

    if ext != "wav":
        wav_path = WAV_DIR / f"{idx}.wav"
        result = subprocess.run(
            ["ffmpeg", "-y", "-i", str(raw_path),
             "-ac", "1", "-ar", "16000", "-sample_fmt", "s16", str(wav_path)],
            capture_output=True,
        )
        if result.returncode != 0:
            return None
        raw_path = wav_path

    try:
        audio, sr = sf.read(str(raw_path))
    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)

skipped = 0
for i, item in enumerate(dataset_raw):
    item["audio"] = download_audio(item["audio_url"], i)
    if item["audio"] is None:
        skipped += 1

dataset_raw = [d for d in dataset_raw if d["audio"] is not None]
log.info(f"Downloaded {len(dataset_raw)} recordings ({skipped} skipped)")

# ── Reward function ───────────────────────────────────────────────────────────
def count_syllables(word: str) -> int:
    word = re.sub(r"[^a-z']", "", word.lower())
    n = syllapy.count(word)
    if n and n > 0:
        return n
    return max(1, len(re.findall(r"[aeiouy]+", word)))

def compute_reward(hypothesis: str, ground_truth: str) -> float:
    hyp = hypothesis.strip().lower()
    ref = ground_truth.strip().lower()
    if not hyp:
        return 0.0
    if hyp == ref:
        return 1.0

    hyp_words = hyp.split()
    ref_words = ref.split()

    result   = process_words(ref, hyp)
    wer_comp = max(0.0, 1.0 - result.wer)

    n_hyp = len(hyp_words)
    pos_scores, syl_scores = [], []

    for chunk in result.alignments[0]:
        ctype = chunk.type
        if ctype in ("equal", "substitute"):
            hyp_pos = chunk.hyp_start_idx
            ref_w   = ref_words[chunk.ref_start_idx] if chunk.ref_start_idx < len(ref_words) else ""
            hyp_w   = hyp_words[hyp_pos]             if hyp_pos < n_hyp else ""
            pos_w   = 1.0 - 0.5 * (hyp_pos / max(1, n_hyp - 1))
            pos_scores.append(pos_w if ctype == "equal" else 0.0)
            if ctype == "substitute" and ref_w and hyp_w:
                syl_scores.append(1.0 if count_syllables(ref_w) == count_syllables(hyp_w) else 0.0)
        elif ctype == "insert":
            for k in range(chunk.hyp_start_idx, chunk.hyp_end_idx):
                pos_scores.append(0.0)

    pos_comp = float(np.mean(pos_scores)) if pos_scores else 0.0
    syl_comp = float(np.mean(syl_scores)) if syl_scores else 1.0

    ref_syl = sum(count_syllables(w) for w in ref_words) if ref_words else 1
    hyp_syl = sum(count_syllables(w) for w in hyp_words) if hyp_words else 0
    syl_count_comp = max(0.0, 1.0 - abs(ref_syl - hyp_syl) / max(ref_syl, 1))

    score = (
        REWARD_ALPHA * wer_comp       +
        REWARD_BETA  * pos_comp       +
        REWARD_GAMMA * syl_comp       +
        REWARD_DELTA * syl_count_comp
    ) / (REWARD_ALPHA + REWARD_BETA + REWARD_GAMMA + REWARD_DELTA)

    return float(np.clip(score, 0.0, 1.0))

# ── Pre-compute reward weights using the existing fine-tuned model ────────────
# Score against the production model so the reward is discriminative:
# examples it already handles well get low weight, hard ones get up to 3×.
login(token=HF_TOKEN)
processor = WhisperProcessor.from_pretrained(WHISPER_BASE)

log.info(f"Loading scorer from {HF_FINETUNE_REPO}/{HF_FINETUNE_SUB}")
_scorer_base = WhisperForConditionalGeneration.from_pretrained(WHISPER_BASE)
_scorer_peft = PeftModel.from_pretrained(_scorer_base, HF_FINETUNE_REPO,
                                          subfolder=HF_FINETUNE_SUB)
scorer = _scorer_peft.merge_and_unload().cuda().eval()
forced_ids = processor.get_decoder_prompt_ids(language="en", task="transcribe")

def transcribe_audio(audio: np.ndarray, num_beams: int = BEAM_N) -> list:
    feats = processor(audio, sampling_rate=16000, return_tensors="pt").input_features.cuda()
    with torch.no_grad():
        ids = scorer.generate(feats, forced_decoder_ids=forced_ids,
                              num_beams=num_beams, num_return_sequences=num_beams)
    return [processor.decode(seq, skip_special_tokens=True) for seq in ids]

for i, item in enumerate(dataset_raw):
    hypotheses            = transcribe_audio(item["audio"])
    best_score            = max(compute_reward(h, item["text"]) for h in hypotheses)
    item["reward_weight"] = 1.0 + LOSS_SCALE * (1.0 - best_score)
    if (i + 1) % 20 == 0:
        log.info(f"  scored {i+1}/{len(dataset_raw)}")

del scorer
torch.cuda.empty_cache()

weights = [d["reward_weight"] for d in dataset_raw]
log.info(f"Reward weights — min {min(weights):.3f}  max {max(weights):.3f}  mean {np.mean(weights):.3f}")

# ── Build HuggingFace Dataset ─────────────────────────────────────────────────
def preprocess(item):
    feats  = processor(item["audio"], sampling_rate=16000).input_features[0]
    labels = processor.tokenizer(item["text"]).input_ids
    return {"input_features": feats, "labels": labels, "reward_weight": item["reward_weight"]}

hf_data  = Dataset.from_list([
    {"audio": d["audio"], "text": d["text"], "reward_weight": d["reward_weight"]}
    for d in dataset_raw
]).map(preprocess, remove_columns=["audio", "text"])

split    = hf_data.train_test_split(test_size=max(1, int(len(hf_data) * 0.1)), seed=42)
train_ds = split["train"]
eval_ds  = split["test"]
log.info(f"Train: {len(train_ds)}  Eval: {len(eval_ds)}")

# ── Model: merge existing fine-tune, then add fresh reward-shaping LoRA ───────
log.info(f"Loading training base from {HF_FINETUNE_REPO}/{HF_FINETUNE_SUB}")
_train_base = WhisperForConditionalGeneration.from_pretrained(WHISPER_BASE)
_train_peft = PeftModel.from_pretrained(_train_base, HF_FINETUNE_REPO,
                                         subfolder=HF_FINETUNE_SUB)
model = _train_peft.merge_and_unload()
model.config.forced_decoder_ids = None
model.config.suppress_tokens    = []

lora_cfg = LoraConfig(
    task_type      = TaskType.SEQ_2_SEQ_LM,
    r              = LORA_R,
    lora_alpha     = LORA_ALPHA,
    lora_dropout   = LORA_DROPOUT,
    target_modules = LORA_TARGETS,
)
model = get_peft_model(model, lora_cfg)
log.info(str(model.print_trainable_parameters()))

# ── Reward-weighted Trainer ───────────────────────────────────────────────────
class RewardWeightedTrainer(Trainer):
    def compute_loss(self, model, inputs, return_outputs=False, **kwargs):
        reward_weights = inputs.pop("reward_weight").to(model.device)
        labels         = inputs["labels"]
        # Bypass PeftModelForSeq2SeqLM.forward — it injects input_ids=None which
        # collides with Whisper's input_features path. LoRA is baked into the
        # linear layers so gradients still flow correctly.
        whisper = model.base_model.model if hasattr(model, 'base_model') else model
        outputs = whisper(**inputs)
        logits  = outputs.logits

        B, T, V = logits.shape
        loss_per_token = F.cross_entropy(
            logits.reshape(B * T, V), labels.reshape(B * T),
            ignore_index=-100, reduction="none",
        ).reshape(B, T)

        valid         = (labels != -100).float()
        loss_per_ex   = (loss_per_token * valid).sum(dim=1) / valid.sum(dim=1).clamp(min=1)
        weighted_loss = (loss_per_ex * reward_weights).mean()

        return (weighted_loss, outputs) if return_outputs else weighted_loss

class WhisperRewardCollator:
    """Stack input_features, pad labels with -100, pass reward_weight through."""
    def __call__(self, features):
        input_features = torch.tensor(
            np.array([f["input_features"] for f in features]), dtype=torch.float32
        )
        max_len = max(len(f["labels"]) for f in features)
        labels  = torch.full((len(features), max_len), -100, dtype=torch.long)
        for i, f in enumerate(features):
            ids = torch.tensor(f["labels"], dtype=torch.long)
            labels[i, :len(ids)] = ids
        reward_weight = torch.tensor(
            [f["reward_weight"] for f in features], dtype=torch.float32
        )
        return {"input_features": input_features, "labels": labels, "reward_weight": reward_weight}

collator = WhisperRewardCollator()

training_args = TrainingArguments(
    output_dir                  = OUTPUT_DIR,
    per_device_train_batch_size = BATCH_SIZE,
    per_device_eval_batch_size  = BATCH_SIZE,
    num_train_epochs            = TRAIN_EPOCHS,
    learning_rate               = LEARNING_RATE,
    warmup_steps                = 50,
    gradient_accumulation_steps = 2,
    fp16                        = True,
    eval_strategy               = "steps",
    eval_steps                  = SAVE_STEPS,
    save_strategy               = "steps",
    save_steps                  = SAVE_STEPS,
    logging_steps               = 10,
    load_best_model_at_end      = True,
    metric_for_best_model       = "eval_loss",
    greater_is_better           = False,
    push_to_hub                 = False,
    remove_unused_columns       = False,
)

trainer = RewardWeightedTrainer(
    model            = model,
    args             = training_args,
    train_dataset    = train_ds,
    eval_dataset     = eval_ds,
    data_collator    = collator,
    processing_class = processor.feature_extractor,
)

# ── Train ─────────────────────────────────────────────────────────────────────
trainer.train()

# ── Merge LoRA and push full model ───────────────────────────────────────────
# Push as a dataset repo — the org token has dataset write access but not model-create.
# Load as: WhisperForConditionalGeneration.from_pretrained(HF_PUSH_REPO)
SAVE_DIR = "/tmp/logos_reward_ft_final"
merged = model.merge_and_unload()
merged.save_pretrained(SAVE_DIR)
processor.save_pretrained(SAVE_DIR)

api = HfApi(token=HF_TOKEN)
# Repo must be pre-created on huggingface.co — org token lacks create permission.
api.upload_folder(folder_path=SAVE_DIR, repo_id=HF_PUSH_REPO, repo_type="dataset")
log.info(f"Pushed merged model to https://huggingface.co/datasets/{HF_PUSH_REPO}")