Upload corrector_ft_job.py with huggingface_hub

corrector_ft_job.py

@@ -0,0 +1,186 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#   "torch",
+#   "transformers",
+#   "datasets",
+#   "peft",
+#   "accelerate",
+#   "bitsandbytes",
+#   "huggingface_hub",
+#   "numpy",
+# ]
+# ///
+"""
+LoRA fine-tune a small causal LM (default Qwen2.5-3B) as an ASR n-best CORRECTOR,
+on the SAP-Hypo5 dysarthric-speech dataset (xiuwenz2/SAP-Hypo5).
+
+Follows the SAP-Hypo5 / Hypo2Trans "H2T-LoRA" recipe verbatim:
+  prompt = instruction + best-hypothesis + other-hypotheses  ->  reference
+  loss on the RESPONSE ONLY (train_on_inputs=False), done here by masking the
+  prompt tokens with -100 in `labels` (plain transformers.Trainer, no TRL — its
+  SFTTrainer API drifts between versions and this job can't be cheaply re-run).
+
+NOTE the dataset's `output` is normalized (lowercase, no punctuation): this trains
+pure WORD correction, not casing/punctuation. The model is the word-arbitration
+stage; formatting stays a separate layer downstream.
+
+Runs as an HF Job (uv run --script). Config via env vars:
+  BASE_MODEL   base causal LM to LoRA-tune          (default Qwen/Qwen2.5-3B)
+  DATASET      HF dataset id                          (default xiuwenz2/SAP-Hypo5)
+  PUSH_REPO    dataset repo to upload the adapter to  (REQUIRED)
+  EPOCHS, MAX_LEN, LR, BATCH, GRAD_ACC, LORA_R       (training hparams)
+  USE_4BIT     "1" for QLoRA (bitsandbytes), else bf16 LoRA (default "0")
+  HF_TOKEN     write token (job secret)
+"""
+import os, logging
+import torch
+from datasets import load_dataset
+from transformers import (AutoTokenizer, AutoModelForCausalLM,
+                          BitsAndBytesConfig, Trainer, TrainingArguments)
+from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
+from huggingface_hub import HfApi, login
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(message)s")
+log = logging.getLogger("corrector_ft")
+
+# ── Config ──────────────────────────────────────────────────────────────────
+BASE_MODEL = os.environ.get("BASE_MODEL", "Qwen/Qwen2.5-3B")
+DATASET    = os.environ.get("DATASET", "xiuwenz2/SAP-Hypo5")
+PUSH_REPO  = os.environ["PUSH_REPO"]                      # e.g. org/qwen2.5-3b-corrector-sap-hypo5
+EPOCHS     = float(os.environ.get("EPOCHS", "2"))
+MAX_LEN    = int(os.environ.get("MAX_LEN", "512"))
+LR         = float(os.environ.get("LR", "2e-4"))
+BATCH      = int(os.environ.get("BATCH", "8"))
+GRAD_ACC   = int(os.environ.get("GRAD_ACC", "4"))
+LORA_R     = int(os.environ.get("LORA_R", "16"))
+USE_4BIT   = os.environ.get("USE_4BIT", "0") == "1"
+HF_TOKEN   = os.environ.get("HF_TOKEN")
+
+# ── SAP-Hypo5 / H2T-LoRA prompt (verbatim from templates/H2T-LoRA.json) ───────
+INSTRUCTION = ("Below is the best-hypotheses transcribed from speech recognition system. "
+    "Please try to revise it using the words which are only included into other-hypothesis, "
+    "and write the response for the true transcription.")
+
+def build_prompt(best: str, others: str) -> str:
+    return (f"{INSTRUCTION}\n\n### Best-hypothesis:\n{best}\n\n"
+            f"### Other-hypothesis:\n{others}\n\n### Response:\n")
+
+def build_others(hyps) -> str:
+    # SAP-Hypo5 inference.py build_prompts: ". ".join(others) + "."
+    return ". ".join(hyps[1:]) + "." if len(hyps) > 1 else ""
+
+
+def main():
+    if HF_TOKEN:
+        login(token=HF_TOKEN)
+
+    tok = AutoTokenizer.from_pretrained(BASE_MODEL, use_fast=True)
+    if tok.pad_token_id is None:
+        tok.pad_token = tok.eos_token
+
+    def encode(ex):
+        hyps = ex["input"]
+        prompt = build_prompt(hyps[0], build_others(hyps))
+        ref = (ex["output"] or "").strip()
+        p_ids = tok(prompt, add_special_tokens=False)["input_ids"]
+        r_ids = tok(ref, add_special_tokens=False)["input_ids"] + [tok.eos_token_id]
+        ids = (p_ids + r_ids)[:MAX_LEN]
+        # train_on_inputs=False: mask the prompt, learn only the reference tokens.
+        labels = ([-100] * len(p_ids) + r_ids)[:MAX_LEN]
+        return {"input_ids": ids, "labels": labels, "attention_mask": [1] * len(ids)}
+
+    log.info("loading %s", DATASET)
+    ds = load_dataset(DATASET)
+    cols = ds["train"].column_names
+    train = ds["train"].map(encode, remove_columns=cols)
+    val   = ds["validation"].map(encode, remove_columns=cols)
+    log.info("train=%d val=%d", len(train), len(val))
+
+    def collate(feats):
+        m = max(len(f["input_ids"]) for f in feats)
+        pad = tok.pad_token_id
+        def p(f, k, fill): return f[k] + [fill] * (m - len(f[k]))
+        return {
+            "input_ids":      torch.tensor([p(f, "input_ids", pad) for f in feats]),
+            "labels":         torch.tensor([p(f, "labels", -100) for f in feats]),
+            "attention_mask": torch.tensor([p(f, "attention_mask", 0) for f in feats]),
+        }
+
+    # ── model + LoRA ────────────────────────────��────────────────────────────
+    if USE_4BIT:
+        quant = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type="nf4",
+                                   bnb_4bit_compute_dtype=torch.bfloat16,
+                                   bnb_4bit_use_double_quant=True)
+        model = AutoModelForCausalLM.from_pretrained(
+            BASE_MODEL, quantization_config=quant,
+            torch_dtype=torch.bfloat16, device_map={"": 0})
+        model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=True)
+    else:
+        model = AutoModelForCausalLM.from_pretrained(
+            BASE_MODEL, torch_dtype=torch.bfloat16, device_map={"": 0})
+        model.gradient_checkpointing_enable(
+            gradient_checkpointing_kwargs={"use_reentrant": False})
+        # With gradient checkpointing + a frozen base, gradients must be told to flow
+        # back to the LoRA adapters (the 4-bit path gets this via prepare_model_for_kbit_training).
+        model.enable_input_require_grads()
+
+    lora = LoraConfig(
+        r=LORA_R, lora_alpha=2 * LORA_R, lora_dropout=0.05, bias="none",
+        task_type="CAUSAL_LM",
+        target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
+                        "gate_proj", "up_proj", "down_proj"])
+    model = get_peft_model(model, lora)
+    model.config.use_cache = False
+    model.print_trainable_parameters()
+
+    args = TrainingArguments(
+        output_dir="out",
+        num_train_epochs=EPOCHS,
+        per_device_train_batch_size=BATCH,
+        gradient_accumulation_steps=GRAD_ACC,
+        learning_rate=LR,
+        bf16=True,
+        warmup_ratio=0.03,
+        lr_scheduler_type="cosine",
+        logging_steps=25,
+        eval_strategy="steps",
+        eval_steps=250,
+        save_strategy="no",
+        optim="paged_adamw_8bit" if USE_4BIT else "adamw_torch",
+        report_to="none",
+    )
+    trainer = Trainer(model=model, args=args, train_dataset=train,
+                      eval_dataset=val, data_collator=collate)
+    trainer.train()
+
+    # ── sanity: generate on a few val examples so the log shows what it learned ─
+    try:
+        model.config.use_cache = True
+        model.eval()
+        raw = load_dataset(DATASET, split="validation").select(range(5))
+        for ex in raw:
+            hyps = ex["input"]
+            prompt = build_prompt(hyps[0], build_others(hyps))
+            enc = tok(prompt, return_tensors="pt").to(model.device)
+            with torch.no_grad():
+                out = model.generate(**enc, max_new_tokens=64, do_sample=False,
+                                     pad_token_id=tok.pad_token_id)
+            gen = tok.decode(out[0][enc["input_ids"].shape[1]:], skip_special_tokens=True).strip()
+            log.info("BEST : %s", hyps[0])
+            log.info("PRED : %s", gen.splitlines()[0] if gen else "")
+            log.info("REF  : %s\n", ex["output"])
+    except Exception as e:
+        log.warning("sanity generation skipped: %s", e)
+
+    # ── save adapter + push to a DATASET repo (org token can't create model repos) ─
+    model.save_pretrained("adapter")
+    tok.save_pretrained("adapter")
+    api = HfApi(token=HF_TOKEN)
+    api.create_repo(PUSH_REPO, repo_type="dataset", exist_ok=True)
+    api.upload_folder(folder_path="adapter", repo_id=PUSH_REPO, repo_type="dataset")
+    log.info("pushed adapter -> https://huggingface.co/datasets/%s", PUSH_REPO)
+
+
+if __name__ == "__main__":
+    main()