#!/usr/bin/env python3 """LoRA SFT of Qwen3.5 (0.8B / 2B) for NL -> one ffmpeg command. Grounded in TRL 1.16.0: SFTConfig(max_length, assistant_only_loss), auto-swapped qwen3_5_nothink training template, LoRA regex targeting only the text stack. Modes: --smoke : 50 steps, no push; checks loss decrease, weight change, 5 val gens full : 3 epochs, checkpoint per epoch, per-epoch val generation, earliest epoch within 1 point of best val score is merged and pushed """ import argparse import json import os import random import re import sys import torch from datasets import Dataset, load_dataset from peft import LoraConfig, PeftModel from transformers import AutoModelForCausalLM, AutoTokenizer, TrainerCallback try: from transformers import AutoModelForImageTextToText except ImportError: # older name from transformers import AutoModelForVision2Seq as AutoModelForImageTextToText sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) import validator as V # noqa: E402 DATASET = "joemaddalone/ffmpeg-nl2cmd-clean" CSV = "hf://datasets/joemaddalone/ffmpeg-nl2cmd-clean/clean_dataset.csv" SYSTEM = "Output exactly one ffmpeg command on a single line. No markdown, no explanation." TRACKIO_SPACE = "joemaddalone/ffmpeg-nl2cmd-trackio" FNAME_MAP = { "video.mp4": "input_video.mp4", "movie.mp4": "film.mp4", "clip.mp4": "segment.mp4", "audio.wav": "sound.wav", "song.wav": "track.wav", "voice.wav": "speech.wav", "song.mp3": "track.mp3", "audio.mp3": "sound.mp3", "music.mp3": "audio_track.mp3", "output.mp4": "result.mp4", "output.gif": "result.gif", "output.mp3": "result.mp3", "output.wav": "result.wav", "output.avi": "result.avi", "output.mkv": "result.mkv", "output.webm": "result.webm", "output.mov": "result.mov", "output.m4a": "result.m4a", "output.jpg": "result.jpg", "output.png": "result.png", "output.flac": "result.flac", "output.aac": "result.aac", "output.ogg": "result.ogg", "thumbnail.jpg": "poster.jpg", "frame.jpg": "snapshot.jpg", "cover.jpg": "album_art.jpg", "image.jpg": "picture.jpg", "image.png": "picture.png", "input.jpg": "source_image.jpg", "input.png": "source_image.png", "input.mp4": "source_video.mp4", "logo.png": "branding.png", "watermark.png": "overlay_wm.png", "subtitles.srt": "captions.srt", "video.gif": "animation.gif", } def load_rows(): ds = list(load_dataset("csv", data_files=CSV)["train"]) for r in ds: r["category"] = r["category"] or "conversion" r["filter_family"] = r["filter_family"] or "plain-conversion" train = [r for r in ds if r["split"] == "train" and r["label"] in ("runs", "static-only")] val = [r for r in ds if r["split"] == "val" and r["label"] in ("runs", "static-only")] return ds, train, val def augment(train, seed=42): """One filename-swap variant per row where any mapping applies (train only).""" rng = random.Random(seed) out = [] for r in train: cmd, nl = r["ffmpeg_command"], r["natural_language"] pairs = [(o, n) for o, n in FNAME_MAP.items() if o in cmd] if pairs: # swap a random subset (>=1) of the applicable filenames k = rng.randint(1, max(1, len(pairs))) chosen = rng.sample(pairs, min(k, len(pairs))) cmd2, nl2 = cmd, nl for o, n in chosen: cmd2 = cmd2.replace(o, n) nl2 = nl2.replace(o, n) if cmd2 != cmd: out.append({"natural_language": nl2, "ffmpeg_command": cmd2}) return out def to_messages(rows): return Dataset.from_list([ {"messages": [ {"role": "system", "content": SYSTEM}, {"role": "user", "content": r["natural_language"]}, {"role": "assistant", "content": r["ffmpeg_command"]}, ]} for r in rows]) def gen_val(model, tok, rows, n): model.eval() pool = V.MediaPool("/tmp/valmedia") res = [] for r in rows[:n]: msgs = [{"role": "system", "content": SYSTEM}, {"role": "user", "content": r["natural_language"]}] text = tok.apply_chat_template(msgs, tokenize=False, add_generation_prompt=True, enable_thinking=False) ids = tok(text, return_tensors="pt").to(model.device) with torch.no_grad(): out = model.generate(**ids, do_sample=False, max_new_tokens=128, pad_token_id=tok.pad_token_id or tok.eos_token_id) pred = tok.decode(out[0][ids["input_ids"].shape[1]:], skip_special_tokens=True).split("\n")[0].strip() v = V.run_command(pred, pool) if pred else {"ok": False, "mode": "none"} res.append({"id": r["id"], "pred": pred, "valid": bool(v.get("ok"))}) return res class TrackioCallback(TrainerCallback): """Minimal callback: pushes train loss to the Trackio dashboard.""" def __init__(self, run_name, every=10): self.every = every self.enabled = False self.run_name = run_name def on_train_begin(self, args, state, control, **kw): try: from trackio import init init(project="ffmpeg-nl2cmd", space_id=TRACKIO_SPACE) self.enabled = True except Exception as e: print(f"trackio init failed: {e}", flush=True) def on_log(self, args, state, control, logs=None, **kw): if not self.enabled or logs is None: return if state.global_step % self.every and state.global_step != state.max_steps: return try: from trackio import log payload = {f"train/{k}": v for k, v in logs.items() if isinstance(v, (int, float))} log(payload, step=state.global_step) except Exception as e: print(f"trackio log failed: {e}", flush=True) def on_train_end(self, args, state, control, **kw): if self.enabled: try: from trackio import finish finish() except Exception: pass def main(): ap = argparse.ArgumentParser() ap.add_argument("--model", required=True) ap.add_argument("--hub_model_id", default=None) ap.add_argument("--smoke", action="store_true") ap.add_argument("--skip-val", action="store_true", help="train only: push per-epoch adapters, no val generation or merge") ap.add_argument("--out", default="sft_out") args = ap.parse_args() short = args.model.split("/")[-1] from trl import SFTConfig, SFTTrainer _, train_rows, val_rows = load_rows() aug = augment(train_rows) print(f"train rows: {len(train_rows)} + {len(aug)} augmented | val rows: {len(val_rows)}", flush=True) train_ds = to_messages(train_rows + aug) total_steps = 50 if args.smoke else -(-len(train_ds) // 16) * 3 warmup_steps = max(1, int(0.03 * total_steps)) print(f"total steps {total_steps}, warmup {warmup_steps}", flush=True) tok = AutoTokenizer.from_pretrained(args.model) if tok.pad_token is None: tok.pad_token = tok.eos_token peft_config = LoraConfig( r=16, lora_alpha=32, lora_dropout=0.05, bias="none", task_type="CAUSAL_LM", target_modules=r"model\.language_model\.layers\.\d+\..*" r"(q_proj|k_proj|v_proj|o_proj|gate_proj|up_proj|down_proj)$", ) sft_args = SFTConfig( output_dir=args.out, max_length=512, assistant_only_loss=True, packing=False, per_device_train_batch_size=4, gradient_accumulation_steps=4, num_train_epochs=3, max_steps=50 if args.smoke else -1, learning_rate=2e-4, lr_scheduler_type="cosine", warmup_steps=warmup_steps, bf16=True, gradient_checkpointing=True, optim="adamw_torch_fused", save_strategy="epoch" if not args.smoke else "no", save_total_limit=4, logging_steps=5, report_to=[], push_to_hub=False, eos_token="<|im_end|>", dataset_num_proc=8, seed=42, model_init_kwargs={"dtype": torch.bfloat16}, ) trainer = SFTTrainer(model=args.model, args=sft_args, train_dataset=train_ds, processing_class=tok, peft_config=peft_config) trainer.add_callback(TrackioCallback(run_name=f"sft-{short}")) trainer.train() # ---- post-training checks ---- loss_log = [l for l in trainer.state.log_history if "loss" in l] first_loss, last_loss = loss_log[0]["loss"], loss_log[-1]["loss"] print(f"loss: first {first_loss:.4f} -> last {last_loss:.4f}", flush=True) model = trainer.model lora_sums = [p.abs().sum().item() for n, p in model.named_parameters() if "lora_A" in n] weights_differ = len(lora_sums) > 0 and sum(lora_sums) > 0 print(f"lora_A params: {len(lora_sums)}, total |A|: {sum(lora_sums):.1f} -> weights_differ={weights_differ}", flush=True) V.load_options() gens = gen_val(model, tok, val_rows, 5) n_valid = sum(g["valid"] for g in gens) print("val generations:", json.dumps(gens, indent=1), flush=True) summary = {"model": args.model, "smoke": args.smoke, "first_loss": first_loss, "last_loss": last_loss, "loss_decreased": last_loss < first_loss, "weights_differ": weights_differ, "val_valid": f"{n_valid}/5", "val_generations": gens} print(json.dumps(summary, indent=1), flush=True) if args.smoke: with open(os.path.join(args.out, "smoke_summary.json"), "w") as f: json.dump(summary, f, indent=1) ok = summary["loss_decreased"] and weights_differ and n_valid >= 3 print(f"SMOKE {'PASS' if ok else 'FAIL'}", flush=True) return # ---- full: per-epoch validation, choose epoch, merge, push ---- ckpts = sorted([d for d in os.listdir(args.out) if d.startswith("checkpoint-")], key=lambda d: int(d.split("-")[-1])) print(f"checkpoints: {ckpts}", flush=True) if args.skip_val: from huggingface_hub import HfApi for ck in ckpts: HfApi().upload_folder(folder_path=os.path.join(args.out, ck), path_in_repo=f"adapter-{ck.split('-')[-1]}", repo_id=args.hub_model_id, repo_type="model") print(f"pushed adapter {ck}", flush=True) with open(os.path.join(args.out, "train_summary.json"), "w") as f: json.dump({"model": args.model, "hub_id": args.hub_model_id, "checkpoints": ckpts, "augmented_rows": len(aug), "train_rows": len(train_rows), "summary": summary}, f, indent=1) print("DONE (adapters pushed, val/merge deferred)", flush=True) return val_results = {} for ck in ckpts: # load the base with the architecture's own class so module names match # the ones the adapter was saved against (model.language_model.*) base = AutoModelForImageTextToText.from_pretrained(args.model, dtype=torch.bfloat16).cuda() peft_model = PeftModel.from_pretrained(base, os.path.join(args.out, ck)) gens = gen_val(peft_model, tok, val_rows, len(val_rows)) valid_all = sum(g["valid"] for g in gens) / len(gens) val_results[ck] = valid_all print(f"{ck}: val valid_all {valid_all:.4f}", flush=True) try: from trackio import log log({f"val/valid_all": valid_all}, step=int(ck.split("-")[-1])) except Exception: pass del peft_model, base torch.cuda.empty_cache() best = max(val_results.values()) chosen = next(ck for ck in ckpts if val_results[ck] >= best - 0.01) print(f"chosen epoch: {chosen} (earliest within 1pt of best {best:.4f})", flush=True) hub_id = args.hub_model_id base = AutoModelForImageTextToText.from_pretrained(args.model, dtype=torch.bfloat16).cuda() merged = PeftModel.from_pretrained(base, os.path.join(args.out, chosen)).merge_and_unload() merged.config.uso_metadata = None merged.push_to_hub(hub_id) tok.push_to_hub(hub_id) print(f"pushed merged model to {hub_id}", flush=True) with open(os.path.join(args.out, "train_summary.json"), "w") as f: json.dump({"model": args.model, "hub_id": hub_id, "chosen_epoch": chosen, "val_results": val_results, "augmented_rows": len(aug), "train_rows": len(train_rows), "summary": summary}, f, indent=1) try: from huggingface_hub import HfApi HfApi().upload_file(path_or_fileobj=os.path.join(args.out, "train_summary.json"), path_in_repo=f"results/train_summary_{short}.json", repo_id=DATASET, repo_type="dataset") except Exception as e: print(f"summary push failed: {e}", flush=True) print("DONE", flush=True) if __name__ == "__main__": main()