| |
| """LoRA fine-tune of Qwen 3.5 on Viperclaw examples (see vc_sft.py), plain transformers + peft. |
| |
| Only the agent's turns in each example are trained on. The language-model head is applied to those positions only, |
| so long conversations fit in memory. Adapters are saved as training goes and the run resumes from the newest one. |
| |
| usage: train_lora.py --examples ex.jsonl --model Qwen/Qwen3.5-9B --out DIR [--epochs 2] [--max-steps 0] [--lr 1e-4] |
| [--rank 32] [--accum 8] [--max-tokens 16384] [--save-every 25] [--merge-to DIR] [--limit 0] |
| """ |
| import argparse |
| import glob |
| import json |
| import math |
| import os |
| import random |
| import re |
| import shutil |
| import sys |
| import time |
|
|
| import torch |
|
|
| sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) |
| from vc_sft import render |
|
|
| p = argparse.ArgumentParser() |
| p.add_argument("--examples", required=True) |
| p.add_argument("--model", required=True) |
| p.add_argument("--out", required=True) |
| p.add_argument("--epochs", type=float, default=2.0) |
| p.add_argument("--max-steps", type=int, default=0) |
| p.add_argument("--lr", type=float, default=1e-4) |
| p.add_argument("--rank", type=int, default=32) |
| p.add_argument("--accum", type=int, default=8) |
| p.add_argument("--max-tokens", type=int, default=16384) |
| p.add_argument("--save-every", type=int, default=25) |
| p.add_argument("--merge-to", default="") |
| p.add_argument("--limit", type=int, default=0) |
| p.add_argument("--seed", type=int, default=3407) |
| a = p.parse_args() |
|
|
| from peft import LoraConfig, PeftModel, get_peft_model |
| from transformers import AutoModelForImageTextToText, AutoTokenizer |
|
|
| cuda = torch.cuda.is_available() |
| dev = "cuda" if cuda else "cpu" |
| dtype = torch.bfloat16 if cuda else torch.float32 |
| os.makedirs(a.out, exist_ok=True) |
| tok = AutoTokenizer.from_pretrained(a.model) |
|
|
| |
| rows = [json.loads(line) for line in open(a.examples)] |
| random.Random(a.seed).shuffle(rows) |
| if a.limit: |
| rows = rows[:a.limit] |
| data, too_long = [], 0 |
| for e in rows: |
| r = render(e, tok, a.max_tokens) |
| if r is None: |
| too_long += 1 |
| continue |
| data.append((torch.tensor(r["input_ids"]), torch.tensor(r["labels"]))) |
| total_tokens = sum(len(x) for x, _ in data) |
| steps_per_epoch = math.ceil(len(data) / a.accum) |
| total_steps = a.max_steps or math.ceil(steps_per_epoch * a.epochs) |
| print("DATA: %d examples (%d too long) | %.1fM tokens per epoch | %d trained-on tokens per example on average | %d optimizer steps planned" % ( |
| len(data), too_long, total_tokens / 1e6, sum(int((y != -100).sum()) for _, y in data) / max(1, len(data)), total_steps), flush=True) |
| if not data: |
| raise SystemExit("TRAIN FAILED: no usable examples") |
|
|
| |
| t0 = time.time() |
| model = AutoModelForImageTextToText.from_pretrained(a.model, dtype=dtype) |
| model.to(dev) |
| targets = r".*language_model.*\.(q_proj|k_proj|v_proj|o_proj|in_proj_qkv|in_proj_z|out_proj|gate_proj|up_proj|down_proj)" |
| done = sorted(glob.glob(os.path.join(a.out, "checkpoint-*")), key=lambda d: int(re.search(r"(\d+)$", d).group(1))) |
| done = [d for d in done if os.path.isfile(os.path.join(d, "adapter_model.safetensors")) and os.path.isfile(os.path.join(d, "state.json"))] |
| start_step = 0 |
| if done: |
| model = PeftModel.from_pretrained(model, done[-1], is_trainable=True) |
| start_step = json.load(open(os.path.join(done[-1], "state.json")))["step"] |
| print("RESUMING from", done[-1], "at step", start_step, flush=True) |
| else: |
| model = get_peft_model(model, LoraConfig(r=a.rank, lora_alpha=a.rank, lora_dropout=0.0, bias="none", target_modules=targets)) |
| core = model.get_base_model() |
| core.gradient_checkpointing_enable() |
| core.enable_input_require_grads() |
| params = [q for q in model.parameters() if q.requires_grad] |
| print("MODEL: loaded in %ds on %s | trainable %.1fM of %.0fM parameters" % ( |
| time.time() - t0, dev, sum(q.numel() for q in params) / 1e6, sum(q.numel() for q in model.parameters()) / 1e6), flush=True) |
| opt = torch.optim.AdamW(params, lr=a.lr, weight_decay=0.01) |
| warmup = max(1, min(10, total_steps // 10)) |
|
|
|
|
| def lr_at(step): |
| if step < warmup: |
| return a.lr * (step + 1) / warmup |
| return a.lr * 0.5 * (1 + math.cos(math.pi * (step - warmup) / max(1, total_steps - warmup))) |
|
|
|
|
| def loss_on(ids, labels): |
| """Cross-entropy on the labelled positions only: the vocabulary head never sees the rest of the sequence.""" |
| ids, labels = ids.to(dev), labels.to(dev) |
| hidden = core.model(input_ids=ids[None]).last_hidden_state[0] |
| pos = (labels[1:] != -100).nonzero().squeeze(-1) |
| logits = core.lm_head(hidden[pos]).float() |
| return torch.nn.functional.cross_entropy(logits, labels[1:][pos]) |
|
|
|
|
| def save(step, name=None): |
| d = os.path.join(a.out, name or "checkpoint-%d" % step) |
| tmp = d + ".tmp" |
| shutil.rmtree(tmp, ignore_errors=True) |
| model.save_pretrained(tmp) |
| json.dump({"step": step, "examples": len(data), "accum": a.accum}, open(os.path.join(tmp, "state.json"), "w")) |
| shutil.rmtree(d, ignore_errors=True) |
| os.replace(tmp, d) |
| for old in sorted(glob.glob(os.path.join(a.out, "checkpoint-*")), key=lambda x: int(re.search(r"(\d+)$", x).group(1)))[:-2]: |
| shutil.rmtree(old, ignore_errors=True) |
|
|
|
|
| |
| model.train() |
| order = [] |
| while len(order) < total_steps * a.accum: |
| epoch = list(range(len(data))) |
| random.Random(a.seed + len(order)).shuffle(epoch) |
| order += epoch |
| t_start, seen_tokens, running = time.time(), 0, [] |
| for step in range(start_step, total_steps): |
| for g in opt.param_groups: |
| g["lr"] = lr_at(step) |
| step_loss = 0.0 |
| for k in range(a.accum): |
| ids, labels = data[order[step * a.accum + k]] |
| with torch.autocast(dev, dtype=torch.bfloat16, enabled=cuda): |
| loss = loss_on(ids, labels) / a.accum |
| loss.backward() |
| step_loss += loss.item() |
| seen_tokens += len(ids) |
| torch.nn.utils.clip_grad_norm_(params, 1.0) |
| opt.step() |
| opt.zero_grad(set_to_none=True) |
| running = (running + [step_loss])[-10:] |
| elapsed = time.time() - t_start |
| per_step = elapsed / (step - start_step + 1) |
| if step < start_step + 3 or (step + 1) % 5 == 0 or step + 1 == total_steps: |
| mem = " | GPU peak %.1f GB" % (torch.cuda.max_memory_allocated() / 2**30) if cuda else "" |
| print("step %d/%d | loss %.4f (last 10: %.4f) | %.0f tokens/s | %.0fs per step | about %d min left%s" % ( |
| step + 1, total_steps, step_loss, sum(running) / len(running), seen_tokens / elapsed, per_step, |
| per_step * (total_steps - step - 1) / 60, mem), flush=True) |
| if (step + 1) % a.save_every == 0 and step + 1 < total_steps: |
| save(step + 1) |
| save(total_steps, "final") |
| print("ADAPTER SAVED:", os.path.join(a.out, "final"), flush=True) |
|
|
| |
| model.eval() |
| e = rows[0] |
| prompt = tok.apply_chat_template(e["messages"][:e["chain_start"]], tools=e["tools"], tokenize=False, add_generation_prompt=True) |
| with torch.no_grad(), torch.autocast(dev, dtype=torch.bfloat16, enabled=cuda): |
| enc = tok(prompt, return_tensors="pt", add_special_tokens=False).to(dev) |
| out = model.generate(**enc, max_new_tokens=160 if cuda else 24, do_sample=False) |
| print("SAMPLE ANSWER after training:\n" + tok.decode(out[0][enc["input_ids"].shape[1]:]), flush=True) |
| if a.merge_to: |
| merged = model.merge_and_unload() |
| merged.save_pretrained(a.merge_to, safe_serialization=True) |
| tok.save_pretrained(a.merge_to) |
| src = a.model if os.path.isdir(a.model) else None |
| if src is None: |
| from huggingface_hub import snapshot_download |
| src = snapshot_download(a.model, allow_patterns=["*.json", "*.jinja", "*.txt"]) |
| for f in os.listdir(src): |
| if f.endswith((".json", ".jinja", ".txt")) and not os.path.exists(os.path.join(a.merge_to, f)): |
| shutil.copy(os.path.join(src, f), os.path.join(a.merge_to, f)) |
| print("MERGED MODEL SAVED:", a.merge_to, flush=True) |
| print("TRAIN DONE", flush=True) |
|
|
