Datasets:
Download scripts/train_sft.py from joemaddalone/ffmpeg-nl2cmd-clean: direct link, hf CLI and curl.
- Browser
- Download file 13 kB
-
https://huggingface.co/datasets/joemaddalone/ffmpeg-nl2cmd-clean/resolve/main/scripts/train_sft.py
- Command line
-
hf download hf://datasets/joemaddalone/ffmpeg-nl2cmd-clean/scripts/train_sft.py
-
curl -L -o train_sft.py https://huggingface.co/datasets/joemaddalone/ffmpeg-nl2cmd-clean/resolve/main/scripts/train_sft.py
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() | |