ffmpeg-nl2cmd-clean / scripts /train_sft.py
joemaddalone's picture
add --skip-val: push per-epoch adapters, defer val/merge
805c920 verified
Raw History Blame Contribute Delete
13 kB
#!/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()