#!/usr/bin/env python3 """Baselines: zero-shot and 5-shot eval of untuned base models on the fixed test set. Same system prompt the students will be trained with, greedy decoding. Metrics per the project spec; results pushed to the dataset repo. Usage: python eval_baselines.py --models Qwen/Qwen3.5-0.8B Qwen/Qwen3.5-2B """ import argparse import json import os import sys import torch from datasets import load_dataset from transformers import AutoModelForCausalLM, AutoTokenizer sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) import validator as V # noqa: E402 DATASET = "joemaddalone/ffmpeg-nl2cmd-clean" SYSTEM = "Output exactly one ffmpeg command on a single line. No markdown, no explanation." FEWSHOT_IDS = None # filled after load: 5 train rows across categories def pick_fewshot(ds): """5 deterministic train examples spanning categories.""" by_cat = {} for r in ds: if r["split"] == "train" and r["label"] == "runs": by_cat.setdefault(r["category"], []).append(r) cats = ["conversion", "video filter", "audio filter", "trim", "concat"] picked = [] for c in cats: if c in by_cat: picked.append(sorted(by_cat[c], key=lambda r: r["id"])[0]) for r in sorted(ds, key=lambda x: x["id"]): if len(picked) >= 5: break if r["split"] == "train" and r["label"] == "runs" and r not in picked: picked.append(r) return picked[:5] def build_messages(nl, fewshot): msgs = [{"role": "system", "content": SYSTEM}] for ex in fewshot: msgs.append({"role": "user", "content": ex["natural_language"]}) msgs.append({"role": "assistant", "content": ex["ffmpeg_command"]}) msgs.append({"role": "user", "content": nl}) return msgs def generate_batch(model, tok, msgs_list): texts = [tok.apply_chat_template(m, tokenize=False, add_generation_prompt=True, enable_thinking=False) for m in msgs_list] tok.padding_side = "left" ids = tok(texts, return_tensors="pt", padding=True).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) outs = [] for i in range(len(texts)): gen = out[i][ids["input_ids"].shape[1]:] s = tok.decode(gen, skip_special_tokens=True) s = s.split("\n")[0].strip() if s.startswith("```"): s = s.strip("`").strip() s = s.split("\n")[0].strip() outs.append(s) return outs def generate(model, tok, msgs): 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) gen = out[0][ids["input_ids"].shape[1]:] s = tok.decode(gen, skip_special_tokens=True) # keep only the first line, strip markdown fences if the base model adds them s = s.split("\n")[0].strip() if s.startswith("```"): s = s.strip("`").strip() s = s.split("\n")[0].strip() return s def score_rows(rows, model_name, mode, pool, fewshot, model, tok, batch_size=16): results = [] for i in range(0, len(rows), batch_size): chunk = rows[i:i + batch_size] msgs_list = [build_messages(r["natural_language"], fewshot) for r in chunk] preds = generate_batch(model, tok, msgs_list) for row, pred in zip(chunk, preds): ref = row["ffmpeg_command"] val = V.run_command(pred, pool) if pred.strip() else {"mode": "none", "ok": False, "reason": "empty output"} sc = { "id": row["id"], "split": row["split"], "category": row["category"], "family": row["filter_family"], "label": row["label"], "seen": bool(row["seen"]), "nl": row["natural_language"], "ref": ref, "pred": pred, "executes": bool(val["ok"]) and val["mode"] == "run", "static_ok": bool(val["ok"]) and val["mode"] == "static", "valid": bool(val["ok"]), "validation_mode": val["mode"], "reason": val["reason"], "exact_match": V.normalize_cmd(pred) == V.normalize_cmd(ref), "token_f1": round(V.token_f1(V.normalize_cmd(ref), V.normalize_cmd(pred)), 4), "hallucinated": V.hallucinated_items(pred), "format_ok": V.format_ok(pred), } results.append(sc) if len(results) % 50 < batch_size: v = sum(r["valid"] for r in results) / len(results) print(f" [{model_name}/{mode}] {len(results)}/{len(rows)} valid-rate so far {v:.3f}", flush=True) return results def aggregate(results): n = len(results) if n == 0: return {} runs = [r for r in results if r["label"] == "runs"] static = [r for r in results if r["label"] == "static-only"] agg = { "n": n, "executes_runs": round(sum(r["executes"] for r in runs) / len(runs), 4) if runs else None, "static_valid": round(sum(r["static_ok"] for r in static) / len(static), 4) if static else None, "valid_all": round(sum(r["valid"] for r in results) / n, 4), "exact_match": round(sum(r["exact_match"] for r in results) / n, 4), "token_f1": round(sum(r["token_f1"] for r in results) / n, 4), "hallucination_rate": round(sum(1 for r in results if r["hallucinated"]) / n, 4), "format_ok": round(sum(r["format_ok"] for r in results) / n, 4), } by_cat = {} for r in results: by_cat.setdefault(r["category"], []).append(r) agg["by_category"] = { c: {"n": len(rs), "valid": round(sum(x["valid"] for x in rs) / len(rs), 4), "exact_match": round(sum(x["exact_match"] for x in rs) / len(rs), 4)} for c, rs in sorted(by_cat.items())} return agg def push_results(all_results, out_dir, suffix=""): path = os.path.join(out_dir, f"baseline_results{suffix}.json") with open(path, "w") as f: json.dump(all_results, f, indent=1) try: from huggingface_hub import HfApi HfApi().upload_file(path_or_fileobj=path, path_in_repo=f"results/baseline_results{suffix}.json", repo_id=DATASET, repo_type="dataset") print("pushed partial results", flush=True) except Exception as e: print(f"partial push failed: {e}", flush=True) def main(): ap = argparse.ArgumentParser() ap.add_argument("--models", nargs="+", default=["Qwen/Qwen3.5-0.8B", "Qwen/Qwen3.5-2B"]) ap.add_argument("--modes", nargs="+", default=["zeroshot", "shot5"], choices=["zeroshot", "shot5"]) ap.add_argument("--out", default="results") args = ap.parse_args() # explicit CSV load: the repo has no parquet export yet, and auto-discovery # of a lone CSV at the repo root is unreliable ds = list(load_dataset("csv", data_files="hf://datasets/joemaddalone/ffmpeg-nl2cmd-clean/clean_dataset.csv")["train"]) for r in ds: r["category"] = r["category"] or "conversion" r["filter_family"] = r["filter_family"] or "plain-conversion" test_rows = [r for r in ds if r["split"] in ("test", "test-robust") and r["label"] in ("runs", "static-only")] train_families = {r["filter_family"] for r in ds if r["split"] == "train"} for r in test_rows: r["seen"] = r["filter_family"] in train_families fewshot = pick_fewshot(ds) print(f"test+robust rows: {len(test_rows)} | fewshot ids: {[e['id'] for e in fewshot]}", flush=True) V.load_options() os.makedirs(args.out, exist_ok=True) all_results = {} for model_name in args.models: short = model_name.split("/")[-1] tok = AutoTokenizer.from_pretrained(model_name) model = AutoModelForCausalLM.from_pretrained(model_name, dtype=torch.bfloat16).cuda().eval() pool = V.MediaPool("/tmp/media_" + short) for mode, fs in (("zeroshot", []), ("shot5", fewshot)): if mode not in args.modes: continue print(f"=== {model_name} / {mode} on {len(test_rows)} rows ===", flush=True) res = score_rows(test_rows, short, mode, pool, fs, model, tok) # preserve raw generations before any aggregation can fail all_results[f"{short}/{mode}"] = {"rows": res} push_results(all_results, args.out, suffix="_" + short) agg = aggregate(res) seen = [r for r in res if r["seen"]] unseen = [r for r in res if not r["seen"]] agg["seen"] = aggregate(seen) agg["unseen"] = aggregate(unseen) all_results[f"{short}/{mode}"] = {"aggregate": agg, "rows": res} push_results(all_results, args.out, suffix="_" + short) print(json.dumps(agg, indent=1), flush=True) try: from trackio import init, log, finish init(project="ffmpeg-nl2cmd", space_id="joemaddalone/ffmpeg-nl2cmd-trackio", run_name=f"baseline-{short}-{mode}") for k in ("valid_all", "executes_runs", "static_valid", "exact_match", "token_f1", "hallucination_rate", "format_ok"): if agg.get(k) is not None: log({k: agg[k]}, step=0) finish() except Exception as e: print(f"trackio skipped: {e}", flush=True) del model torch.cuda.empty_cache() with open(os.path.join(args.out, "baseline_results.json"), "w") as f: json.dump(all_results, f, indent=1) print("DONE", flush=True) if __name__ == "__main__": main()