corrector_ft_job.py

# /// 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()