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