Sync from GitHub via hub-sync

README.md

@@ -38,6 +38,42 @@ hf jobs uv run --image vllm/vllm-openai:latest --flavor a10g-small \
 
 ## Scripts
 
+### qwen38-caption.py
+
+Runs [Qwen/Qwen3.8-27B](https://huggingface.co/Qwen/Qwen3.8-27B) (27B dense VLM,
+Apache 2.0, not gated) over a directory of videos via vLLM — **whole videos, no
+chunking**. The model ingests video natively at hour scale: an 11-minute film is
+one request. The default video processor caps each video at 768 frames and a
+fixed pixel budget, so videos longer than ~6.4 min are seen at a lower frame rate
+and resolution (an hour at ~1 frame per 4.7 s). Output is a resumable parquet dataset, one row per video with
+`caption` (and, with `--timestamps`, an `events` column of `<start - end>`
+descriptions in global seconds).
+
+`--timestamps` asks for a full event timeline instead of a prose caption. The
+model reads times off per-frame time tags rather than estimating. On one
+11-minute film (96 events), spot-checked event times matched extracted frames to
+within ~2 s, and on-screen text was quoted verbatim; that is one measured
+example, not a guarantee.
+
+Thinking mode is on for `--timestamps` (without it, the model sometimes answered
+a timeline request with a one-line summary) and off for captions.
+`--thinking` / `--no-thinking` override this. A truncated, empty or
+event-less answer is stored as an error row; `--retry-errors` tries it again.
+Row ids include the prompt and mode, so changing them re-processes videos
+instead of reusing old rows.
+
+**Hardware**: bf16 weights are ~52 GB. The script's `[tool.hf-jobs]` header
+sets `a100-large` and a pinned vLLM image, so `hf jobs uv run` needs no flavor
+or image flags (hf CLI 1.32+). `--flavor h200` generated ~2.3x faster in our
+test.
+
+**vs marlin-caption.py**: Marlin is ~13x smaller and cheaper per minute of
+footage, but must chunk at 60s (with per-chunk timestamp offsetting) and returns
+grounding candidates rather than reliable timelines. Qwen3.8 handles the whole
+film in one pass with verbatim on-screen-text reading. Rough guide: bulk
+captioning of large collections → Marlin; rich timelines, text-heavy or
+long-form material → Qwen3.8.
+
 ### marlin-caption.py
 
 Runs [NemoStation/Marlin-2B](https://huggingface.co/NemoStation/Marlin-2B) (2B video

qwen38-caption.py

@@ -0,0 +1,266 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#     "saturate[hf]==0.2.0",
+# ]
+#
+# [tool.hf-jobs]
+# image = "vllm/vllm-openai:v0.32.0"
+# flavor = "a100-large"
+# secrets = ["HF_TOKEN"]
+# ///
+
+"""
+Caption whole videos — no chunking — with Qwen3.8-27B, writing a resumable dataset.
+
+Qwen3.8-27B (Apache 2.0, not gated) ingests videos natively at hour scale: an
+11-minute film is one request, and in --timestamps mode the model returns a
+timeline of <start - end> events whose times are read off per-frame time tags
+(verified accurate to the ~2s sampling interval, with on-screen text quoted
+verbatim). This is the structural difference from marlin-caption.py, which must
+split anything over ~60s into chunks.
+
+Serves the model on vLLM inside the job and pumps every video in INPUT_DIR
+through it with saturate: crash-safe parquet out, exact resume (re-running
+skips completed videos), congestion-aware concurrency.
+
+Input:                              Output (one parquet dataset):
+  /input/film.mp4   (11 min)  ->      1 row per video — columns: video,
+  /input/clip.mp4   (45 s)    ->      duration_s, caption, events (JSON,
+                                      --timestamps mode), token counts
+
+Examples:
+
+  # Caption a bucket of videos on HF Jobs (the [tool.hf-jobs] header sets the
+  # image, a100-large and HF_TOKEN; hf CLI >= 1.32)
+  hf jobs uv run --timeout 2h \\
+      -v hf://buckets/user/my-videos:/input:ro \\
+      https://huggingface.co/datasets/uv-scripts/video/raw/main/qwen38-caption.py \\
+      /input hf://buckets/user/my-videos/captions
+
+  # Timestamped event timeline per film instead of a prose caption
+  ... qwen38-caption.py /input hf://buckets/user/out --timestamps
+
+  # Local machine with a CUDA GPU (needs ~60 GB VRAM); vLLM comes from the
+  # Jobs image, so add it yourself
+  uv run --with vllm==0.32.0 qwen38-caption.py ./videos ./captions-out
+
+Thinking mode defaults off for captions (little gain, big latency) but ON for
+--timestamps: measured on the 11-min film, the non-thinking model may answer a
+timeline request with a one-line summary, while thinking mode produced a
+frame-verified 96-event timeline. --thinking / --no-thinking overrides.
+
+Frame budget: the model's default video processor caps a video at 768 frames
+and a fixed pixel budget (~12k video tokens). At the default 2 fps anything longer than
+~6.4 min is capped, so a long film is seen at lower frame rate and resolution:
+an 11-min film at ~1 frame per 0.9 s, an hour at ~1 frame per 4.7 s. Small
+on-screen text gets harder to read as videos get longer. The model card's
+"Long Video Understanding" section explains how to raise the budget.
+
+Model: Qwen/Qwen3.8-27B (27B dense, hybrid GDN linear attention, vision tower).
+bf16 weights are ~52 GB — a100-large is the smallest sensible Jobs flavor;
+h200 generates ~2.3x faster if latency matters.
+"""
+
+import argparse
+import hashlib
+import json
+import logging
+import re
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+logger = logging.getLogger(__name__)
+
+MODEL = "Qwen/Qwen3.8-27B"
+VIDEO_EXTENSIONS = {".mp4", ".mkv", ".webm", ".mov", ".avi", ".m4v"}
+
+CAPTION_PROMPT = (
+    "Describe this video: the setting, the people, what happens over its course, "
+    "and any text that appears on screen."
+)
+TIMESTAMPS_PROMPT = (
+    "Watch this video and produce a timeline of events covering the WHOLE video "
+    "from start to finish. Output ONLY the timeline, one event per line. For "
+    "each event give the time range as <start - end> in decimal seconds "
+    "(e.g. <95.0 - 112.5>) followed by a one-sentence description. "
+    "Include title cards, on-screen text (quoted), and scene changes. "
+    "Do not summarize; cover the full duration."
+)
+
+THINK = re.compile(r"<think>.*?</think>\s*|^.*?</think>\s*", re.DOTALL)
+# accepts decimal seconds (<95.0 - 112.5>) and clock forms (<01:35 - 01:52>)
+EVENT_LINE = re.compile(
+    r"<(\d+(?::\d{2}){0,2}(?:\.\d+)?)\s*-\s*(\d+(?::\d{2}){0,2}(?:\.\d+)?)>\s*[:–\-]?\s*(.+)")
+
+
+def to_seconds(ts: str) -> float:
+    parts = [float(x) for x in ts.split(":")]
+    out = 0.0
+    for part in parts:
+        out = out * 60 + part
+    return round(out, 2)
+
+
+def probe_duration(path: Path) -> float | None:
+    try:
+        out = subprocess.run(
+            ["ffprobe", "-v", "error", "-show_entries", "format=duration",
+             "-of", "csv=p=0", str(path)],
+            capture_output=True, text=True, timeout=120)
+        return round(float(out.stdout.strip()), 2)
+    except (ValueError, subprocess.SubprocessError):
+        return None
+
+
+def config_tag(**config) -> str:
+    """Short hash of everything that changes the output, so resume never reuses
+    a row produced under a different prompt, mode or frame rate."""
+    return hashlib.sha256(json.dumps(config, sort_keys=True).encode()).hexdigest()[:12]
+
+
+def parse_events(text: str) -> list[dict]:
+    return [{"start": to_seconds(a), "end": to_seconds(b), "text": d.strip()}
+            for a, b, d in EVENT_LINE.findall(text)]
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("input_dir", help="Directory of videos (e.g. a mounted bucket)")
+    parser.add_argument("output", help="Dataset output: hf://datasets/..., hf://buckets/..., or local path")
+    parser.add_argument("--timestamps", action="store_true",
+                        help="Return a <start - end> event timeline per video instead of a prose caption")
+    parser.add_argument("--prompt", help="Override the built-in prompt")
+    parser.add_argument("--thinking", action=argparse.BooleanOptionalAction, default=None,
+                        help="Thinking mode. Default: on for --timestamps (measured: without it the "
+                             "model may summarize instead of covering the video), off otherwise")
+    parser.add_argument("--max-videos", type=int, help="Only process the first N videos (testing)")
+    parser.add_argument("--window-max", type=int, default=8,
+                        help="Max in-flight requests (default 8 — whole-video requests are large)")
+    parser.add_argument("--max-model-len", type=int, default=131072)
+    parser.add_argument("--retry-errors", action="store_true",
+                        help="Re-attempt rows that errored in a previous run")
+    args = parser.parse_args()
+    if args.window_max < 1:
+        sys.exit("--window-max must be at least 1")
+
+    if shutil.which("ffprobe") is None:
+        sys.exit("ffprobe not found — use the vllm/vllm-openai image (has it) or install ffmpeg")
+
+    input_root = Path(args.input_dir).resolve()
+    videos = sorted(p for p in input_root.rglob("*")
+                    if p.suffix.lower() in VIDEO_EXTENSIONS)
+    if args.max_videos:
+        videos = videos[: args.max_videos]
+    if not videos:
+        sys.exit(f"no videos found under {input_root}")
+    logger.info("found %d videos", len(videos))
+
+    prompt = args.prompt or (TIMESTAMPS_PROMPT if args.timestamps else CAPTION_PROMPT)
+    thinking = args.timestamps if args.thinking is None else args.thinking
+    tag = config_tag(model=MODEL, prompt=prompt, timestamps=args.timestamps,
+                     thinking=thinking)
+    logger.info("config tag %s (part of every row id; changing the prompt or mode "
+                "re-processes videos instead of reusing old rows)", tag)
+
+    # Row id = relative path + file size + config tag: a replaced video or a
+    # changed setting gets a new id, so resume cannot return a stale result.
+    rows = [(f"{p.relative_to(input_root)}|{p.stat().st_size}|{tag}",
+             {"video": str(p.relative_to(input_root)), "uri": p.as_uri(),
+              "duration_s": probe_duration(p)})
+            for p in videos]
+    # Timeline output scales with video length; measured 9.6K tokens for an
+    # 11-min film — leave generous headroom. Thinking needs its own budget on top.
+    max_tokens = 16384 if args.timestamps else 4096
+    if thinking:
+        max_tokens += 32768
+
+    def to_request(row: dict) -> dict:
+        req = {
+            "model": MODEL,
+            "messages": [{"role": "user", "content": [
+                {"type": "video_url", "video_url": {"url": row["uri"]}},
+                {"type": "text", "text": prompt},
+            ]}],
+            "max_tokens": max_tokens,
+        }
+        if thinking:  # model-card sampling params per mode
+            req.update({"temperature": 1.0, "top_p": 0.95, "top_k": 20})
+        else:
+            req.update({"temperature": 0.7, "top_p": 0.8, "top_k": 20,
+                        "presence_penalty": 1.5,
+                        "chat_template_kwargs": {"enable_thinking": False}})
+        return req
+
+    def parse(row: dict, resp: dict) -> dict:
+        # Raising here makes saturate store an error row, which --retry-errors
+        # re-attempts; a truncated or empty answer must not count as done.
+        choice = resp["choices"][0]
+        raw = choice["message"]["content"] or ""
+        if choice.get("finish_reason") == "length":
+            raise ValueError(f"truncated at max_tokens={max_tokens} (finish_reason=length)")
+        if "<think>" in raw and "</think>" not in raw:
+            raise ValueError("reasoning never finished (no </think>)")
+        text = THINK.sub("", raw).strip()
+        if not text:
+            raise ValueError("empty response")
+        usage = resp.get("usage") or {}
+        out = {"video": row["video"], "duration_s": row["duration_s"],
+               "caption": text,
+               "prompt_tokens": usage.get("prompt_tokens"),
+               "completion_tokens": usage.get("completion_tokens")}
+        if args.timestamps:
+            events = parse_events(text)
+            if not events:
+                raise ValueError("no <start - end> events in the response")
+            duration = row["duration_s"]
+            if duration and any(e["end"] > duration + 2.0 for e in events):
+                raise ValueError(f"event ends past the video's {duration}s duration")
+            out["events"] = json.dumps(events)
+        return out
+
+    from saturate import Auto, Engine, pump
+
+    with Engine(
+        MODEL,
+        engine="vllm",
+        extra_args=[
+            "--allowed-local-media-path", str(input_root),
+            "--max-model-len", str(args.max_model_len),
+            # Model card's video flag. vLLM 0.32 then samples at the model's
+            # default 2 fps (a 60 s clip -> 119 frames). Do NOT also pass
+            # --mm-processor-kwargs '{"fps": ..., "do_sample_frames": true}':
+            # on 0.32 the frames are sampled twice and every request 400s.
+            "--media-io-kwargs", json.dumps({"video": {"num_frames": -1}}),
+            # Unbounded growth on distinct videos — OOM-kills the node if left on.
+            "--mm-processor-cache-gb", "0",
+        ],
+    ) as endpoint:
+        stats = pump(
+            rows,
+            to_request=to_request,
+            parse=parse,
+            endpoint=endpoint,
+            output=args.output,
+            window=Auto(initial=min(4, args.window_max), min_limit=1,
+                        max_limit=args.window_max),
+            retry_errors=args.retry_errors,
+            # A thinking timeline can run to ~49k tokens; at 8 in flight one
+            # request can take longer than saturate's 1800 s default.
+            read_timeout=7200,
+        )
+
+    logger.info("done: %d ok, %d failed, %.1f tok/s (window settled at %d)",
+                stats.rows_processed, stats.rows_failed,
+                stats.tokens_per_sec, stats.final_limit)
+    if stats.rows_failed:
+        logger.warning("failed rows are recorded in the output; re-run with "
+                       "--retry-errors to attempt them again")
+
+
+if __name__ == "__main__":
+    main()