Upload folder using huggingface_hub

scripts/build_index.py

@@ -0,0 +1,43 @@
+import json, os, sys, time, requests
+from concurrent.futures import ThreadPoolExecutor, as_completed
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from hfzip import open_part
+
+OUT = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "meta", "part_index.jsonl")
+
+def index_part(i):
+    s = requests.Session()
+    for attempt in range(4):
+        try:
+            z, rf = open_part(i, s)
+            return i, [(n, z.getinfo(n).compress_size)
+                       for n in z.namelist() if n.endswith(".mp4")], rf.bytes_fetched
+        except Exception as e:
+            if attempt == 3:
+                return i, None, 0
+            time.sleep(3 * (attempt + 1))
+
+# resume: skip parts already fully written
+done = set()
+if os.path.exists(OUT):
+    with open(OUT) as f:
+        for line in f:
+            try: done.add(json.loads(line)["part"])
+            except Exception: pass
+todo = [i for i in range(186) if i not in done]
+print(f"already indexed parts: {len(done)}, todo: {len(todo)}", flush=True)
+
+fails = []
+with open(OUT, "a") as out, ThreadPoolExecutor(max_workers=10) as ex:
+    futs = [ex.submit(index_part, i) for i in todo]
+    for fut in as_completed(futs):
+        i, members, nb = fut.result()
+        if members is None:
+            print(f"[FAIL] part{i}", flush=True); fails.append(i); continue
+        for m, csz in members:
+            out.write(json.dumps({"clip": m.split("/")[-1], "part": i,
+                                  "member": m, "bytes": csz}) + "\n")
+        out.flush()
+        print(f"part{i}: {len(members)} clips ({nb/1e6:.1f} MB read)", flush=True)
+print("FAILED_PARTS:", fails, flush=True)
+print("INDEX_DONE", flush=True)

scripts/extract_frames.py

