Upload logos_reward_ft_job.py with huggingface_hub

logos_reward_ft_job.py

@@ -19,13 +19,25 @@
 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      — repo to push the trained adapter to
-  SUPABASE_URL      — Supabase project URL
-  SUPABASE_KEY      — Supabase anon/publishable key
-  REFRESH_TOKEN     — Supabase session refresh token
-  USER_ID           — Supabase user UUID
+  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
@@ -45,8 +57,8 @@ from transformers import (
     Trainer,
     TrainingArguments,
 )
-from peft import LoraConfig, get_peft_model, TaskType
-from huggingface_hub import login
+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__)
@@ -56,35 +68,38 @@ 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_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
-
-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 loss multiplier for worst examples
-
-BEAM_N         = 5
-TRAIN_EPOCHS   = 5
-BATCH_SIZE     = 8
-LEARNING_RATE  = 1e-4
-SAVE_STEPS     = 50
-OUTPUT_DIR     = "/tmp/logos_reward_ft"
+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:
-    # Service role key is a long-lived JWT — use directly, bypasses RLS.
     ACCESS_TOKEN = SERVICE_ROLE_KEY
     SUPABASE_KEY = SERVICE_ROLE_KEY
 else:
@@ -220,17 +235,24 @@ def compute_reward(hypothesis: str, ground_truth: str) -> float:
 
     return float(np.clip(score, 0.0, 1.0))
 
-# ── Pre-compute reward weights using base model ───────────────────────────────
-processor  = WhisperProcessor.from_pretrained(WHISPER_BASE)
-base_model = WhisperForConditionalGeneration.from_pretrained(WHISPER_BASE).cuda()
-base_model.eval()
+# ── 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 = base_model.generate(feats, forced_decoder_ids=forced_ids,
-                                  num_beams=num_beams, num_return_sequences=num_beams)
+        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):
@@ -240,7 +262,7 @@ for i, item in enumerate(dataset_raw):
     if (i + 1) % 20 == 0:
         log.info(f"  scored {i+1}/{len(dataset_raw)}")
 
-del base_model
+del scorer
 torch.cuda.empty_cache()
 
 weights = [d["reward_weight"] for d in dataset_raw]
@@ -262,17 +284,22 @@ train_ds = split["train"]
 eval_ds  = split["test"]
 log.info(f"Train: {len(train_ds)}  Eval: {len(eval_ds)}")
 
-# ── LoRA model ────────────────────────────────────────────────────────────────
+# ── 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 = ["q_proj", "v_proj"],
+    target_modules = LORA_TARGETS,
 )
-model = WhisperForConditionalGeneration.from_pretrained(WHISPER_BASE)
-model.config.forced_decoder_ids = None
-model.config.suppress_tokens    = []
 model = get_peft_model(model, lora_cfg)
 log.info(str(model.print_trainable_parameters()))
 
@@ -281,12 +308,12 @@ 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 (which injects input_ids=None and
-        # causes a duplicate-kwarg collision with Whisper's input_features path).
-        # LoRA patches are baked into the linear layers so gradients still flow.
+        # 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
+        logits  = outputs.logits
 
         B, T, V = logits.shape
         loss_per_token = F.cross_entropy(
@@ -307,7 +334,7 @@ class WhisperRewardCollator:
             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)
+        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
@@ -340,19 +367,26 @@ training_args = TrainingArguments(
 )
 
 trainer = RewardWeightedTrainer(
-    model         = model,
-    args          = training_args,
-    train_dataset = train_ds,
-    eval_dataset  = eval_ds,
-    data_collator = collator,
+    model            = model,
+    args             = training_args,
+    train_dataset    = train_ds,
+    eval_dataset     = eval_ds,
+    data_collator    = collator,
     processing_class = processor.feature_extractor,
 )
 
 # ── Train ───────────────────���─────────────────────────────────────────────────
 trainer.train()
 
-# ── Push to Hub ───────────────────────────────────────────────────────────────
-login(token=HF_TOKEN)
-model.push_to_hub(HF_PUSH_REPO)
-processor.push_to_hub(HF_PUSH_REPO)
-log.info(f"Pushed to https://huggingface.co/{HF_PUSH_REPO}")
+# ── 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)
+api.create_repo(HF_PUSH_REPO, repo_type="dataset", private=True, exist_ok=True)
+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}")