Datasets:
File size: 4,413 Bytes
07b266f | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 | #!/usr/bin/env python
"""Write clean_data/label_same.csv for the segment_same clips that are complete.
16_build_segment_same.py can be stopped part way through, which leaves the
clip it was encoding truncated. This probes every clip on disk, keeps only the
ones whose length matches the annotation, and deletes the rest so a later
re-run of 16 re-cuts them cleanly.
Outputs
clean_data/label_same.csv video, prompt <- the two-column label
clean_data/segment_same/meta.csv annotation_id, video_uid, scene,
start_sec, end_sec, duration, split
<- what the loader joins for split/scene
Splits are assigned per ego video, not per clip, and any video already placed
by label_cross.csv keeps that placement -- otherwise the same ego video could
land in cross-train and same-val, leaking between the two tasks.
python 17_finalize_segment_same.py
"""
import argparse
import hashlib
import subprocess
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
import pandas as pd
DATA = Path(__file__).resolve().parent.parent
TOL = 0.15 # s; a complete clip matches the annotation to well under this
RATIO = (0.70, 0.15) # train, val; rest test
def probe_dur(p):
r = subprocess.run(["ffprobe", "-v", "error", "-show_entries", "format=duration",
"-of", "csv=p=0", str(p)], capture_output=True, text=True)
try:
return float(r.stdout.strip())
except ValueError:
return -1.0
def assign_split(uid, known):
"""Deterministic, stable under re-runs, and consistent with label_cross."""
if uid in known:
return known[uid]
h = int(hashlib.md5(uid.encode()).hexdigest()[:8], 16) / 0xFFFFFFFF
return "train" if h < RATIO[0] else "val" if h < sum(RATIO) else "test"
def main():
p = argparse.ArgumentParser(description=__doc__,
formatter_class=argparse.RawDescriptionHelpFormatter)
p.add_argument("--clean", type=Path, default=DATA / "clean_data")
p.add_argument("--workers", type=int, default=16)
p.add_argument("--keep-truncated", action="store_true")
a = p.parse_args()
ego_dir = a.clean / "segment_same" / "ego"
seg = pd.read_parquet(DATA / "index/segments.parquet").set_index("annotation_id")
on_disk = sorted(f.stem for f in ego_dir.glob("*.mp4"))
print(f"{len(on_disk):,} clips on disk")
d = seg.loc[on_disk].reset_index()
with ThreadPoolExecutor(a.workers) as ex:
d["real_sec"] = list(ex.map(probe_dur, [ego_dir / f"{i}.mp4" for i in d.annotation_id]))
d["complete"] = (d.real_sec - d.duration).abs() < TOL
bad = d[~d.complete]
print(f" complete {int(d.complete.sum()):,} truncated/unreadable {len(bad):,}")
for r in bad.itertuples():
print(f" {r.annotation_id}: {r.real_sec:.2f}s vs {r.duration:.2f}s expected")
if not a.keep_truncated:
(ego_dir / f"{r.annotation_id}.mp4").unlink(missing_ok=True)
d = d[d.complete].copy()
# splits: inherit from label_cross where the ego video is already placed
known = {}
lc = a.clean / "label_cross.csv"
if lc.exists():
c = pd.read_csv(lc)
known = dict(zip(c.ego_video_uid, c.split))
print(f" inheriting split for {len(known)} ego videos from label_cross.csv")
vids = sorted(d.video_uid.unique())
smap = {v: assign_split(v, known) for v in vids}
d["split"] = d.video_uid.map(smap)
lab = pd.DataFrame({"video": "segment_same/ego/" + d.annotation_id + ".mp4",
"prompt": d.narration_en.str.strip()})
lab.to_csv(a.clean / "label_same.csv", index=False)
meta = d[["annotation_id", "video_uid", "scene", "start_sec", "end_sec",
"duration", "split"]].copy()
meta.to_csv(a.clean / "segment_same" / "meta.csv", index=False)
gb = sum(f.stat().st_size for f in ego_dir.glob("*.mp4")) / 2**30
print(f"\n[write] {len(lab):,} rows -> {a.clean/'label_same.csv'} ({gb:.1f} GB)")
print(f"[write] {len(meta):,} rows -> {a.clean/'segment_same'/'meta.csv'}")
print(f" videos {d.video_uid.nunique()} scene {dict(d.scene.value_counts())}")
print(f" split {dict(meta.split.value_counts())}")
print(f" duration median {d.duration.median():.2f}s total {d.duration.sum()/3600:.1f} h")
if __name__ == "__main__":
main()
|