train.py

#!/usr/bin/env python3
"""LoRA SFT (and optional DPO) on the shared-fail reference mix.

Defaults match the recipe: few steps, low LR, assistant-only loss, left-truncate
so the reference actions (edits / verifies) survive when the prefix is long.

Example:
  python train.py \\
    --model /path/to/qwen3.6-35b-a3b \\
    --data datasets/mix/sft.jsonl \\
    --out runs/sft-shared-fail \\
    --max-seq-len 16384 --lr 2e-5 --epochs 1

  python train.py --mode dpo --data datasets/mix/dpo.jsonl --model ... --out runs/dpo
"""

from __future__ import annotations

import argparse
import json
from pathlib import Path

import torch
from datasets import Dataset
from peft import LoraConfig, PeftModel, TaskType
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from trl import DPOConfig, DPOTrainer, SFTConfig, SFTTrainer


DEFAULT_TARGETS = [
    "q_proj",
    "k_proj",
    "v_proj",
    "o_proj",
    "gate_proj",
    "up_proj",
    "down_proj",
]


def load_jsonl(path: Path) -> list[dict]:
    return [json.loads(line) for line in path.read_text().splitlines() if line.strip()]


def sft_dataset(path: Path) -> Dataset:
    rows = []
    for row in load_jsonl(path):
        messages = row.get("messages")
        if not messages:
            continue
        rows.append(
            {
                "messages": messages,
                "sample_id": row.get("sample_id"),
                "habits": row.get("habits") or [],
                "phase": row.get("phase"),
            }
        )
    if not rows:
        raise SystemExit(f"no SFT rows in {path}")
    return Dataset.from_list(rows)


def _completion_text(tokenizer, prompt: list[dict], completion: list[dict]) -> str:
    prompt_text = tokenizer.apply_chat_template(
        prompt, tokenize=False, add_generation_prompt=True
    )
    full = tokenizer.apply_chat_template(
        prompt + completion, tokenize=False, add_generation_prompt=False
    )
    if full.startswith(prompt_text):
        return full[len(prompt_text) :]
    return full


def dpo_dataset(path: Path, tokenizer) -> Dataset:
    rows = []
    skipped = 0
    for row in load_jsonl(path):
        prompt = row.get("prompt_messages")
        chosen = row.get("chosen_messages")
        rejected = row.get("rejected_messages")
        if not prompt or not chosen or not rejected:
            skipped += 1
            continue
        if "FULL CANDIDATE TRAJECTORY" in (rejected[0].get("content") or ""):
            skipped += 1
            continue
        prompt_text = tokenizer.apply_chat_template(
            prompt, tokenize=False, add_generation_prompt=True
        )
        rows.append(
            {
                "prompt": prompt_text,
                "chosen": _completion_text(tokenizer, prompt, chosen),
                "rejected": _completion_text(tokenizer, prompt, rejected),
                "sample_id": row.get("sample_id"),
            }
        )
    if not rows:
        raise SystemExit(f"no clean DPO rows in {path} (skipped {skipped} legacy/broken pairs)")
    return Dataset.from_list(rows)


def load_model_and_tokenizer(args):
    tokenizer = AutoTokenizer.from_pretrained(
        args.model, trust_remote_code=True, use_fast=True
    )
    if tokenizer.pad_token is None:
        tokenizer.pad_token = tokenizer.eos_token
    tokenizer.padding_side = "right"

    quant = None
    if args.qlora:
        quant = BitsAndBytesConfig(
            load_in_4bit=True,
            bnb_4bit_compute_dtype=torch.bfloat16,
            bnb_4bit_use_double_quant=True,
            bnb_4bit_quant_type="nf4",
        )
    model = AutoModelForCausalLM.from_pretrained(
        args.model,
        trust_remote_code=True,
        torch_dtype=torch.bfloat16,
        quantization_config=quant,
        device_map=args.device_map,
        attn_implementation=args.attn,
    )
    model.config.use_cache = False
    if getattr(args, "adapter", None):
        model = PeftModel.from_pretrained(model, args.adapter, is_trainable=True)
        print(f"loaded trainable adapter from {args.adapter}")
    return model, tokenizer


