ffmpeg-nl2cmd-clean / scripts /make_splits.py
joemaddalone's picture
Upload scripts/make_splits.py with huggingface_hub
96b3ae3 verified
Raw History Blame Contribute Delete
9.23 kB
#!/usr/bin/env python3
"""Step 2: clean, fix, and split the audited dataset.
Input : /work/out/audit_table.csv (produced by audit.py)
Output: /work/out/clean_dataset.csv - all 1,024 unique rows with labels + splits
/work/out/report_splits.json - split stats, seen/unseen families, edit log
Policy (user-approved):
- drop exact and near duplicates (label 'dup')
- exclude 'fails' rows from training/evaluation (split left empty)
- one-token fixes, logged: merge duplicate -af flags (rows 127, 231)
- 80/10/10 train/val/test grouped by main filter/codec family
- rare families (<=2 rows) go entirely to test/val so the test set contains
families absent from train; reported separately as 'unseen'
- robustness slice: test prompts rewritten with different filenames (applied
consistently to prompt AND command) and rule-based rephrasing. Never applied
to train/val. Split tag 'test-robust'.
"""
import json
import random
import re
import shlex
from collections import Counter, defaultdict
import pandas as pd
OUT = "/work/out"
SEED = 42
rng = random.Random(SEED)
df = pd.read_csv(f"{OUT}/audit_table.csv")
df = df[df.label != "dup"].copy() # 1,024 unique rows
edits = []
# ---------------------------------------------------------------- fixes
AF_FIXES = {
127: ("-af atempo=0.8 -af aresample=44100", "-af atempo=0.8,aresample=44100"),
231: ("-af atempo=0.5 -af aresample=44100", "-af atempo=0.5,aresample=44100"),
}
for rid, (old, new) in AF_FIXES.items():
m = df.id == rid
if m.any() and old in df.loc[m, "ffmpeg_command"].iloc[0]:
df.loc[m, "ffmpeg_command"] = df.loc[m, "ffmpeg_command"].str.replace(old, new, regex=False)
edits.append({"id": int(rid), "change": f"{old!r} -> {new!r}",
"reason": "second -af overrode the first; merged into one chain"})
# ---------------------------------------------------------------- families
LAVFI = {"testsrc", "testsrc2", "sine", "color", "anullsrc", "mandelbrot", "smptebars",
"smptehdbars", "rgbtestsrc", "nullsrc", "gradients", "aevalsrc", "life", "cellauto"}
def family(cmd):
if "-f concat" in cmd:
return "concat"
for m in re.finditer(r"-v(?:f)?\s+(?:(['\"])(.*?)\1|(\S+))|-af\s+(?:(['\"])(.*?)\4|(\S+))|"
r"-filter_complex\s+(?:(['\"])(.*?)\7|(\S+))", cmd):
chain = next((g for g in m.groups() if g), "")
for part in re.split(r"[,;]", chain):
n = part.strip().split("=")[0].split("[")[0].strip()
if n and re.fullmatch(r"[a-z0-9_]+", n) and n not in LAVFI:
return n
enc = re.findall(r"-c:v\s+(\S+)|-c:a\s+(\S+)|-vcodec\s+(\S+)|-acodec\s+(\S+)", cmd)
for tup in enc:
v = next(x for x in tup if x)
if v != "copy":
return f"codec:{v}"
if any(t.split("=")[0].split(":")[0] in LAVFI for t in shlex.split(cmd)):
return "lavfi-source"
return "plain-conversion"
df["filter_family"] = df.ffmpeg_command.map(family)
# ---------------------------------------------------------------- splits
splittable = df[df.label.isin(["runs", "static-only"])].index.tolist()
by_fam = defaultdict(list)
for i in splittable:
by_fam[df.at[i, "filter_family"]].append(i)
df["split"] = ""
unseen_fams = []
for fam, idxs in sorted(by_fam.items(), key=lambda kv: -len(kv[1])):
n = len(idxs)
if n >= 10:
rng.shuffle(idxs)
n_tr = int(round(0.8 * n))
n_va = max(1, int(round(0.1 * n)))
for i in idxs[:n_tr]:
df.at[i, "split"] = "train"
for i in idxs[n_tr:n_tr + n_va]:
df.at[i, "split"] = "val"
for i in idxs[n_tr + n_va:]:
df.at[i, "split"] = "test"
elif n in (3, 4):
# tiny family: keep one example in train, rest to val/test
rng.shuffle(idxs)
df.at[idxs[0], "split"] = "train"
df.at[idxs[1], "split"] = "val" if n == 4 else "test"
if n == 4:
df.at[idxs[2], "split"] = "test"
unseen_fams.append(fam)
else: # n <= 2: a deliberate subset goes to test, absent from train;
# the rest stay in train so the long tail does not hollow it out
if rng.random() < 0.35:
for i in idxs:
df.at[i, "split"] = "test"
unseen_fams.append(fam)
else:
for i in idxs:
df.at[i, "split"] = "train"
# ---------------------------------------------------------------- robustness
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", "screenshot.png": "grab.png",
"slowmotion.mp4": "slowed.mp4", "reversed.mp4": "backwards.mp4", "cropped.mp4": "cut_video.mp4",
"resized.mp4": "scaled_video.mp4", "thumbnail.png": "poster.png", "highlight.mp4": "best_of.mp4",
"cat.png": "pet.png", "kick.wav": "drum.wav", "merged.mp4": "combined_video.mp4",
"video_with_alpha.mov": "alpha_source.mov", "rgba.mov": "alpha_source2.mov",
}
REPHRASE = [
(r"\bconvert (.+?) to ", r"change \1 into "),
(r"\bresize (.+?) to ", r"scale \1 to "),
(r"\bextract (.+?) from ", r"pull \1 out of "),
(r"\badd (.+?) to ", r"apply \1 onto "),
(r"\bcreate (.+?) from ", r"make \1 out of "),
(r"\bcreate (.+?) for ", r"make \1 for "),
(r"\bremove (.+?) from ", r"delete \1 from "),
(r"\btrim ", "cut "),
(r"\bmerge ", "join "),
(r"\bslow down ", "reduce the speed of "),
(r"\bspeed up ", "increase the speed of "),
(r"\brotate ", "turn "),
(r"\bflip ", "invert "),
(r"\bcrop ", "cut out a region from "),
(r"\bincrease ", "raise "),
(r"\bdecrease ", "lower "),
(r"\bcompress ", "shrink "),
(r"\breverse ", "play backwards "),
]
def robust_variant(row):
"""Return (prompt, command, notes) or None if nothing applies."""
prompt, cmd = row.natural_language, row.ffmpeg_command
notes = []
# filename swaps, consistently in prompt and command
for old, new in FNAME_MAP.items():
if old in cmd:
cmd = cmd.replace(old, new)
if old in prompt:
prompt = prompt.replace(old, new)
notes.append(f"file {old}->{new}")
# rephrase: apply the first matching rule
for pat, rep in REPHRASE:
if re.search(pat, prompt):
prompt = re.sub(pat, rep, prompt, count=1)
notes.append(f"rephrase {pat}")
break
if not notes:
return None
return prompt, cmd, "; ".join(notes)
robust_rows = []
for _, r in df[df.split == "test"].iterrows():
v = robust_variant(r)
if v is None:
continue
p, c, notes = v
if p == r.natural_language and c == r.ffmpeg_command:
continue
robust_rows.append({
"id": f"robust-{r.id}", "natural_language": p, "ffmpeg_command": c,
"label": r.label, "category": r.category, "filter_family": r.filter_family,
"split": "test-robust", "robustness_notes": notes, "source_id": int(r.id),
})
rob = pd.DataFrame(robust_rows)
for col in ("dup_of", "notes", "reason"):
if col not in rob.columns:
rob[col] = ""
df["robustness_notes"] = ""
df["source_id"] = ""
clean = pd.concat([df, rob], ignore_index=True)
clean.to_csv(f"{OUT}/clean_dataset.csv", index=False)
# ---------------------------------------------------------------- report
core = clean[clean.split.isin(["train", "val", "test"])]
rep = {
"unique_rows": len(df),
"excluded_fails": int((df.label == "fails").sum()),
"edits": edits,
"split_counts": core.split.value_counts().to_dict(),
"split_by_label": {f"{s}|{l}": n for (s, l), n in core.groupby(["split", "label"]).size().items()},
"families_total": len(by_fam),
"unseen_families_in_test": sorted(unseen_fams),
"unseen_family_rows": int((core.split == "test").sum() and sum(
len(by_fam[f]) for f in unseen_fams)),
"robustness_rows": len(rob),
"train_families": sorted(set(df[df.split == "train"].filter_family)),
}
with open(f"{OUT}/report_splits.json", "w") as f:
json.dump(rep, f, indent=2)
print(json.dumps({k: v for k, v in rep.items() if k != "train_families"}, indent=1))
print(f"train families ({len(rep['train_families'])}):", ", ".join(rep["train_families"][:25]), "...")
print("DONE")