ffmpeg-nl2cmd-clean / scripts /eval_baselines.py
joemaddalone's picture
fix: score all rows in each batch (indentation bug)
42704f4 verified
Raw History Blame Contribute Delete
9.98 kB
#!/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()