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