@@ -0,0 +1,107 @@
+import argparse, csv, hashlib, json, os, subprocess, sys, time
+from concurrent.futures import ProcessPoolExecutor, as_completed
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+csv.field_size_limit(10**9)
+
+ap = argparse.ArgumentParser()
+ap.add_argument("--manifest", default=os.path.join(ROOT, "meta", "manifest.csv"))
+ap.add_argument("--videos",   default=os.path.join(ROOT, "videos"))
+ap.add_argument("--frames",   default=os.path.join(ROOT, "frames"))
+ap.add_argument("--out",      default=os.path.join(ROOT, "sequences.jsonl"))
+ap.add_argument("--n-frames", type=int,   default=10)
+ap.add_argument("--step",     type=float, default=0.5)
+ap.add_argument("--width",    type=int,   default=768)
+ap.add_argument("--quality",  type=int,   default=3)
+ap.add_argument("--workers",  type=int,   default=max(1, os.cpu_count() - 8))
+ap.add_argument("--limit",    type=int,   default=None)
+A = ap.parse_args()
+
+N, STEP, W, Q = A.n_frames, A.step, A.width, A.quality
+WINDOW_SEC = N * STEP          # start-to-start distance between windows (5.0 s)
+
+def shard(seq_id):
+    return hashlib.md5(seq_id.encode()).hexdigest()[:2]   # 256 buckets
+
+def rel_dir(seq_id):
+    return os.path.join("frames", shard(seq_id), seq_id)
+
+def extract_window(video_path, out_abs, start):
+    os.makedirs(out_abs, exist_ok=True)
+    have = sorted(f for f in os.listdir(out_abs) if f.endswith(".jpg"))
+    if len(have) >= N:
+        return "skip"
+    for f in have:                                   # partial -> redo cleanly
+        os.remove(os.path.join(out_abs, f))
+    subprocess.run(
+        ["ffmpeg", "-v", "error", "-ss", str(start), "-i", video_path,
+         # eof_action=pass: without it the fps filter drops the final frame on clips
+         # whose duration only just covers the window (the N*STEP boundary cases).
+         "-vf", f"fps={1/STEP}:eof_action=pass,scale={W}:-2:flags=lanczos",
+         "-frames:v", str(N), "-q:v", str(Q),
+         "-start_number", "0",                      # ffmpeg defaults to 1 -> would break f00.jpg paths
+         os.path.join(out_abs, "f%02d.jpg"), "-y"],
+        check=True, stdin=subprocess.DEVNULL,
+        stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
+    n = len([f for f in os.listdir(out_abs) if f.endswith(".jpg")])
+    return "ok" if n == N else f"short:{n}"
+
+def job(row):
+    vp = os.path.join(A.videos, row["video"])
+    if not os.path.exists(vp):
+        return []
+    stem, out = row["video"][:-4], []
+    for w in range(int(row["windows"])):
+        start  = w * WINDOW_SEC
+        seq_id = f"{stem}__w{w}"
+        rd     = rel_dir(seq_id)
+        od     = os.path.join(ROOT, rd)
+        try:
+            st = extract_window(vp, od, start)
+        except subprocess.CalledProcessError:
+            continue
+        except Exception:
+            continue
+        if st.startswith("short"):
+            try:
+                for f in os.listdir(od): os.remove(os.path.join(od, f))
+                os.rmdir(od)
+            except Exception: pass
+            continue
+        out.append({
+            "id": seq_id,
+            "video": row["video"],
+            "frames":     [f"{rd}/f{i:02d}.jpg" for i in range(N)],
+            "timestamps": [round(start + i * STEP, 2) for i in range(N)],
+            "step_sec": STEP,
+            "n_frames": N,
+            "video_caption": row["caption"],
+            "meta": {k: row[k] for k in ("seconds", "fps", "motion",
+                                         "aesthetic", "camera", "hd")},
+        })
+    return out
+
+rows = list(csv.DictReader(open(A.manifest, newline="")))
+rows = [r for r in rows if os.path.exists(os.path.join(A.videos, r["video"]))]
+if A.limit:
+    rows = rows[:A.limit]
+print(f"clips on disk: {len(rows):,}  workers: {A.workers}  -> {A.out}", flush=True)
+
+t0, n, done = time.time(), 0, 0
+with open(A.out, "w") as f, ProcessPoolExecutor(A.workers) as ex:
+    futs = [ex.submit(job, r) for r in rows]
+    for fut in as_completed(futs):
+        done += 1
+        try:
+            recs = fut.result()
+        except Exception as e:
+            print(f"  [ERR] {e}", flush=True); continue
+        for rec in recs:
+            f.write(json.dumps(rec, ensure_ascii=False) + "\n"); n += 1
+        if done % 500 == 0:
+            el = time.time() - t0
+            print(f"[{time.strftime('%H:%M:%S')}] clips {done:,}/{len(rows):,}  "
+                  f"seqs {n:,}  {done/el:.1f} clip/s  "
+                  f"ETA {(len(rows)-done)/(done/el)/60:.1f} min", flush=True)
+        f.flush()
+print(f"DONE  {n:,} sequences -> {n * (N - 1):,} adjacent frame pairs", flush=True)

scripts/fetch_clips.py

@@ -0,0 +1,142 @@
+import argparse, collections, csv, json, os, sys, threading, time
+import requests
+from concurrent.futures import ThreadPoolExecutor, as_completed
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from hfzip import open_part, make_session, read_member
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+csv.field_size_limit(10**9)
+
+ap = argparse.ArgumentParser()
+ap.add_argument("--manifest", default=os.path.join(ROOT, "meta", "manifest.csv"))
+ap.add_argument("--budget-gb", type=float, default=None)
+ap.add_argument("--out", default=os.path.join(ROOT, "videos"))
+ap.add_argument("--workers", type=int, default=16)
+ap.add_argument("--chunk", type=int, default=150, help="clips per worker task (allows >1 thread per zip part)")
+ap.add_argument("--limit", type=int, default=None, help="benchmark: only first N clips")
+ap.add_argument("--retries", type=int, default=4)
+args = ap.parse_args()
+
+os.makedirs(args.out, exist_ok=True)
+
+jobs = []
+with open(args.manifest, newline="") as f:
+    for r in csv.DictReader(f):
+        if args.budget_gb and float(r["cum_gb"]) > args.budget_gb:
+            break
+        jobs.append({"video": r["video"], "member": r["member"],
+                     "part": int(r["part"]), "bytes": int(r["bytes"])})
+if args.limit:
+    jobs = jobs[:args.limit]
+
+total_jobs = len(jobs)
+total_bytes = sum(j["bytes"] for j in jobs)
+jobs = [j for j in jobs if not os.path.exists(os.path.join(args.out, j["video"]))]
+print(f"manifest jobs: {total_jobs:,} ({total_bytes/1e9:.1f} GB) | todo: {len(jobs):,} "
+      f"({sum(j['bytes'] for j in jobs)/1e9:.1f} GB) | already on disk: {total_jobs-len(jobs):,}", flush=True)
+
+by_part = collections.defaultdict(list)
+for j in jobs:
+    by_part[j["part"]].append(j)
+
+# split each part's jobs into chunks -> several threads may work the same part
+tasks = []
+for p, js in sorted(by_part.items()):
+    for k in range(0, len(js), args.chunk):
+        tasks.append((p, js[k:k+args.chunk]))
+tasks.sort(key=lambda t: -len(t[1]))
+print(f"parts: {len(by_part)} | tasks: {len(tasks)} | workers: {args.workers}", flush=True)
+
+LOCK = threading.Lock()
+THROTTLE_UNTIL = [0.0]
+
+def note_throttle(e, secs=20):
+    """Global brake: when HF starts 429-ing, every thread pauses."""
+    if "429" in str(e) or "Too Many Requests" in str(e):
+        with LOCK:
+            THROTTLE_UNTIL[0] = max(THROTTLE_UNTIL[0], time.time() + secs)
+
+def wait_throttle():
+    while True:
+        with LOCK:
+            t = THROTTLE_UNTIL[0]
+        d = t - time.time()
+        if d <= 0:
+            return
+        time.sleep(min(d, 5))
+STAT = dict(got=0, failed=0, nbytes=0, t0=time.time())
+STOP = threading.Event()
+
+def bump(got=0, failed=0, nbytes=0):
+    with LOCK:
+        STAT["got"] += got; STAT["failed"] += failed; STAT["nbytes"] += nbytes
+
+def reporter():
+    last = 0
+    while not STOP.wait(30):
+        with LOCK:
+            g, fl, nb, t0 = STAT["got"], STAT["failed"], STAT["nbytes"], STAT["t0"]
+        el = time.time() - t0
+        inst = (nb - last) / 30 / 1e6
+        last = nb
+        eta = (len(jobs) - g) / (g / el) / 3600 if g else float("nan")
+        print(f"[{time.strftime('%H:%M:%S')}] {g:,}/{len(jobs):,} clips  {nb/1e9:.1f} GB  "
+              f"avg {nb/el/1e6:.0f} MB/s  now {inst:.0f} MB/s  fail {fl}  ETA {eta:.1f} h", flush=True)
+
+def fetch_task(part, todo):
+    s = make_session()
+    z = rf = None
+    for attempt in range(args.retries):
+        try:
+            z, rf = open_part(part, s); break
+        except Exception as e:
+            if attempt == args.retries - 1:
+                bump(failed=len(todo))
+                return part, 0, len(todo), f"open_part failed: {e}"
+            time.sleep(3 * (attempt + 1))
+    got = failed = 0
+    for j in todo:
+        wait_throttle()
+        dst = os.path.join(args.out, j["video"])
+        if os.path.exists(dst):
+            continue
+        tmp = dst + f".part{threading.get_ident()}"
+        for attempt in range(args.retries):
+            try:
+                data = read_member(z, rf, j["member"])
+                with open(tmp, "wb") as fh:
+                    fh.write(data)
+                os.replace(tmp, dst)
+                got += 1
+                bump(got=1, nbytes=len(data))
+                break
+            except Exception as e:
+                note_throttle(e)
+                try: os.path.exists(tmp) and os.remove(tmp)
+                except Exception: pass
+                if attempt == args.retries - 1:
+                    failed += 1; bump(failed=1)
+                    print(f"  [FAIL] {j['video']} part{part}: {e}", flush=True)
+                else:
+                    wait_throttle()
+                    time.sleep(3 * (attempt + 1))
+                    try:
+                        z, rf = open_part(part, s)   # re-open on error
+                    except Exception:
+                        pass
+    return part, got, failed, "ok"
+
+th = threading.Thread(target=reporter, daemon=True); th.start()
+with ThreadPoolExecutor(max_workers=args.workers) as ex:
+    futs = [ex.submit(fetch_task, p, js) for p, js in tasks]
+    done = 0
+    for fut in as_completed(futs):
+        done += 1
+        try:
+            fut.result()
+        except Exception as e:
+            print(f"  [TASK ERR] {e}", flush=True)
+STOP.set()
+el = time.time() - STAT["t0"]
+print(f"DONE  got={STAT['got']:,}  failed={STAT['failed']:,}  "
+      f"{STAT['nbytes']/1e9:.1f} GB in {el/60:.1f} min ({STAT['nbytes']/el/1e6:.0f} MB/s)", flush=True)

scripts/hfzip.py

@@ -0,0 +1,94 @@
+import io, struct, zipfile, zlib, requests
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+HF = "https://huggingface.co/datasets/nkp37/OpenVid-1M/resolve/main"
+
+def make_session(total=10, backoff=1.5):
+    """Session that transparently retries 429/5xx with exponential backoff,
+    honouring Retry-After when HF sends it."""
+    s = requests.Session()
+    r = Retry(total=total, connect=total, read=total, status=total,
+              backoff_factor=backoff,
+              status_forcelist=[429, 500, 502, 503, 504],
+              allowed_methods=["GET", "HEAD"],
+              respect_retry_after_header=True,
+              raise_on_status=False)
+    ad = HTTPAdapter(max_retries=r, pool_connections=64, pool_maxsize=64)
+    s.mount("https://", ad); s.mount("http://", ad)
+    return s
+SPLIT_PARTS = {73,76,78,83,88,89,92,95,96,102,103,111,118,183,184,185}
+
+def part_urls(i):
+    if i in SPLIT_PARTS:
+        return [f"{HF}/OpenVid_part{i}_partaa", f"{HF}/OpenVid_part{i}_partab"]
+    return [f"{HF}/OpenVid_part{i}.zip"]
+
+class RangeFile(io.RawIOBase):
+    """Several URLs concatenated into one seekable read-only file."""
+    def __init__(self, urls, session=None, timeout=60):
+        self.urls, self.s, self.timeout = list(urls), session or make_session(), timeout
+        self.sizes = [int(self.s.head(u, allow_redirects=True, timeout=timeout)
+                          .headers["Content-Length"]) for u in self.urls]
+        self.offs, acc = [], 0
+        for sz in self.sizes:
+            self.offs.append(acc); acc += sz
+        self.size, self.pos, self.bytes_fetched = acc, 0, 0
+
+    def seek(self, off, whence=0):
+        self.pos = off if whence == 0 else (self.pos + off if whence == 1 else self.size + off)
+        return self.pos
+    def tell(self):     return self.pos
+    def seekable(self): return True
+    def readable(self): return True
+
+    def read(self, n=-1):
+        n = self.size - self.pos if (n is None or n < 0) else min(n, self.size - self.pos)
+        if n <= 0: return b""
+        out = bytearray()
+        while n > 0:
+            k = max(j for j, o in enumerate(self.offs) if o <= self.pos)
+            local = self.pos - self.offs[k]
+            take = min(n, self.sizes[k] - local)
+            r = self.s.get(self.urls[k], headers={"Range": f"bytes={local}-{local+take-1}"},
+                           allow_redirects=True, timeout=self.timeout)
+            r.raise_for_status()
+            out += r.content
+            self.pos += len(r.content); n -= len(r.content); self.bytes_fetched += len(r.content)
+            if len(r.content) < take: break
+        return bytes(out)
+
+def open_part(i, session=None):
+    rf = RangeFile(part_urls(i), session or make_session())
+    return zipfile.ZipFile(rf), rf
+
+
+def read_member(z, rf, member):
+    """Read one zip member with a SINGLE HTTP Range request.
+
+    zipfile.ZipFile.read() costs 3-4 round trips per member (local header, file
+    name, extra field, payload). Over HTTP that is latency- and request-rate-
+    bound, and HF throttles on request count, so we fetch
+    [local header .. end of payload] in one go and parse the 30-byte header
+    locally. Members are deflated; zlib with a raw (-15) window undoes that.
+    """
+    zi = z.getinfo(member)
+    if zi.compress_type not in (zipfile.ZIP_STORED, zipfile.ZIP_DEFLATED):
+        return z.read(member)                       # exotic method: stay correct
+    SLACK = 30 + 1024                               # header + filename + extra
+    rf.seek(zi.header_offset)
+    blob = rf.read(SLACK + zi.compress_size)
+    if len(blob) < 30 or blob[:4] != b"PK\x03\x04":
+        raise IOError(f"bad local header for {member}")
+    fnl, exl = struct.unpack("<HH", blob[26:30])
+    off = 30 + fnl + exl
+    raw = blob[off:off + zi.compress_size]
+    if len(raw) < zi.compress_size:                 # filename+extra > SLACK
+        rf.seek(zi.header_offset + off + len(raw))
+        raw += rf.read(zi.compress_size - len(raw))
+    if len(raw) != zi.compress_size:
+        raise IOError(f"short read {member}: {len(raw)}/{zi.compress_size}")
+    data = raw if zi.compress_type == zipfile.ZIP_STORED else zlib.decompress(raw, -15)
+    if len(data) != zi.file_size:
+        raise IOError(f"bad size {member}: {len(data)}/{zi.file_size}")
+    return data

scripts/motion_cut.py

@@ -0,0 +1,48 @@
+"""Print the motion-score percentile ladder of the candidate pool.
+
+The pool is everything select_clips.py would keep *except* the motion cut, so the
+number printed here is exactly the value to pass as --motion-lo.
+"""
+import argparse, csv, json, os, re, bisect
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+META = os.path.join(ROOT, "meta")
+csv.field_size_limit(10**9)
+TALKING = re.compile(r"\b(talk|talks|talking|interview|interviews|interviewed|"
+                     r"podcast|podcasts)\b", re.I)
+
+ap = argparse.ArgumentParser()
+ap.add_argument("--n-frames", type=int, default=10)
+ap.add_argument("--step", type=float, default=0.5)
+ap.add_argument("--margin", type=float, default=0.25)
+ap.add_argument("--motion-hi", type=float, default=60.0)
+ap.add_argument("--min-aesthetic", type=float, default=5.0)
+ap.add_argument("--keep-talking", action="store_true")
+ap.add_argument("--at", type=float, default=None, help="report the percentile of this score")
+A = ap.parse_args()
+MIN_SEC = (A.n_frames - 1) * A.step + A.margin
+
+idx = {json.loads(l)["clip"] for l in open(os.path.join(META, "part_index.jsonl"))}
+mot = []
+with open(os.path.join(META, "OpenVid-1M.csv"), newline="") as f:
+    for r in csv.DictReader(f):
+        v = r["video"]
+        if v.startswith(("celebv_", "pixabay_")) or v not in idx:
+            continue
+        try:
+            m, sec, aes = float(r["motion score"]), float(r["seconds"]), float(r["aesthetic score"])
+        except ValueError:
+            continue
+        if sec < MIN_SEC or m > A.motion_hi or aes < A.min_aesthetic:
+            continue
+        if not A.keep_talking and TALKING.search(r["caption"]):
+            continue
+        mot.append(m)
+
+mot.sort()
+n = len(mot)
+print(f"candidate pool (no motion cut): {n:,} clips")
+for top in (10, 20, 30, 40, 50, 70, 100):
+    print(f"  top {top:>3}%  ->  motion >= {mot[int(n * (1 - top/100))]:.4f}")
+if A.at is not None:
+    print(f"  motion {A.at} sits at top {100 - bisect.bisect_left(mot, A.at)*100/n:.1f}%")

scripts/select_clips.py

@@ -0,0 +1,116 @@
+import argparse, csv, hashlib, json, os, re
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+META = os.path.join(ROOT, "meta")
+csv.field_size_limit(10**9)
+
+# Only the "a person is talking at the camera" cases: those clips can carry a high
+# motion score (lip/hand movement) while nothing in the scene actually changes.
+TALKING = re.compile(r"\b(talk|talks|talking|interview|interviews|interviewed|"
+                     r"podcast|podcasts)\b", re.I)
+
+p = argparse.ArgumentParser()
+p.add_argument("--n-frames",    type=int,   default=10)
+p.add_argument("--step",        type=float, default=0.5)
+p.add_argument("--max-windows", type=int,   default=2,
+               help="hard cap on sequences taken from one clip")
+p.add_argument("--margin",      type=float, default=0.25,
+               help="seconds of slack required past the last frame of a window")
+p.add_argument("--motion-lo",   type=float, default=5.27)
+p.add_argument("--motion-hi",   type=float, default=60.0)
+p.add_argument("--min-aesthetic", type=float, default=5.0)
+p.add_argument("--keep-talking", action="store_true")
+p.add_argument("--order", choices=["efficiency", "shuffle", "quality"], default="efficiency")
+p.add_argument("--out", default=os.path.join(META, "manifest.csv"))
+args = p.parse_args()
+
+SPAN = (args.n_frames - 1) * args.step      # first frame -> last frame
+SLOT = args.n_frames * args.step            # start-to-start distance between windows
+
+def n_windows(sec):
+    """How many non-overlapping windows fit, capped at --max-windows."""
+    w = 0
+    while w < args.max_windows and sec >= w * SLOT + SPAN + args.margin:
+        w += 1
+    return w
+
+print("loading part index ...", flush=True)
+idx = {}
+with open(os.path.join(META, "part_index.jsonl")) as f:
+    for line in f:
+        d = json.loads(line)
+        idx[d["clip"]] = (d["part"], d["member"], d["bytes"])
+print(f"  {len(idx):,} clips indexed", flush=True)
+
+print("loading OpenVidHD.csv ...", flush=True)
+hd = set()
+with open(os.path.join(META, "OpenVidHD.csv"), newline="") as f:
+    for r in csv.DictReader(f):
+        hd.add(r["video"])
+print(f"  {len(hd):,} HD clips", flush=True)
+
+print("scanning OpenVid-1M.csv ...", flush=True)
+rows = []
+stats = dict(total=0, prefix=0, short=0, motion=0, aesth=0, talking=0, noidx=0, bad=0)
+with open(os.path.join(META, "OpenVid-1M.csv"), newline="") as f:
+    for r in csv.DictReader(f):
+        stats["total"] += 1
+        try:
+            v = r["video"]
+            if v.startswith(("celebv_", "pixabay_")):     # 512x512 face crops / 2.67s stock
+                stats["prefix"] += 1; continue
+            sec, mot = float(r["seconds"]), float(r["motion score"])
+            nw = n_windows(sec)
+            if nw == 0:
+                stats["short"] += 1; continue
+            if not (args.motion_lo <= mot <= args.motion_hi):
+                stats["motion"] += 1; continue
+            if float(r["aesthetic score"]) < args.min_aesthetic:
+                stats["aesth"] += 1; continue
+            if not args.keep_talking and TALKING.search(r["caption"]):
+                stats["talking"] += 1; continue
+            if v not in idx:
+                stats["noidx"] += 1; continue
+            part, member, nbytes = idx[v]
+            rows.append(dict(video=v, part=part, member=member, bytes=nbytes,
+                             windows=nw, seconds=sec, fps=float(r["fps"]), motion=mot,
+                             aesthetic=float(r["aesthetic score"]),
+                             camera=r["camera motion"], hd=int(v in hd),
+                             caption=r["caption"]))
+        except Exception:
+            stats["bad"] += 1
+
+print(json.dumps(stats, indent=2), flush=True)
+print(f"kept: {len(rows):,} clips", flush=True)
+
+# Sort order == download priority: any prefix of the manifest is a usable dataset.
+if args.order == "efficiency":      # most sequences per downloaded GB
+    rows.sort(key=lambda d: d["bytes"] / d["windows"])
+elif args.order == "shuffle":       # unbiased sample at any cut point
+    rows.sort(key=lambda d: hashlib.md5(("openvid" + d["video"]).encode()).hexdigest())
+else:
+    rows.sort(key=lambda d: -(d["aesthetic"] + 2*d["hd"] - abs(d["motion"] - 12)/20))
+
+cum = 0
+fields = ["rank","video","part","member","bytes","cum_gb","windows",
+          "seconds","fps","motion","aesthetic","camera","hd","caption"]
+with open(args.out, "w", newline="") as f:
+    w = csv.DictWriter(f, fieldnames=fields)
+    w.writeheader()
+    for i, d in enumerate(rows):
+        cum += d["bytes"]
+        w.writerow({"rank": i, "cum_gb": round(cum/1e9, 4), **d})
+
+tot = sum(d["windows"] for d in rows)
+print(f"\nmanifest -> {args.out}", flush=True)
+print(f"  {args.n_frames} frames x {args.step}s (span {SPAN}s), <= {args.max_windows} windows/clip, "
+      f"motion in [{args.motion_lo}, {args.motion_hi}]", flush=True)
+print(f"  order={args.order}  {len(rows):,} clips / {tot:,} sequences / "
+      f"{tot*(args.n_frames-1):,} pairs / {cum/1e9:,.1f} GB", flush=True)
+for b in (200, 400, 600, 800, 1000):
+    c = s = 0; acc = 0
+    for d in rows:
+        acc += d["bytes"]
+        if acc/1e9 > b: break
+        c += 1; s += d["windows"]
+    print(f"  budget {b:>5} GB -> {c:>7,} clips / {s:>7,} seq / {s*(args.n_frames-1):>9,} pairs", flush=True)

scripts/verify_dataset.py

@@ -0,0 +1,74 @@
+import argparse, collections, json, os, random, statistics
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+ap = argparse.ArgumentParser()
+ap.add_argument("jsonl", nargs="?", default=os.path.join(ROOT, "sequences.jsonl"))
+ap.add_argument("--full", action="store_true", help="stat every frame path (else sample 2000 seqs)")
+ap.add_argument("--max-windows", type=int, default=2)
+ap.add_argument("--motion-lo", type=float, default=5.27)
+A = ap.parse_args()
+
+seqs = nframes = 0
+bad, ids = [], set()
+per_video = collections.Counter()
+nf_seen, step_seen = collections.Counter(), collections.Counter()
+motions, sample = [], []
+
+for line in open(A.jsonl):
+    d = json.loads(line)
+    seqs += 1
+    ids.add(d["id"])
+    per_video[d["video"]] += 1
+    nf_seen[d["n_frames"]] += 1
+    step_seen[d["step_sec"]] += 1
+    motions.append(float(d["meta"]["motion"]))
+    fr = d["frames"]
+    nframes += len(fr)
+    if len(fr) != d["n_frames"] or len(d["timestamps"]) != len(fr):
+        bad.append((d["id"], "len mismatch"))
+    ts = d["timestamps"]
+    if any(round(ts[i+1] - ts[i], 3) != d["step_sec"] for i in range(len(ts)-1)):
+        bad.append((d["id"], "irregular timestamps"))
+    if A.full:
+        for p in fr:
+            if not os.path.exists(os.path.join(ROOT, p)):
+                bad.append((d["id"], f"missing {p}")); break
+    else:
+        sample.append((d["id"], fr))
+
+if not A.full and sample:
+    for sid, fr in random.Random(0).sample(sample, min(2000, len(sample))):
+        for p in fr:
+            if not os.path.exists(os.path.join(ROOT, p)):
+                bad.append((sid, f"missing {p}")); break
+
+over = [v for v, c in per_video.items() if c > A.max_windows]
+low = [m for m in motions if m < A.motion_lo]
+
+print(f"sequences        : {seqs:,}")
+print(f"unique ids       : {len(ids):,}   (dupes: {seqs - len(ids)})")
+print(f"source clips     : {len(per_video):,}   (mean {seqs/max(1,len(per_video)):.2f} windows/clip)")
+print(f"windows/clip     : {dict(sorted(collections.Counter(per_video.values()).items()))}"
+      f"   over cap({A.max_windows}): {len(over)}")
+print(f"n_frames         : {dict(nf_seen)}")
+print(f"step_sec         : {dict(step_seen)}")
+print(f"frames listed    : {nframes:,}")
+print(f"adjacent pairs   : {nframes - seqs:,}   <- VLM caption calls")
+if motions:
+    ms = sorted(motions)
+    print(f"motion           : min {ms[0]:.2f}  med {statistics.median(ms):.2f}  "
+          f"max {ms[-1]:.2f}   below {A.motion_lo}: {len(low)}")
+print(f"path check       : {'FULL' if A.full else f'sampled {min(2000,len(sample))} seqs'} "
+      f"-> {len(bad)} problems")
+for b in bad[:10]:
+    print("   ", b)
+
+fs = []
+for dp, _, fn in os.walk(os.path.join(ROOT, "frames")):
+    fs += [os.path.getsize(os.path.join(dp, f)) for f in fn if f.endswith(".jpg")]
+if fs:
+    print(f"jpgs on disk     : {len(fs):,}  ({sum(fs)/1e9:.1f} GB, mean {statistics.mean(fs)/1024:.0f} KB)")
+    print(f"orphan jpgs      : {len(fs) - nframes:,}")
+vd = os.path.join(ROOT, "videos")
+vids = [os.path.getsize(os.path.join(vd, f)) for f in os.listdir(vd) if f.endswith(".mp4")]
+print(f"videos on disk   : {len(vids):,}  ({sum(vids)/1e9:.1f} GB)")