def lora_config(args) -> LoraConfig:
    targets = [t.strip() for t in args.lora_targets.split(",") if t.strip()]
    return LoraConfig(
        r=args.lora_r,
        lora_alpha=args.lora_alpha,
        lora_dropout=args.lora_dropout,
        bias="none",
        task_type=TaskType.CAUSAL_LM,
        target_modules=targets,
    )


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="LoRA SFT/DPO on the Albedo shared-fail mix.")
    parser.add_argument("--mode", choices=("sft", "dpo"), default="sft")
    parser.add_argument("--model", required=True, help="base model dir or HF id (Qwen3.6-35B-A3B)")
    parser.add_argument(
        "--adapter",
        help="existing LoRA dir to continue from (use this for DPO after SFT)",
    )
    parser.add_argument("--data", type=Path, required=True, help="sft.jsonl or dpo.jsonl")
    parser.add_argument("--out", type=Path, required=True, help="output dir for adapter + tokenizer")
    parser.add_argument("--max-seq-len", type=int, default=16384)
    parser.add_argument("--lr", type=float, default=2e-5)
    parser.add_argument("--epochs", type=float, default=1.0)
    parser.add_argument("--batch-size", type=int, default=1)
    parser.add_argument("--grad-accum", type=int, default=8)
    parser.add_argument("--warmup-ratio", type=float, default=0.03)
    parser.add_argument("--weight-decay", type=float, default=0.0)
    parser.add_argument("--max-grad-norm", type=float, default=1.0)
    parser.add_argument("--lora-r", type=int, default=16)
    parser.add_argument("--lora-alpha", type=int, default=32)
    parser.add_argument("--lora-dropout", type=float, default=0.05)
    parser.add_argument("--lora-targets", default=",".join(DEFAULT_TARGETS))
    parser.add_argument("--qlora", action="store_true", help="4-bit QLoRA")
    parser.add_argument("--device-map", default="auto")
    parser.add_argument("--attn", default="sdpa", help="sdpa | flash_attention_2 | eager")
    parser.add_argument("--logging-steps", type=int, default=5)
    parser.add_argument("--save-steps", type=int, default=50)
    parser.add_argument("--seed", type=int, default=7)
    parser.add_argument("--beta", type=float, default=0.1, help="DPO beta")
    return parser.parse_args()


def main() -> int:
    args = parse_args()
    args.out.mkdir(parents=True, exist_ok=True)
    model, tokenizer = load_model_and_tokenizer(args)
    peft = None if args.adapter else lora_config(args)

    common = dict(
        output_dir=str(args.out),
        num_train_epochs=args.epochs,
        per_device_train_batch_size=args.batch_size,
        gradient_accumulation_steps=args.grad_accum,
        learning_rate=args.lr,
        lr_scheduler_type="cosine",
        warmup_ratio=args.warmup_ratio,
        weight_decay=args.weight_decay,
        max_grad_norm=args.max_grad_norm,
        logging_steps=args.logging_steps,
        save_steps=args.save_steps,
        save_total_limit=2,
        bf16=True,
        gradient_checkpointing=True,
        dataloader_num_workers=2,
        report_to="none",
        seed=args.seed,
        remove_unused_columns=False,
    )

    if args.mode == "sft":
        data = sft_dataset(args.data)
        config = SFTConfig(
            **common,
            max_length=args.max_seq_len,
            packing=False,
            assistant_only_loss=True,
            padding_free=False,
        )
        trainer_kw = dict(
            model=model,
            args=config,
            train_dataset=data,
            processing_class=tokenizer,
        )
        if peft is not None:
            trainer_kw["peft_config"] = peft
        trainer = SFTTrainer(**trainer_kw)
    else:
        data = dpo_dataset(args.data, tokenizer)
        config = DPOConfig(
            **common,
            max_length=args.max_seq_len,
            max_prompt_length=min(args.max_seq_len // 2, 8192),
            beta=args.beta,
        )
        trainer_kw = dict(
            model=model,
            args=config,
            train_dataset=data,
            processing_class=tokenizer,
        )
        if peft is not None:
            trainer_kw["peft_config"] = peft
        trainer = DPOTrainer(**trainer_kw)

    trainer.train()
    trainer.save_model(str(args.out))
    tokenizer.save_pretrained(str(args.out))
    (args.out / "train-args.json").write_text(
        json.dumps({k: str(v) if isinstance(v, Path) else v for k, v in vars(args).items()}, indent=2)
        + "\n"
    )
    print(f"saved adapter to {args.out}")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())