Improve orchestration robustness, monitoring, and DWPose optimization

debug/benchmark_dwpose_cpu_vs_gpu.py

@@ -0,0 +1,251 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+
+DEFAULT_RAW_VIDEO_DIR = Path("/home/sf895/Sign-DWPose-2M-runtime/raw_video")
+VIDEO_EXTENSIONS = (".mp4", ".mkv", ".webm", ".mov")
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Benchmark DWpose CPU vs GPU on the same video and estimate CPU threads per 1 GPU."
+    )
+    parser.add_argument("--video-id", type=str, required=True)
+    parser.add_argument("--raw-video-dir", type=Path, default=DEFAULT_RAW_VIDEO_DIR)
+    parser.add_argument("--fps", type=int, default=24)
+    parser.add_argument("--max-frames", type=int, default=None)
+    parser.add_argument(
+        "--cpu-threads",
+        type=str,
+        default="1,2,4,8,16,32",
+        help="Comma-separated CPU thread counts to benchmark.",
+    )
+    parser.add_argument(
+        "--device",
+        choices=("cpu", "gpu"),
+        default=None,
+        help="Internal worker mode. Omit to run the controller.",
+    )
+    parser.add_argument("--json", action="store_true", help="Emit final summary as JSON.")
+    return parser.parse_args()
+
+
+def resolve_video_path(video_id: str, raw_video_dir: Path) -> Path:
+    for ext in VIDEO_EXTENSIONS:
+        candidate = raw_video_dir / f"{video_id}{ext}"
+        if candidate.is_file():
+            return candidate
+    raise FileNotFoundError(f"Video not found for {video_id} under {raw_video_dir}")
+
+
+def run_ffprobe_dims(video_path: Path) -> tuple[int, int]:
+    proc = subprocess.run(
+        [
+            "ffprobe",
+            "-v",
+            "error",
+            "-select_streams",
+            "v:0",
+            "-show_entries",
+            "stream=width,height",
+            "-of",
+            "csv=p=0:s=x",
+            str(video_path),
+        ],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    dims = (proc.stdout or "").strip()
+    if "x" not in dims:
+        raise RuntimeError(f"Unable to parse ffprobe dimensions: {dims!r}")
+    width_s, height_s = dims.split("x", 1)
+    return int(width_s), int(height_s)
+
+
+def stream_frames(video_path: Path, fps: int, max_frames: int | None):
+    import numpy as np
+    from PIL import Image
+
+    width, height = run_ffprobe_dims(video_path)
+    frame_bytes = width * height * 3
+    command = [
+        "ffmpeg",
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-i",
+        str(video_path),
+        "-vf",
+        f"fps={fps}",
+        "-f",
+        "rawvideo",
+        "-pix_fmt",
+        "rgb24",
+        "pipe:1",
+    ]
+    proc = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    assert proc.stdout is not None
+    frame_index = 0
+    stopped_early = False
+    try:
+        while True:
+            if max_frames is not None and frame_index >= max_frames:
+                stopped_early = True
+                break
+            chunk = proc.stdout.read(frame_bytes)
+            if not chunk:
+                break
+            if len(chunk) != frame_bytes:
+                raise RuntimeError(
+                    f"Short raw frame read: expected {frame_bytes} bytes, got {len(chunk)}"
+                )
+            frame_index += 1
+            frame_array = np.frombuffer(chunk, dtype=np.uint8).reshape((height, width, 3))
+            yield frame_index, Image.fromarray(frame_array, mode="RGB")
+    finally:
+        if stopped_early and proc.poll() is None:
+            proc.terminate()
+        if proc.stdout:
+            proc.stdout.close()
+        stderr = proc.stderr.read().decode("utf-8", errors="replace") if proc.stderr else ""
+        if proc.stderr:
+            proc.stderr.close()
+        returncode = proc.wait()
+        if returncode != 0 and not stopped_early:
+            raise RuntimeError(f"ffmpeg raw frame stream failed: {stderr.strip()}")
+
+
+def worker_main(args: argparse.Namespace) -> int:
+    video_path = resolve_video_path(args.video_id, args.raw_video_dir)
+
+    if args.device == "cpu":
+        cpu_threads = int(os.environ.get("DWPOSE_CPU_THREADS", "1"))
+        os.environ["OMP_NUM_THREADS"] = str(cpu_threads)
+        os.environ["MKL_NUM_THREADS"] = str(cpu_threads)
+        os.environ["OPENBLAS_NUM_THREADS"] = str(cpu_threads)
+        os.environ["NUMEXPR_NUM_THREADS"] = str(cpu_threads)
+        os.environ["ORT_NUM_THREADS"] = str(cpu_threads)
+
+    from easy_dwpose import DWposeDetector
+
+    device = "cpu" if args.device == "cpu" else "cuda:0"
+    detector = DWposeDetector(device=device)
+
+    start = time.perf_counter()
+    frames = 0
+    for frame_index, frame in stream_frames(video_path, args.fps, args.max_frames):
+        detector(frame, draw_pose=False, include_hands=True, include_face=True)
+        frames = frame_index
+    elapsed = time.perf_counter() - start
+    result = {
+        "video_id": args.video_id,
+        "video_path": str(video_path),
+        "device": args.device,
+        "fps": args.fps,
+        "max_frames": args.max_frames,
+        "frames_processed": frames,
+        "elapsed_seconds": elapsed,
+        "frames_per_second": (frames / elapsed) if elapsed > 0 else 0.0,
+        "cpu_threads": int(os.environ.get("DWPOSE_CPU_THREADS", "0")) if args.device == "cpu" else 0,
+        "hostname": os.uname().nodename,
+    }
+    print(json.dumps(result, sort_keys=True))
+    return 0
+
+
+def run_worker(script_path: Path, args: argparse.Namespace, device: str, cpu_threads: int | None = None) -> dict:
+    env = os.environ.copy()
+    if cpu_threads is not None:
+        env["DWPOSE_CPU_THREADS"] = str(cpu_threads)
+    cmd = [
+        sys.executable,
+        str(script_path),
+        "--video-id",
+        args.video_id,
+        "--raw-video-dir",
+        str(args.raw_video_dir),
+        "--fps",
+        str(args.fps),
+        "--device",
+        device,
+    ]
+    if args.max_frames is not None:
+        cmd.extend(["--max-frames", str(args.max_frames)])
+    proc = subprocess.run(cmd, check=True, capture_output=True, text=True, env=env)
+    lines = [line.strip() for line in proc.stdout.splitlines() if line.strip()]
+    if not lines:
+        raise RuntimeError(f"No benchmark output returned for device={device}")
+    return json.loads(lines[-1])
+
+
+def controller_main(args: argparse.Namespace) -> int:
+    script_path = Path(__file__).resolve()
+    video_path = resolve_video_path(args.video_id, args.raw_video_dir)
+    cpu_threads_list = [int(x) for x in args.cpu_threads.split(",") if x.strip()]
+
+    gpu_result = run_worker(script_path, args, "gpu")
+    cpu_results = [run_worker(script_path, args, "cpu", cpu_threads=t) for t in cpu_threads_list]
+
+    summary = {
+        "video_id": args.video_id,
+        "video_path": str(video_path),
+        "fps": args.fps,
+        "max_frames": args.max_frames,
+        "gpu_result": gpu_result,
+        "cpu_results": [],
+    }
+    gpu_elapsed = gpu_result["elapsed_seconds"]
+    for cpu_result in cpu_results:
+        cpu_elapsed = cpu_result["elapsed_seconds"]
+        cpu_threads = cpu_result["cpu_threads"]
+        cpu_equivalent_threads = (cpu_threads * cpu_elapsed / gpu_elapsed) if gpu_elapsed > 0 else None
+        merged = dict(cpu_result)
+        merged["speedup_gpu_over_cpu"] = (cpu_elapsed / gpu_elapsed) if gpu_elapsed > 0 else None
+        merged["approx_cpu_threads_for_one_gpu"] = cpu_equivalent_threads
+        summary["cpu_results"].append(merged)
+
+    if args.json:
+        print(json.dumps(summary, indent=2, sort_keys=True))
+        return 0
+
+    print(f"video_id={summary['video_id']}")
+    print(f"video_path={summary['video_path']}")
+    print(f"fps={summary['fps']}")
+    print(f"max_frames={summary['max_frames']}")
+    print(
+        "gpu_result "
+        f"elapsed_seconds={gpu_result['elapsed_seconds']:.3f} "
+        f"frames_processed={gpu_result['frames_processed']} "
+        f"frames_per_second={gpu_result['frames_per_second']:.3f}"
+    )
+    for row in summary["cpu_results"]:
+        print(
+            "cpu_result "
+            f"threads={row['cpu_threads']} "
+            f"elapsed_seconds={row['elapsed_seconds']:.3f} "
+            f"frames_processed={row['frames_processed']} "
+            f"frames_per_second={row['frames_per_second']:.3f} "
+            f"speedup_gpu_over_cpu={row['speedup_gpu_over_cpu']:.3f} "
+            f"approx_cpu_threads_for_one_gpu={row['approx_cpu_threads_for_one_gpu']:.2f}"
+        )
+    return 0
+
+
+def main() -> int:
+    args = parse_args()
+    if args.device is not None:
+        return worker_main(args)
+    return controller_main(args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

debug/benchmark_dwpose_cpu_vs_gpu.slurm

@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+#SBATCH --job-name=dwpose-cpu-gpu-bench
+#SBATCH --nodes=1
+#SBATCH --ntasks=1
+#SBATCH --cpus-per-task=32
+#SBATCH --gres=gpu:1
+#SBATCH --mem=32G
+#SBATCH --time=02:00:00
+#SBATCH --output=/home/sf895/Sign-DWPose-2M-runtime/slurm/logs/dwpose_cpu_gpu_bench_%j.out
+#SBATCH --error=/home/sf895/Sign-DWPose-2M-runtime/slurm/logs/dwpose_cpu_gpu_bench_%j.err
+
+set -euo pipefail
+
+ROOT_DIR="/cache/home/sf895/Sign-DWPose-2M"
+CONDA_SH="/home/sf895/miniconda3/etc/profile.d/conda.sh"
+CONDA_ENV="signx2"
+SCRIPT="$ROOT_DIR/debug/benchmark_dwpose_cpu_vs_gpu.py"
+VIDEO_ID="${1:?video id required}"
+FPS="${FPS:-24}"
+MAX_FRAMES="${MAX_FRAMES:-240}"
+CPU_THREADS="${CPU_THREADS:-1,2,4,8,16,32}"
+RAW_VIDEO_DIR="${RAW_VIDEO_DIR:-/home/sf895/Sign-DWPose-2M-runtime/raw_video}"
+
+source "$CONDA_SH"
+
+printf 'video_id=%s\n' "$VIDEO_ID"
+printf 'hostname=%s\n' "$(hostname)"
+printf 'cuda_visible_devices=%s\n' "${CUDA_VISIBLE_DEVICES:-unset}"
+printf 'fps=%s\n' "$FPS"
+printf 'max_frames=%s\n' "$MAX_FRAMES"
+printf 'cpu_threads=%s\n' "$CPU_THREADS"
+
+conda run -n "$CONDA_ENV" python "$SCRIPT" \
+  --video-id "$VIDEO_ID" \
+  --raw-video-dir "$RAW_VIDEO_DIR" \
+  --fps "$FPS" \
+  --max-frames "$MAX_FRAMES" \
+  --cpu-threads "$CPU_THREADS"

debug/cluster_capacity_snapshot.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import re
+import subprocess
+import sys
+from collections import Counter
+
+
+def run(cmd: list[str]) -> str:
+    proc = subprocess.run(cmd, check=False, capture_output=True, text=True)
+    if proc.returncode != 0:
+        raise RuntimeError(f"command failed: {' '.join(cmd)}\n{proc.stderr.strip()}")
+    return proc.stdout
+
+
+def count_free_gpus(partition: str) -> tuple[int, int]:
+    nodes_out = run(["sinfo", "-h", "-N", "-p", partition, "-o", "%N"])
+    nodes = [line.strip() for line in nodes_out.splitlines() if line.strip()]
+    total = 0
+    free = 0
+    for node in nodes:
+        node_out = run(["scontrol", "show", "node", node, "-o"]).strip()
+        if not node_out:
+            continue
+        state_m = re.search(r"\bState=([^ ]+)", node_out)
+        state = state_m.group(1).lower() if state_m else ""
+        if any(flag in state for flag in ("drain", "drained", "down", "fail", "inval")):
+            continue
+        cfg_m = re.search(r"\bCfgTRES=.*?(?:,|^)gres/gpu=(\d+)", node_out)
+        alloc_m = re.search(r"\bAllocTRES=.*?(?:,|^)gres/gpu=(\d+)", node_out)
+        node_total = int(cfg_m.group(1)) if cfg_m else 0
+        node_used = int(alloc_m.group(1)) if alloc_m else 0
+        total += node_total
+        free += max(0, node_total - node_used)
+    return free, total
+
+
+def count_cpu_capacity(partition: str) -> tuple[int, int, int]:
+    out = run(["sinfo", "-h", "-N", "-p", partition, "-o", "%N|%C|%t"])
+    free_cpu = 0
+    total_cpu = 0
+    nodes_with_free_cpu = 0
+    for line in out.splitlines():
+        if not line.strip() or "|" not in line:
+            continue
+        _node, cpu_field, state = line.split("|", 2)
+        state = state.strip().lower()
+        if any(flag in state for flag in ("drain", "drained", "down", "fail", "inval")):
+            continue
+        parts = cpu_field.split("/")
+        if len(parts) != 4:
+            continue
+        _alloc, idle, _other, total = (int(x) for x in parts)
+        free_cpu += idle
+        total_cpu += total
+        if idle > 0:
+            nodes_with_free_cpu += 1
+    return free_cpu, total_cpu, nodes_with_free_cpu
+
+
+def user_job_breakdown(user: str) -> Counter[tuple[str, str]]:
+    out = run(["squeue", "-u", user, "-h", "-o", "%j|%T"])
+    counter: Counter[tuple[str, str]] = Counter()
+    for line in out.splitlines():
+        if not line.strip() or "|" not in line:
+            continue
+        job, state = line.split("|", 1)
+        counter[(job.strip(), state.strip())] += 1
+    return counter
+
+
+def main() -> int:
+    user = sys.argv[1] if len(sys.argv) > 1 else "sf895"
+    cpu_free, cpu_total, cpu_nodes = count_cpu_capacity("main")
+    gpu_parts = ["gpu", "gpu-redhat", "cgpu"]
+    print(f"user={user}")
+    print(f"cpu_partition=main free_cpu={cpu_free} total_cpu={cpu_total} nodes_with_free_cpu={cpu_nodes}")
+    for part in gpu_parts:
+        free, total = count_free_gpus(part)
+        print(f"gpu_partition={part} free_gpu={free} total_gpu={total}")
+    jobs = user_job_breakdown(user)
+    for (job, state), count in sorted(jobs.items()):
+        print(f"user_jobs job={job} state={state} count={count}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

reproduce_independently_slurm.sh

@@ -23,6 +23,7 @@ PROGRESS_JSON="${PROGRESS_JSON:-$RUNTIME_ROOT/archive_upload_progress.json}"
 PIPELINE01="${PIPELINE01:-$ROOT_DIR/scripts/pipeline01_download_video_fix_caption.py}"
 PIPELINE02="${PIPELINE02:-$ROOT_DIR/scripts/pipeline02_extract_dwpose_from_video.py}"
 PIPELINE03="${PIPELINE03:-$ROOT_DIR/scripts/pipeline03_upload_to_huggingface.py}"
+PIPELINE_SYNC="${PIPELINE_SYNC:-$ROOT_DIR/scripts/sync_processed_csv_from_runtime.py}"
 
 STAGE="${STAGE:-all}"
 LIMIT="${LIMIT:-}"
@@ -32,10 +33,11 @@ WORKERS="${WORKERS:-}"
 TARGET_BYTES="${TARGET_BYTES:-$((10 * 1024 * 1024 * 1024))}"
 TARGET_FOLDERS="${TARGET_FOLDERS:-40}"
 DOWNLOAD_BATCH_SIZE="${DOWNLOAD_BATCH_SIZE:-1}"
-DOWNLOAD_WORKERS="${DOWNLOAD_WORKERS:-4}"
+DOWNLOAD_WORKERS="${DOWNLOAD_WORKERS:-60}"
 USE_SLURM_DOWNLOAD="${USE_SLURM_DOWNLOAD:-1}"
 PROCESS_BATCH_SIZE="${PROCESS_BATCH_SIZE:-}"
 MIN_PROCESS_START_BACKLOG="${MIN_PROCESS_START_BACKLOG:-4}"
+PROCESS_PENDING_TIMEOUT_SECONDS="${PROCESS_PENDING_TIMEOUT_SECONDS:-1800}"
 RAW_BACKLOG_LIMIT="${RAW_BACKLOG_LIMIT:-180}"
 MAX_RAW_VIDEO_BYTES="${MAX_RAW_VIDEO_BYTES:-0}"
 MAX_ITERATIONS="${MAX_ITERATIONS:-0}"
@@ -58,9 +60,11 @@ DOWNLOAD_TIME="${DOWNLOAD_TIME:-04:00:00}"
 DOWNLOAD_CPUS_PER_TASK="${DOWNLOAD_CPUS_PER_TASK:-1}"
 DOWNLOAD_MEM="${DOWNLOAD_MEM:-4G}"
 DOWNLOAD_ARRAY_PARALLEL="${DOWNLOAD_ARRAY_PARALLEL:-32}"
-DOWNLOAD_MAX_ACTIVE="${DOWNLOAD_MAX_ACTIVE:-30}"
+DOWNLOAD_MAX_ACTIVE="${DOWNLOAD_MAX_ACTIVE:-60}"
 DOWNLOAD_START_STAGGER_MIN="${DOWNLOAD_START_STAGGER_MIN:-1}"
 DOWNLOAD_START_STAGGER_MAX="${DOWNLOAD_START_STAGGER_MAX:-3}"
+DOWNLOAD_CLAIM_GRACE_SECONDS="${DOWNLOAD_CLAIM_GRACE_SECONDS:-600}"
+DOWNLOAD_PARTIAL_TIMEOUT_SECONDS="${DOWNLOAD_PARTIAL_TIMEOUT_SECONDS:-1800}"
 ORCHESTRATOR_PARTITION="${ORCHESTRATOR_PARTITION:-main}"
 ORCHESTRATOR_ACCOUNT="${ORCHESTRATOR_ACCOUNT:-}"
 ORCHESTRATOR_TIME="${ORCHESTRATOR_TIME:-24:00:00}"
@@ -539,6 +543,18 @@ run_process_stage() {
   return "$status"
 }
 
+run_sync_csv_stage() {
+  python "$PIPELINE_SYNC" \
+    --source-metadata-csv "$SOURCE_METADATA_CSV" \
+    --output-metadata-csv "$OUTPUT_METADATA_CSV" \
+    --raw-video-dir "$RAW_VIDEO_DIR" \
+    --raw-caption-dir "$RAW_CAPTION_DIR" \
+    --raw-metadata-dir "$RAW_METADATA_DIR" \
+    --dataset-dir "$DATASET_DIR" \
+    --progress-path "$PROGRESS_JSON" \
+    --status-journal-path "$RUNTIME_ROOT/upload_status_journal.jsonl"
+}
+
 run_upload_stage() {
   local require_target="${1:-0}"
   local cmd=(python "$PIPELINE03"
@@ -614,19 +630,126 @@ print(pending)
 PY
 }
 
+count_download_stop_guard() {
+  python - <<PY
+import csv
+import json
+import re
+import subprocess
+from pathlib import Path
+source_csv = Path("$SOURCE_METADATA_CSV")
+processed_csv = Path("$OUTPUT_METADATA_CSV")
+progress_json = Path("$PROGRESS_JSON")
+source_rows = 0
+terminal_rows = 0
+uploaded_rows = 0
+if source_csv.exists():
+    with source_csv.open("r", encoding="utf-8-sig", newline="") as handle:
+        for row in csv.reader(handle):
+            if row and (row[0] or "").strip():
+                source_rows += 1
+if processed_csv.exists():
+    with processed_csv.open("r", encoding="utf-8-sig", newline="") as handle:
+        reader = csv.DictReader(handle)
+        for row in reader:
+            if (row.get("download_status") or "").strip() in {"ok", "skipped"}:
+                terminal_rows += 1
+if progress_json.exists():
+    try:
+        uploaded_rows = len(json.loads(progress_json.read_text()).get("uploaded_folders", {}))
+    except Exception:
+        uploaded_rows = 0
+line_re = re.compile(r"^(?P<jobid>[^|]+)\|(?P<job>[^|]+)\|(?P<state>[^|]+)$")
+array_re = re.compile(r"^(\d+)_\[(.+)\]$")
+def expand_count(jobid_token: str) -> int:
+    m = array_re.match(jobid_token)
+    if not m:
+        return 1
+    body = m.group(2)
+    if "%" in body:
+        body = body.split("%", 1)[0]
+    total = 0
+    for part in body.split(","):
+        part = part.strip()
+        if not part:
+            continue
+        if "-" in part:
+            a, b = part.split("-", 1)
+            try:
+                total += int(b) - int(a) + 1
+            except ValueError:
+                total += 1
+        else:
+            total += 1
+    return max(total, 1)
+live_download_jobs = 0
+try:
+    proc = subprocess.run(["squeue", "-u", "$USER", "-h", "-o", "%i|%j|%T"], check=False, capture_output=True, text=True)
+    for line in (proc.stdout or "").splitlines():
+        m = line_re.match(line.strip())
+        if not m:
+            continue
+        if m.group("job") != "download":
+            continue
+        if m.group("state") not in {"RUNNING", "PENDING", "CONFIGURING"}:
+            continue
+        live_download_jobs += expand_count(m.group("jobid"))
+except Exception:
+    live_download_jobs = 0
+print(f"{source_rows}|{terminal_rows}|{uploaded_rows}|{live_download_jobs}")
+PY
+}
+
 cleanup_stale_download_claims() {
   python - <<PY
 import os
 import subprocess
+from datetime import datetime, timedelta
 from pathlib import Path
 claim_dir = Path("$DOWNLOAD_CLAIM_DIR")
 claim_dir.mkdir(parents=True, exist_ok=True)
 removed = 0
+now = datetime.now()
+job_states = {}
+base_states = {}
 try:
-    result = subprocess.run(["squeue", "-h", "-u", "$USER", "-o", "%A"], check=True, capture_output=True, text=True)
-    active_jobs = {line.split("_", 1)[0].strip() for line in result.stdout.splitlines() if line.strip()}
+    result = subprocess.run(["squeue", "-h", "-u", "$USER", "-o", "%i|%T"], check=True, capture_output=True, text=True)
+    for line in result.stdout.splitlines():
+        if not line.strip() or "|" not in line:
+            continue
+        job_key, state = line.split("|", 1)
+        job_key = job_key.strip()
+        state = state.strip().upper()
+        job_states[job_key] = state
+        base_states[job_key.split("_", 1)[0]] = state
 except Exception:
-    active_jobs = set()
+    job_states = {}
+    base_states = {}
+base_activity_cache = {}
+def base_job_alive(job_id: str) -> bool:
+    if not job_id:
+        return False
+    if job_id in base_activity_cache:
+        return base_activity_cache[job_id]
+    alive = False
+    try:
+        proc = subprocess.run(["sacct", "-n", "-X", "-j", job_id, "--format=JobIDRaw,State", "-P"], check=False, capture_output=True, text=True)
+        terminal_tokens = ("COMPLETED", "FAILED", "CANCELLED", "TIMEOUT", "OUT_OF_MEMORY", "NODE_FAIL", "PREEMPTED", "BOOT_FAIL", "DEADLINE", "REVOKED")
+        for row in proc.stdout.splitlines():
+            if not row.strip() or "|" not in row:
+                continue
+            jid, state = row.split("|", 1)
+            jid = jid.strip()
+            state = state.strip().upper()
+            if not jid.startswith(job_id):
+                continue
+            if state and not any(tok in state for tok in terminal_tokens):
+                alive = True
+                break
+    except Exception:
+        alive = job_id in base_states
+    base_activity_cache[job_id] = alive
+    return alive
 for claim_path in claim_dir.glob("*.claim"):
     try:
         lines = claim_path.read_text(encoding="utf-8").splitlines()
@@ -634,6 +757,9 @@ for claim_path in claim_dir.glob("*.claim"):
         continue
     pid = None
     job_id = ""
+    task_id = ""
+    job_key = ""
+    submitted_at = ""
     for line in lines:
         if line.startswith("pid="):
             try:
@@ -642,10 +768,27 @@ for claim_path in claim_dir.glob("*.claim"):
                 pid = None
         elif line.startswith("job_id="):
             job_id = line.split("=", 1)[1].strip()
+        elif line.startswith("task_id="):
+            task_id = line.split("=", 1)[1].strip()
+        elif line.startswith("job_key="):
+            job_key = line.split("=", 1)[1].strip()
+        elif line.startswith("submitted_at="):
+            submitted_at = line.split("=", 1)[1].strip()
     alive = False
-    if job_id:
-        alive = job_id in active_jobs
-    elif pid is not None:
+    if submitted_at:
+        try:
+            submitted_dt = datetime.strptime(submitted_at, "%Y-%m-%d %H:%M:%S")
+            if (now - submitted_dt) <= timedelta(seconds=int("$DOWNLOAD_CLAIM_GRACE_SECONDS")):
+                alive = True
+        except Exception:
+            pass
+    if (not alive) and job_key:
+        alive = job_key in job_states
+    elif (not alive) and job_id and task_id:
+        alive = f"{job_id}_{task_id}" in job_states
+    elif (not alive) and job_id:
+        alive = base_job_alive(job_id)
+    elif (not alive) and pid is not None:
         try:
             os.kill(pid, 0)
             alive = True
@@ -658,6 +801,51 @@ print(removed)
 PY
 }
 
+cleanup_stale_download_partials() {
+  python - <<PY
+import time
+from pathlib import Path
+claim_dir = Path("$DOWNLOAD_CLAIM_DIR")
+raw_dir = Path("$RAW_VIDEO_DIR")
+timeout = int("$DOWNLOAD_PARTIAL_TIMEOUT_SECONDS")
+now = time.time()
+active_ids = set()
+try:
+    claim_dir.mkdir(parents=True, exist_ok=True)
+    for claim_path in claim_dir.glob("*.claim"):
+        active_ids.add(claim_path.stem)
+except Exception:
+    pass
+removed = 0
+if raw_dir.exists():
+    for path in raw_dir.iterdir():
+        if not path.is_file():
+            continue
+        name = path.name
+        if not (name.endswith(".part") or name.endswith(".ytdl") or ".mp4.part" in name or ".mp4.ytdl" in name or ".webm.part" in name or ".webm.ytdl" in name or ".mkv.part" in name or ".mkv.ytdl" in name or ".mov.part" in name or ".mov.ytdl" in name):
+            continue
+        video_id = name
+        for suffix in (".mp4.part", ".webm.part", ".mkv.part", ".mov.part", ".mp4.ytdl", ".webm.ytdl", ".mkv.ytdl", ".mov.ytdl", ".part", ".ytdl"):
+            if video_id.endswith(suffix):
+                video_id = video_id[:-len(suffix)]
+                break
+        if video_id in active_ids:
+            continue
+        try:
+            age = now - path.stat().st_mtime
+        except OSError:
+            continue
+        if age < timeout:
+            continue
+        try:
+            path.unlink()
+            removed += 1
+        except OSError:
+            pass
+print(removed)
+PY
+}
+
 dir_size_bytes() {
   python - <<PY
 from pathlib import Path
@@ -677,33 +865,213 @@ PY
 count_active_process_claims() {
   python - <<PY
 import subprocess
+from datetime import datetime, timedelta
 from pathlib import Path
+from datetime import datetime, timedelta
 claim_dir = Path("$STATE_ROOT/slurm/state/claims")
 claim_dir.mkdir(parents=True, exist_ok=True)
+timeout_seconds = int("$PROCESS_PENDING_TIMEOUT_SECONDS")
+now = datetime.now()
+job_states = {}
+base_states = {}
 try:
-    result = subprocess.run(["squeue", "-h", "-u", "$USER", "-o", "%A"], check=True, capture_output=True, text=True)
-    active_jobs = {line.split("_", 1)[0].strip() for line in result.stdout.splitlines() if line.strip()}
+    result = subprocess.run(["squeue", "-h", "-u", "$USER", "-o", "%i|%T"], check=True, capture_output=True, text=True)
+    for line in result.stdout.splitlines():
+        if not line.strip() or "|" not in line:
+            continue
+        job_key, state = line.split("|", 1)
+        job_key = job_key.strip()
+        state = state.strip().upper()
+        job_states[job_key] = state
+        base_states[job_key.split("_", 1)[0]] = state
 except Exception:
-    active_jobs = set()
+    job_states = {}
+    base_states = {}
 count = 0
 for claim_path in claim_dir.glob("*.claim"):
     try:
         lines = claim_path.read_text(encoding="utf-8").splitlines()
     except OSError:
         continue
-    job_id = ""
+    meta = {}
     for line in lines:
-        if line.startswith("job_id="):
-            job_id = line.split("=", 1)[1].strip()
-            break
-    if job_id and job_id in active_jobs:
-        count += 1
+        if "=" in line:
+            k, v = line.split("=", 1)
+            meta[k.strip()] = v.strip()
+    job_id = meta.get("job_id", "")
+    task_id = meta.get("task_id", "")
+    job_key = meta.get("job_key", "")
+    if not job_id:
+        claim_path.unlink(missing_ok=True)
+        continue
+    state = None
+    if job_key:
+        state = job_states.get(job_key)
+    elif task_id:
+        state = job_states.get(f"{job_id}_{task_id}")
     else:
+        state = base_states.get(job_id)
+    if not state:
+        claim_path.unlink(missing_ok=True)
+        continue
+    submitted_at = meta.get("submitted_at", "")
+    stale_pending = False
+    if state == "PENDING" and submitted_at:
+        try:
+            submitted_dt = datetime.strptime(submitted_at, "%Y-%m-%d %H:%M:%S")
+            stale_pending = (now - submitted_dt) > timedelta(seconds=timeout_seconds)
+        except Exception:
+            stale_pending = False
+    if stale_pending:
+        subprocess.run(["scancel", job_id], check=False)
         claim_path.unlink(missing_ok=True)
+        continue
+    count += 1
 print(count)
 PY
 }
 
+cleanup_stale_process_jobs() {
+  python - <<PY
+import subprocess
+from datetime import datetime, timedelta
+from pathlib import Path
+
+claim_dir = Path("$STATE_ROOT/slurm/state/claims")
+claim_dir.mkdir(parents=True, exist_ok=True)
+timeout_seconds = int("$PROCESS_PENDING_TIMEOUT_SECONDS")
+now = datetime.now()
+
+bad_reason_tokens = (
+    "ReqNodeNotAvail",
+    "UnavailableNodes",
+    "NodeDown",
+    "PartitionDown",
+    "PartitionInactive",
+    "ReservationDeleted",
+)
+timed_pending_reasons = ("Priority", "Resources", "QOS")
+
+squeue_rows = {}
+try:
+    proc = subprocess.run(
+        ["squeue", "-h", "-u", "$USER", "-n", "dwpose", "-o", "%i|%T|%R"],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    for line in proc.stdout.splitlines():
+        if not line.strip() or "|" not in line:
+            continue
+        job_key, state, reason = line.split("|", 2)
+        squeue_rows[job_key.strip()] = (state.strip().upper(), reason.strip())
+except Exception:
+    squeue_rows = {}
+
+cancelled_jobs = set()
+removed_claims = 0
+
+for claim_path in claim_dir.glob("*.claim"):
+    try:
+        lines = claim_path.read_text(encoding="utf-8").splitlines()
+    except OSError:
+        continue
+    meta = {}
+    for line in lines:
+        if "=" in line:
+            k, v = line.split("=", 1)
+            meta[k.strip()] = v.strip()
+    job_id = meta.get("job_id", "")
+    task_id = meta.get("task_id", "")
+    job_key = meta.get("job_key", "") or (f"{job_id}_{task_id}" if job_id and task_id else "")
+    submitted_at = meta.get("submitted_at", "")
+    if not job_key:
+        claim_path.unlink(missing_ok=True)
+        removed_claims += 1
+        continue
+    row = squeue_rows.get(job_key)
+    if not row:
+        claim_path.unlink(missing_ok=True)
+        removed_claims += 1
+        continue
+    state, reason = row
+    should_cancel = False
+    if state == "PENDING":
+        if any(tok in reason for tok in bad_reason_tokens):
+            should_cancel = True
+        elif submitted_at:
+            try:
+                submitted_dt = datetime.strptime(submitted_at, "%Y-%m-%d %H:%M:%S")
+                if (now - submitted_dt) > timedelta(seconds=timeout_seconds):
+                    if any(tok in reason for tok in timed_pending_reasons) or not reason:
+                        should_cancel = True
+            except Exception:
+                pass
+    if should_cancel:
+        subprocess.run(["scancel", job_id], check=False)
+        cancelled_jobs.add(job_id)
+        claim_path.unlink(missing_ok=True)
+        removed_claims += 1
+
+print(f"{len(cancelled_jobs)}|{removed_claims}")
+PY
+}
+
+
+cleanup_orphan_pending_process_jobs() {
+  python - <<PY
+import subprocess
+from datetime import datetime, timedelta
+
+bad_reason_tokens = (
+    "ReqNodeNotAvail",
+    "UnavailableNodes",
+    "NodeDown",
+    "PartitionDown",
+    "PartitionInactive",
+    "ReservationDeleted",
+)
+timed_pending_reasons = ("Priority", "Resources", "QOS")
+timeout_seconds = int("$PROCESS_PENDING_TIMEOUT_SECONDS")
+now = datetime.now()
+
+cancelled = set()
+try:
+    proc = subprocess.run(
+        ["squeue", "-h", "-u", "$USER", "-n", "dwpose", "-o", "%A|%T|%R|%V"],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    for line in proc.stdout.splitlines():
+        if not line.strip() or "|" not in line:
+            continue
+        job_id, state, reason, submit_time = line.split("|", 3)
+        state = state.strip().upper()
+        reason = reason.strip()
+        if state != "PENDING":
+            continue
+        should_cancel = False
+        if any(tok in reason for tok in bad_reason_tokens):
+            should_cancel = True
+        elif any(tok in reason for tok in timed_pending_reasons):
+            submit_time = submit_time.strip()
+            if submit_time and submit_time != "N/A":
+                try:
+                    submitted_dt = datetime.strptime(submit_time, "%Y-%m-%dT%H:%M:%S")
+                    if (now - submitted_dt) > timedelta(seconds=timeout_seconds):
+                        should_cancel = True
+                except Exception:
+                    pass
+        if should_cancel:
+            subprocess.run(["scancel", job_id.strip()], check=False)
+            cancelled.add(job_id.strip())
+except Exception:
+    pass
+print(len(cancelled))
+PY
+}
+
 count_complete_pending_upload() {
   python - <<PY
 import json
@@ -758,22 +1126,52 @@ download_loop() {
   local iteration=0
   while true; do
     iteration=$((iteration + 1))
-    local pruned stale_download_claims
-    pruned="$(prune_processed_raw_videos)"
-    stale_download_claims="$(cleanup_stale_download_claims)"
+    local pruned stale_download_claims stale_download_partials stale_process_result stale_process_jobs stale_process_claims stale_orphan_process_jobs
+    pruned="$(prune_processed_raw_videos 2>/dev/null || true)"
+    [[ "$pruned" =~ ^[0-9]+$ ]] || pruned=0
+    stale_download_claims="$(cleanup_stale_download_claims 2>/dev/null || true)"
+    [[ "$stale_download_claims" =~ ^[0-9]+$ ]] || stale_download_claims=0
+    stale_download_partials="$(cleanup_stale_download_partials 2>/dev/null || true)"
+    [[ "$stale_download_partials" =~ ^[0-9]+$ ]] || stale_download_partials=0
+    stale_process_result="$(cleanup_stale_process_jobs 2>/dev/null || true)"
+    IFS="|" read -r stale_process_jobs stale_process_claims <<< "$stale_process_result"
+    [[ "$stale_process_jobs" =~ ^[0-9]+$ ]] || stale_process_jobs=0
+    [[ "$stale_process_claims" =~ ^[0-9]+$ ]] || stale_process_claims=0
+    stale_orphan_process_jobs="$(cleanup_orphan_pending_process_jobs 2>/dev/null || true)"
+    [[ "$stale_orphan_process_jobs" =~ ^[0-9]+$ ]] || stale_orphan_process_jobs=0
     local pending_download pending_process raw_video_bytes
-    pending_download="$(count_pending_downloads)"
-    pending_process="$(count_pending_process)"
-    raw_video_bytes="$(dir_size_bytes "$RAW_VIDEO_DIR")"
-    echo "[download] iteration=$iteration pending_download=$pending_download raw_backlog=$pending_process raw_video_bytes=$raw_video_bytes pruned_raw_videos=$pruned stale_download_claims=$stale_download_claims"
+    pending_download="$(count_pending_downloads 2>/dev/null || true)"
+    [[ "$pending_download" =~ ^[0-9]+$ ]] || pending_download=0
+    pending_process="$(count_pending_process 2>/dev/null || true)"
+    [[ "$pending_process" =~ ^[0-9]+$ ]] || pending_process=0
+    raw_video_bytes="$(dir_size_bytes "$RAW_VIDEO_DIR" 2>/dev/null || true)"
+    [[ "$raw_video_bytes" =~ ^[0-9]+$ ]] || raw_video_bytes=0
+    echo "[download] iteration=$iteration pending_download=$pending_download raw_backlog=$pending_process raw_video_bytes=$raw_video_bytes pruned_raw_videos=$pruned stale_download_claims=$stale_download_claims stale_download_partials=$stale_download_partials stale_process_jobs=$stale_process_jobs stale_process_claims=$stale_process_claims stale_orphan_process_jobs=$stale_orphan_process_jobs"
 
     if [[ "$MAX_ITERATIONS" -gt 0 && "$iteration" -gt "$MAX_ITERATIONS" ]]; then
       echo "[download] reached max iterations: $MAX_ITERATIONS"
       break
     fi
     if [[ "$pending_download" -eq 0 ]]; then
-      echo "[download] nothing left to download"
-      break
+      run_sync_csv_stage >/dev/null 2>&1 || true
+      pending_download="$(count_pending_downloads 2>/dev/null || true)"
+      [[ "$pending_download" =~ ^[0-9]+$ ]] || pending_download=0
+      if [[ "$pending_download" -eq 0 ]]; then
+        local stop_guard source_rows terminal_rows uploaded_rows live_download_jobs
+        stop_guard="$(count_download_stop_guard 2>/dev/null || true)"
+        IFS="|" read -r source_rows terminal_rows uploaded_rows live_download_jobs <<< "$stop_guard"
+        [[ "$source_rows" =~ ^[0-9]+$ ]] || source_rows=0
+        [[ "$terminal_rows" =~ ^[0-9]+$ ]] || terminal_rows=0
+        [[ "$uploaded_rows" =~ ^[0-9]+$ ]] || uploaded_rows=0
+        [[ "$live_download_jobs" =~ ^[0-9]+$ ]] || live_download_jobs=0
+        if [[ "$live_download_jobs" -gt 0 || "$terminal_rows" -lt "$source_rows" ]]; then
+          echo "[download] stop guard blocked exit: pending_download=$pending_download source_rows=$source_rows terminal_rows=$terminal_rows uploaded_rows=$uploaded_rows live_download_jobs=$live_download_jobs"
+          sleep "$IDLE_SLEEP_SECONDS"
+          continue
+        fi
+        echo "[download] nothing left to download"
+        break
+      fi
     fi
     if [[ "$pending_process" -ge "$RAW_BACKLOG_LIMIT" ]]; then
       echo "[download] backpressure: raw backlog $pending_process >= limit $RAW_BACKLOG_LIMIT"
@@ -789,6 +1187,21 @@ download_loop() {
     if ! run_download_stage "$DOWNLOAD_BATCH_SIZE"; then
       echo "[download] pipeline01 failed; retry after sleep"
       sleep "$IDLE_SLEEP_SECONDS"
+    else
+      run_sync_csv_stage >/dev/null 2>&1 || true
+    fi
+
+    pending_process="$(count_pending_process 2>/dev/null || true)"
+    [[ "$pending_process" =~ ^[0-9]+$ ]] || pending_process=0
+    local active_process_claims
+    active_process_claims="$(count_active_process_claims 2>/dev/null || true)"
+    [[ "$active_process_claims" =~ ^[0-9]+$ ]] || active_process_claims=0
+    if [[ "$pending_process" -ge "$MIN_PROCESS_START_BACKLOG" && "$active_process_claims" -eq 0 ]]; then
+      if ! run_process_stage "$PROCESS_BATCH_SIZE"; then
+        echo "[download] fallback process submit failed"
+      else
+        echo "[download] fallback process submit succeeded count=$RUN_PROCESS_STAGE_SUBMITTED_COUNT"
+      fi
     fi
   done
 }
@@ -796,15 +1209,26 @@ download_loop() {
 process_loop() {
   local iteration=0
   local submitted_total=0
+  echo "[process] loop started"
   while true; do
     iteration=$((iteration + 1))
-    local pruned
-    pruned="$(prune_processed_raw_videos)"
+    local pruned stale_process_result stale_process_jobs stale_process_claims stale_orphan_process_jobs
+    pruned="$(prune_processed_raw_videos 2>/dev/null || true)"
+    [[ "$pruned" =~ ^[0-9]+$ ]] || pruned=0
+    stale_process_result="$(cleanup_stale_process_jobs 2>/dev/null || true)"
+    IFS="|" read -r stale_process_jobs stale_process_claims <<< "$stale_process_result"
+    [[ "$stale_process_jobs" =~ ^[0-9]+$ ]] || stale_process_jobs=0
+    [[ "$stale_process_claims" =~ ^[0-9]+$ ]] || stale_process_claims=0
+    stale_orphan_process_jobs="$(cleanup_orphan_pending_process_jobs 2>/dev/null || true)"
+    [[ "$stale_orphan_process_jobs" =~ ^[0-9]+$ ]] || stale_orphan_process_jobs=0
     local pending_download pending_process active_process_claims remaining_limit cycle_limit
-    pending_download="$(count_pending_downloads)"
-    pending_process="$(count_pending_process)"
-    active_process_claims="$(count_active_process_claims)"
-    echo "[process] iteration=$iteration pending_download=$pending_download raw_backlog=$pending_process slurm_backlog=$active_process_claims submitted_total=$submitted_total pruned_raw_videos=$pruned"
+    pending_download="$(count_pending_downloads 2>/dev/null || true)"
+    [[ "$pending_download" =~ ^[0-9]+$ ]] || pending_download=0
+    pending_process="$(count_pending_process 2>/dev/null || true)"
+    [[ "$pending_process" =~ ^[0-9]+$ ]] || pending_process=0
+    active_process_claims="$(count_active_process_claims 2>/dev/null || true)"
+    [[ "$active_process_claims" =~ ^[0-9]+$ ]] || active_process_claims=0
+    echo "[process] iteration=$iteration pending_download=$pending_download raw_backlog=$pending_process slurm_backlog=$active_process_claims submitted_total=$submitted_total pruned_raw_videos=$pruned stale_process_jobs=$stale_process_jobs stale_process_claims=$stale_process_claims stale_orphan_process_jobs=$stale_orphan_process_jobs"
 
     if [[ "$MAX_ITERATIONS" -gt 0 && "$iteration" -gt "$MAX_ITERATIONS" ]]; then
       echo "[process] reached max iterations: $MAX_ITERATIONS"
@@ -853,6 +1277,7 @@ process_loop() {
       sleep "$IDLE_SLEEP_SECONDS"
     else
       submitted_total=$((submitted_total + RUN_PROCESS_STAGE_SUBMITTED_COUNT))
+      run_sync_csv_stage >/dev/null 2>&1 || true
     fi
     sleep "$IDLE_SLEEP_SECONDS"
   done
@@ -896,6 +1321,8 @@ upload_loop() {
     if ! run_upload_stage "$require_target"; then
       echo "[upload] pipeline03 failed; retry after sleep"
       sleep "$IDLE_SLEEP_SECONDS"
+    else
+      run_sync_csv_stage >/dev/null 2>&1 || true
     fi
   done
 }

scripts/benchmark_pipeline02_stream_vs_jpg.sh

@@ -0,0 +1,95 @@
+#!/usr/bin/env bash
+#SBATCH --job-name=dwpose-bench
+#SBATCH --nodes=1
+#SBATCH --ntasks=1
+#SBATCH --cpus-per-task=8
+#SBATCH --gres=gpu:1
+#SBATCH --mem=32G
+#SBATCH --time=02:00:00
+#SBATCH --output=/home/sf895/Sign-DWPose-2M-runtime/slurm/logs/dwpose_bench_%j.out
+#SBATCH --error=/home/sf895/Sign-DWPose-2M-runtime/slurm/logs/dwpose_bench_%j.err
+
+set -euo pipefail
+
+ROOT_DIR="/cache/home/sf895/Sign-DWPose-2M"
+RUNTIME_ROOT="/home/sf895/Sign-DWPose-2M-runtime"
+CONDA_SH="/home/sf895/miniconda3/etc/profile.d/conda.sh"
+CONDA_ENV="dwpose"
+VIDEO_ID="${1:?video id required}"
+FPS="${FPS:-24}"
+RAW_VIDEO_DIR="$RUNTIME_ROOT/raw_video"
+BENCH_ROOT="$RUNTIME_ROOT/bench_pipeline02/$VIDEO_ID"
+OLD_DATASET_DIR="$BENCH_ROOT/jpg_spill"
+NEW_DATASET_DIR="$BENCH_ROOT/stream"
+OLD_STATS="$BENCH_ROOT/stats_old.npz"
+NEW_STATS="$BENCH_ROOT/stats_new.npz"
+TMP_ROOT="${SLURM_TMPDIR:-/tmp}"
+VIDEO_PATH=""
+for ext in mp4 mkv webm mov; do
+  candidate="$RAW_VIDEO_DIR/$VIDEO_ID.$ext"
+  if [[ -f "$candidate" ]]; then
+    VIDEO_PATH="$candidate"
+    break
+  fi
+done
+if [[ -z "$VIDEO_PATH" ]]; then
+  echo "Video not found for $VIDEO_ID" >&2
+  exit 1
+fi
+
+mkdir -p "$BENCH_ROOT"
+rm -rf "$OLD_DATASET_DIR" "$NEW_DATASET_DIR"
+rm -f "$OLD_STATS" "$NEW_STATS"
+
+echo "video_id=$VIDEO_ID"
+echo "video_path=$VIDEO_PATH"
+echo "hostname=$(hostname)"
+echo "cuda_visible_devices=${CUDA_VISIBLE_DEVICES:-unset}"
+echo "fps=$FPS"
+echo "tmp_root=$TMP_ROOT"
+
+source "$CONDA_SH"
+
+run_case() {
+  local mode="$1"
+  local dataset_dir="$2"
+  local stats_path="$3"
+  shift 3
+  local start end elapsed
+  start=$(python3 - <<'PY'
+import time
+print(time.perf_counter())
+PY
+)
+  conda run -n "$CONDA_ENV" python -u "$ROOT_DIR/scripts/pipeline02_extract_dwpose_from_video.py" \
+    --raw-video-dir "$RAW_VIDEO_DIR" \
+    --dataset-dir "$dataset_dir" \
+    --stats-npz "$stats_path" \
+    --fps "$FPS" \
+    --workers 1 \
+    --video-ids="$VIDEO_ID" \
+    --force \
+    --tmp-root "$TMP_ROOT" \
+    "$@"
+  end=$(python3 - <<'PY'
+import time
+print(time.perf_counter())
+PY
+)
+  elapsed=$(python3 - <<PY
+start = float("$start")
+end = float("$end")
+print(f"{end-start:.3f}")
+PY
+)
+  local poses_npz="$dataset_dir/$VIDEO_ID/npz/poses.npz"
+  local complete_marker="$dataset_dir/$VIDEO_ID/npz/.complete"
+  local size_bytes=0
+  if [[ -f "$poses_npz" ]]; then
+    size_bytes=$(stat -c %s "$poses_npz")
+  fi
+  echo "benchmark_result mode=$mode elapsed_seconds=$elapsed poses_npz_bytes=$size_bytes complete=$([[ -f "$complete_marker" ]] && echo yes || echo no)"
+}
+
+run_case jpg_spill "$OLD_DATASET_DIR" "$OLD_STATS" --spill-jpg-frames
+run_case stream "$NEW_DATASET_DIR" "$NEW_STATS"

scripts/pipeline02_extract_dwpose_from_video.py

@@ -8,11 +8,20 @@ import sys
 import tempfile
 import time
 from pathlib import Path
-from typing import Dict, List, Sequence
+from typing import Dict, Iterator, List, Sequence, Tuple
 
 import numpy as np
+import onnxruntime as ort
 import torch
+import torch.nn.functional as F
+import torchvision.ops as tv_ops
 from easy_dwpose import DWposeDetector
+from easy_dwpose.body_estimation import resize_image
+from easy_dwpose.body_estimation.detector import inference_detector, preprocess as detector_preprocess, demo_postprocess as detector_demo_postprocess
+from easy_dwpose.body_estimation.pose import (
+    postprocess as pose_postprocess,
+    preprocess as pose_preprocess,
+)
 from PIL import Image
 
 
@@ -30,6 +39,55 @@ VIDEO_EXTENSIONS = {".mp4", ".mkv", ".webm", ".mov"}
 COMPLETE_MARKER_NAME = ".complete"
 
 
+def build_optimized_providers(device: str, optimized_provider: str, cache_dir: Path):
+    device = str(device)
+    gpu_id = 0
+    if ":" in device:
+        gpu_id = int(device.split(":", 1)[1])
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    if optimized_provider == "tensorrt":
+        providers = ["TensorrtExecutionProvider", "CUDAExecutionProvider", "CPUExecutionProvider"]
+        provider_options = [
+            {
+                "device_id": str(gpu_id),
+                "trt_engine_cache_enable": "1",
+                "trt_engine_cache_path": str(cache_dir),
+                "trt_timing_cache_enable": "1",
+                "trt_fp16_enable": "1",
+            },
+            {"device_id": str(gpu_id)},
+            {},
+        ]
+    elif optimized_provider == "cuda":
+        providers = ["CUDAExecutionProvider", "CPUExecutionProvider"]
+        provider_options = [
+            {"device_id": str(gpu_id)},
+            {},
+        ]
+    else:
+        providers = ["CPUExecutionProvider"]
+        provider_options = [{}]
+    return providers, provider_options
+
+
+def create_detector(device: str, optimized_mode: bool, optimized_provider: str, tmp_root: Path) -> DWposeDetector:
+    detector = DWposeDetector(device=device)
+    if not optimized_mode:
+        return detector
+    providers, provider_options = build_optimized_providers(device, optimized_provider, tmp_root / "ort_trt_cache")
+    detector.pose_estimation.session_det = ort.InferenceSession(
+        "checkpoints/yolox_l.onnx",
+        providers=providers,
+        provider_options=provider_options,
+    )
+    detector.pose_estimation.session_pose = ort.InferenceSession(
+        "checkpoints/dw-ll_ucoco_384.onnx",
+        providers=providers,
+        provider_options=provider_options,
+    )
+    return detector
+
+
 def parse_args() -> argparse.Namespace:
     parser = argparse.ArgumentParser(
         description="Extract DWpose NPZ files from raw videos."
@@ -57,6 +115,71 @@ def parse_args() -> argparse.Namespace:
         action="store_false",
         help="Save one NPZ file per frame under the npz directory.",
     )
+    parser.add_argument(
+        "--stream-frames",
+        dest="stream_frames",
+        action="store_true",
+        default=True,
+        help="Decode frames directly from ffmpeg stdout without JPG spill (default).",
+    )
+    parser.add_argument(
+        "--spill-jpg-frames",
+        dest="stream_frames",
+        action="store_false",
+        help="Use legacy ffmpeg-to-JPG spill path for comparison/debugging.",
+    )
+    parser.add_argument(
+        "--optimized-mode",
+        dest="optimized_mode",
+        action="store_true",
+        default=True,
+        help="Enable optimized ndarray + batched pose inference path (default).",
+    )
+    parser.add_argument(
+        "--legacy-mode",
+        dest="optimized_mode",
+        action="store_false",
+        help="Disable optimized path and use legacy per-frame single-image inference.",
+    )
+    parser.add_argument(
+        "--optimized-frame-batch-size",
+        type=int,
+        default=8,
+        help="Frame micro-batch size for optimized pose inference.",
+    )
+    parser.add_argument(
+        "--optimized-detect-resolution",
+        type=int,
+        default=512,
+        help="Detect resolution used only in optimized mode.",
+    )
+    parser.add_argument(
+        "--optimized-frame-stride",
+        type=int,
+        default=1,
+        help="Process every Nth decoded frame in optimized mode.",
+    )
+    parser.add_argument(
+        "--optimized-provider",
+        choices=("tensorrt", "cuda", "cpu"),
+        default="cuda",
+        help="Execution provider used only in optimized mode.",
+    )
+    parser.add_argument(
+        "--optimized-gpu-pose-preprocess",
+        action="store_true",
+        help="Experimental: move pose crop affine/normalize to GPU in optimized mode.",
+    )
+    parser.add_argument(
+        "--optimized-gpu-detector-postprocess",
+        action="store_true",
+        help="Experimental: run detector postprocess and NMS on GPU in optimized mode.",
+    )
+    parser.add_argument(
+        "--optimized-io-binding",
+        action="store_true",
+        help="Experimental: use ONNX Runtime IO binding in optimized mode.",
+    )
     return parser.parse_args()
 
 
@@ -88,7 +211,7 @@ def select_video_paths(args: argparse.Namespace) -> List[Path]:
     return selected
 
 
-def extract_frames(video_path: Path, frame_dir: Path, fps: int) -> None:
+def extract_frames_to_jpg(video_path: Path, frame_dir: Path, fps: int) -> None:
     command = [
         "ffmpeg",
         "-hide_banner",
@@ -104,6 +227,71 @@ def extract_frames(video_path: Path, frame_dir: Path, fps: int) -> None:
     subprocess.run(command, check=True)
 
 
+def probe_video_dimensions(video_path: Path) -> Tuple[int, int]:
+    command = [
+        "ffprobe",
+        "-v",
+        "error",
+        "-select_streams",
+        "v:0",
+        "-show_entries",
+        "stream=width,height",
+        "-of",
+        "csv=p=0:s=x",
+        str(video_path),
+    ]
+    proc = subprocess.run(command, check=True, capture_output=True, text=True)
+    dims = (proc.stdout or "").strip()
+    if "x" not in dims:
+        raise RuntimeError(f"Unable to parse ffprobe dimensions for {video_path.name}: {dims!r}")
+    width_s, height_s = dims.split("x", 1)
+    return int(width_s), int(height_s)
+
+
+def iter_streamed_frames(video_path: Path, fps: int) -> Iterator[Tuple[int, np.ndarray, int, int]]:
+    width, height = probe_video_dimensions(video_path)
+    frame_bytes = width * height * 3
+    command = [
+        "ffmpeg",
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-i",
+        str(video_path),
+        "-vf",
+        f"fps={fps}",
+        "-f",
+        "rawvideo",
+        "-pix_fmt",
+        "rgb24",
+        "pipe:1",
+    ]
+    proc = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    assert proc.stdout is not None
+    try:
+        frame_index = 0
+        while True:
+            chunk = proc.stdout.read(frame_bytes)
+            if not chunk:
+                break
+            if len(chunk) != frame_bytes:
+                raise RuntimeError(
+                    f"Short raw frame read for {video_path.name}: expected {frame_bytes} bytes, got {len(chunk)}"
+                )
+            frame_index += 1
+            frame_array = np.frombuffer(chunk, dtype=np.uint8).reshape((height, width, 3))
+            yield frame_index, frame_array, width, height
+    finally:
+        if proc.stdout:
+            proc.stdout.close()
+        stderr = proc.stderr.read().decode("utf-8", errors="replace") if proc.stderr else ""
+        if proc.stderr:
+            proc.stderr.close()
+        returncode = proc.wait()
+        if returncode != 0:
+            raise RuntimeError(f"ffmpeg raw frame stream failed for {video_path.name}: {stderr.strip()}")
+
+
 def build_npz_payload(pose_data: Dict[str, np.ndarray], width: int, height: int) -> Dict[str, np.ndarray]:
     num_persons = int(pose_data["faces"].shape[0]) if "faces" in pose_data else 0
     payload: Dict[str, np.ndarray] = {
@@ -114,12 +302,12 @@ def build_npz_payload(pose_data: Dict[str, np.ndarray], width: int, height: int)
     if num_persons == 0:
         return payload
 
-    bodies = pose_data["bodies"].reshape(num_persons, 18, 2).astype(np.float32)
-    body_scores = pose_data["body_scores"].astype(np.float32)
-    faces = pose_data["faces"].astype(np.float32)
-    face_scores = pose_data["faces_scores"].astype(np.float32)
-    hands = pose_data["hands"].astype(np.float32)
-    hand_scores = pose_data["hands_scores"].astype(np.float32)
+    bodies = pose_data["bodies"].reshape(num_persons, 18, 2).astype(np.float32, copy=False)
+    body_scores = pose_data["body_scores"].astype(np.float32, copy=False)
+    faces = pose_data["faces"].astype(np.float32, copy=False)
+    face_scores = pose_data["faces_scores"].astype(np.float32, copy=False)
+    hands = pose_data["hands"].astype(np.float32, copy=False)
+    hand_scores = pose_data["hands_scores"].astype(np.float32, copy=False)
 
     for person_idx in range(num_persons):
         prefix = f"person_{person_idx:03d}"
@@ -138,6 +326,243 @@ def build_npz_payload(pose_data: Dict[str, np.ndarray], width: int, height: int)
     return payload
 
 
+def run_session_outputs(
+    session: ort.InferenceSession,
+    input_array: np.ndarray,
+    use_io_binding: bool,
+    device_id: int,
+):
+    input_name = session.get_inputs()[0].name
+    output_names = [out.name for out in session.get_outputs()]
+    if not use_io_binding:
+        return session.run(output_names, {input_name: input_array})
+    io_binding = session.io_binding()
+    io_binding.bind_cpu_input(input_name, input_array)
+    for output_name in output_names:
+        io_binding.bind_output(output_name, device_type="cuda", device_id=device_id)
+    session.run_with_iobinding(io_binding)
+    return io_binding.copy_outputs_to_cpu()
+
+
+def inference_detector_gpu_postprocess(
+    session: ort.InferenceSession,
+    ori_img: np.ndarray,
+    device: torch.device,
+    use_io_binding: bool,
+    device_id: int,
+) -> np.ndarray:
+    input_shape = (640, 640)
+    img, ratio = detector_preprocess(ori_img, input_shape)
+    outputs = run_session_outputs(session, img[None, :, :, :], use_io_binding, device_id)
+    predictions = detector_demo_postprocess(outputs[0], input_shape)[0]
+    pred = torch.from_numpy(np.ascontiguousarray(predictions)).to(device=device, dtype=torch.float32)
+    boxes = pred[:, :4]
+    score_obj = pred[:, 4]
+    cls_scores = pred[:, 5:]
+    if cls_scores.ndim == 1:
+        cls_scores = cls_scores.unsqueeze(1)
+    cls0 = score_obj * cls_scores[:, 0]
+    mask = cls0 > 0.1
+    if not torch.any(mask):
+        return np.array([])
+    boxes = boxes[mask]
+    cls0 = cls0[mask]
+    boxes_xyxy = torch.empty_like(boxes)
+    boxes_xyxy[:, 0] = boxes[:, 0] - boxes[:, 2] / 2.0
+    boxes_xyxy[:, 1] = boxes[:, 1] - boxes[:, 3] / 2.0
+    boxes_xyxy[:, 2] = boxes[:, 0] + boxes[:, 2] / 2.0
+    boxes_xyxy[:, 3] = boxes[:, 1] + boxes[:, 3] / 2.0
+    boxes_xyxy /= ratio
+    keep = tv_ops.nms(boxes_xyxy, cls0, 0.45)
+    if keep.numel() == 0:
+        return np.array([])
+    final_boxes = boxes_xyxy[keep]
+    final_scores = cls0[keep]
+    final_boxes = final_boxes[final_scores > 0.3]
+    if final_boxes.numel() == 0:
+        return np.array([])
+    return final_boxes.detach().cpu().numpy()
+
+
+def optimized_detector_call(
+    detector: DWposeDetector,
+    frame: np.ndarray,
+    detect_resolution: int,
+    include_hands: bool = True,
+    include_face: bool = True,
+) -> Dict[str, np.ndarray]:
+    del include_hands, include_face
+    return optimized_process_frame_batch(detector, [(1, frame, 0, 0)], detect_resolution)[0][1]
+
+
+def empty_pose_payload() -> Dict[str, np.ndarray]:
+    empty_f = np.zeros((0,), dtype=np.float32)
+    return {
+        "bodies": empty_f.reshape(0, 2),
+        "body_scores": empty_f.reshape(0, 18),
+        "hands": empty_f.reshape(0, 21, 2),
+        "hands_scores": empty_f.reshape(0, 21),
+        "faces": empty_f.reshape(0, 68, 2),
+        "faces_scores": empty_f.reshape(0, 68),
+    }
+
+
+def format_pose_output(
+    detector: DWposeDetector,
+    keypoints: np.ndarray,
+    scores: np.ndarray,
+    width: int,
+    height: int,
+) -> Dict[str, np.ndarray]:
+    keypoints_info = np.concatenate((keypoints, scores[..., None]), axis=-1)
+    neck = np.mean(keypoints_info[:, [5, 6]], axis=1)
+    neck[:, 2:4] = np.logical_and(
+        keypoints_info[:, 5, 2:4] > 0.3,
+        keypoints_info[:, 6, 2:4] > 0.3,
+    ).astype(int)
+    new_keypoints_info = np.insert(keypoints_info, 17, neck, axis=1)
+    mmpose_idx = [17, 6, 8, 10, 7, 9, 12, 14, 16, 13, 15, 2, 1, 4, 3]
+    openpose_idx = [1, 2, 3, 4, 6, 7, 8, 9, 10, 12, 13, 14, 15, 16, 17]
+    new_keypoints_info[:, openpose_idx] = new_keypoints_info[:, mmpose_idx]
+    keypoints_info = new_keypoints_info
+
+    keypoints = keypoints_info[..., :2]
+    scores = keypoints_info[..., 2]
+    return detector._format_pose(keypoints, scores, width, height)
+
+
+def prepare_optimized_frame(
+    detector: DWposeDetector,
+    frame: np.ndarray,
+    detect_resolution: int,
+) -> Tuple[np.ndarray, np.ndarray, int, int]:
+    image = frame
+    if not isinstance(image, np.ndarray):
+        image = np.asarray(image.convert("RGB"))
+    image = resize_image(np.ascontiguousarray(image), target_resolution=detect_resolution)
+    height, width = image.shape[:2]
+    if getattr(detector, "_optimized_gpu_detector_postprocess", False):
+        det_result = inference_detector_gpu_postprocess(
+            detector.pose_estimation.session_det,
+            image,
+            detector._optimized_torch_device,
+            getattr(detector, "_optimized_io_binding", False),
+            getattr(detector, "_optimized_device_id", 0),
+        )
+    else:
+        det_result = inference_detector(detector.pose_estimation.session_det, image)
+    return image, det_result, width, height
+
+
+def gpu_pose_preprocess(
+    image: np.ndarray,
+    out_bbox: np.ndarray,
+    input_size: Tuple[int, int],
+    device: torch.device,
+) -> Tuple[np.ndarray, List[np.ndarray], List[np.ndarray]]:
+    if len(out_bbox) == 0:
+        return np.empty((0, 3, input_size[1], input_size[0]), dtype=np.float32), [], []
+    img_t = torch.from_numpy(np.ascontiguousarray(image)).to(device=device, dtype=torch.float32)
+    img_t = img_t.permute(2, 0, 1).unsqueeze(0)
+    H, W = image.shape[:2]
+    out_w, out_h = input_size
+    boxes = np.asarray(out_bbox, dtype=np.float32)
+    x0 = boxes[:, 0]
+    y0 = boxes[:, 1]
+    x1 = boxes[:, 2]
+    y1 = boxes[:, 3]
+    centers = np.stack([(x0 + x1) * 0.5, (y0 + y1) * 0.5], axis=1).astype(np.float32)
+    scales = np.stack([(x1 - x0) * 1.25, (y1 - y0) * 1.25], axis=1).astype(np.float32)
+    aspect = out_w / out_h
+    w = scales[:, 0:1]
+    h = scales[:, 1:2]
+    scales = np.where(w > h * aspect, np.concatenate([w, w / aspect], axis=1), np.concatenate([h * aspect, h], axis=1)).astype(np.float32)
+    centers_t = torch.from_numpy(centers).to(device=device, dtype=torch.float32)
+    scales_t = torch.from_numpy(scales).to(device=device, dtype=torch.float32)
+    theta = torch.zeros((len(boxes), 2, 3), device=device, dtype=torch.float32)
+    theta[:, 0, 0] = scales_t[:, 0] / max(W - 1, 1)
+    theta[:, 1, 1] = scales_t[:, 1] / max(H - 1, 1)
+    theta[:, 0, 2] = 2.0 * centers_t[:, 0] / max(W - 1, 1) - 1.0
+    theta[:, 1, 2] = 2.0 * centers_t[:, 1] / max(H - 1, 1) - 1.0
+    grid = F.affine_grid(theta, size=(len(boxes), 3, out_h, out_w), align_corners=True)
+    crops = F.grid_sample(img_t.expand(len(boxes), -1, -1, -1), grid, mode='bilinear', padding_mode='zeros', align_corners=True)
+    mean = torch.tensor([123.675, 116.28, 103.53], device=device, dtype=torch.float32).view(1, 3, 1, 1)
+    std = torch.tensor([58.395, 57.12, 57.375], device=device, dtype=torch.float32).view(1, 3, 1, 1)
+    crops = (crops - mean) / std
+    return crops.detach().cpu().numpy(), [c for c in centers], [s for s in scales]
+
+
+def optimized_process_frame_batch(
+    detector: DWposeDetector,
+    frames: Sequence[Tuple[int, np.ndarray, int, int]],
+    detect_resolution: int,
+) -> List[Tuple[int, Dict[str, np.ndarray], int, int]]:
+    session_pose = detector.pose_estimation.session_pose
+    model_input = session_pose.get_inputs()[0].shape
+    model_input_size = (model_input[3], model_input[2])
+
+    prepared = []
+    pose_inputs = []
+    all_centers = []
+    all_scales = []
+
+    for frame_index, frame, width, height in frames:
+        input_image, det_result, input_width, input_height = prepare_optimized_frame(detector, frame, detect_resolution)
+        if len(det_result) == 0:
+            prepared.append((frame_index, empty_pose_payload(), width, height, 0, input_width, input_height))
+            continue
+        torch_device = getattr(detector, "_optimized_torch_device", None)
+        if torch_device is not None:
+            batch_imgs, centers, scales = gpu_pose_preprocess(input_image, det_result, model_input_size, torch_device)
+            count = int(batch_imgs.shape[0])
+            prepared.append((frame_index, None, width, height, count, input_width, input_height))
+            if count:
+                pose_inputs.extend(list(batch_imgs))
+                all_centers.extend(centers)
+                all_scales.extend(scales)
+            continue
+        resized_imgs, centers, scales = pose_preprocess(input_image, det_result, model_input_size)
+        count = len(resized_imgs)
+        prepared.append((frame_index, None, width, height, count, input_width, input_height))
+        pose_inputs.extend([img.transpose(2, 0, 1) for img in resized_imgs])
+        all_centers.extend(centers)
+        all_scales.extend(scales)
+
+    if pose_inputs:
+        batch = np.stack(pose_inputs, axis=0).astype(np.float32, copy=False)
+        sess_input = {session_pose.get_inputs()[0].name: batch}
+        sess_output = [out.name for out in session_pose.get_outputs()]
+        simcc_x, simcc_y = session_pose.run(sess_output, sess_input)
+        batched_outputs = [(simcc_x[i : i + 1], simcc_y[i : i + 1]) for i in range(batch.shape[0])]
+        keypoints_all, scores_all = pose_postprocess(
+            batched_outputs,
+            model_input_size,
+            all_centers,
+            all_scales,
+        )
+    else:
+        keypoints_all = scores_all = None
+
+    results = []
+    offset = 0
+    for frame_index, pose_data, width, height, count, input_width, input_height in prepared:
+        if count == 0:
+            results.append((frame_index, pose_data, width, height))
+            continue
+        keypoints = keypoints_all[offset : offset + count]
+        scores = scores_all[offset : offset + count]
+        offset += count
+        results.append(
+            (
+                frame_index,
+                format_pose_output(detector, keypoints, scores, input_width, input_height),
+                width,
+                height,
+            )
+        )
+    return results
+
+
 def process_video(
     video_path: Path,
     dataset_dir: Path,
@@ -146,6 +571,11 @@ def process_video(
     tmp_root: Path,
     force: bool,
     single_poses_npz: bool,
+    stream_frames: bool,
+    optimized_mode: bool,
+    optimized_frame_batch_size: int,
+    optimized_detect_resolution: int,
+    optimized_frame_stride: int,
 ) -> None:
     video_id = video_path.stem
     output_npz_dir = dataset_dir / video_id / "npz"
@@ -159,24 +589,42 @@ def process_video(
         shutil.rmtree(output_npz_dir)
     output_npz_dir.mkdir(parents=True, exist_ok=True)
 
-    tmp_root.mkdir(parents=True, exist_ok=True)
-    frame_dir = Path(tempfile.mkdtemp(prefix=f"sign_dwpose_{video_id}_", dir=str(tmp_root)))
-
-    try:
-        extract_frames(video_path, frame_dir, fps)
-        frame_paths = sorted(frame_dir.glob("*.jpg"))
-        total_frames = len(frame_paths)
-        print(f"{video_id}: extracted {total_frames} frames at {fps} fps")
-
-        aggregated_payloads = []
-        frame_widths = []
-        frame_heights = []
-
-        for frame_index, frame_path in enumerate(frame_paths, start=1):
-            with Image.open(frame_path) as image:
-                frame = image.convert("RGB")
-                width, height = frame.size
-                pose_data = detector(frame, draw_pose=False, include_hands=True, include_face=True)
+    aggregated_payloads = []
+    frame_widths = []
+    frame_heights = []
+    frame_indices = []
+    total_frames = 0
+    decode_start = time.perf_counter()
+    process_start = decode_start
+
+    if stream_frames:
+        print(f"{video_id}: decoding mode=stream fps={fps} optimized={optimized_mode}")
+        frame_batch = []
+        batch_size = max(1, optimized_frame_batch_size)
+        frame_stride = max(1, optimized_frame_stride)
+        for frame_index, frame, width, height in iter_streamed_frames(video_path, fps):
+            total_frames = frame_index
+            if optimized_mode:
+                if ((frame_index - 1) % frame_stride) != 0:
+                    continue
+                frame_batch.append((frame_index, frame, width, height))
+                if len(frame_batch) < batch_size:
+                    continue
+                batch_results = optimized_process_frame_batch(detector, frame_batch, optimized_detect_resolution)
+                frame_batch = []
+                for result_index, pose_data, result_width, result_height in batch_results:
+                    payload = build_npz_payload(pose_data, result_width, result_height)
+                    if single_poses_npz:
+                        aggregated_payloads.append(payload)
+                        frame_widths.append(result_width)
+                        frame_heights.append(result_height)
+                        frame_indices.append(result_index)
+                    else:
+                        np.savez(output_npz_dir / f"{result_index:08d}.npz", **payload)
+                    if result_index == 1 or result_index % 100 == 0:
+                        print(f"{video_id}: processed {result_index} frames")
+                continue
+            pose_data = detector(frame, draw_pose=False, include_hands=True, include_face=True)
             payload = build_npz_payload(pose_data, width, height)
             if single_poses_npz:
                 aggregated_payloads.append(payload)
@@ -184,27 +632,77 @@ def process_video(
                 frame_heights.append(height)
             else:
                 np.savez(output_npz_dir / f"{frame_index:08d}.npz", **payload)
-
-            if frame_index == 1 or frame_index % 100 == 0 or frame_index == total_frames:
-                print(f"{video_id}: processed {frame_index}/{total_frames} frames")
-
-        if single_poses_npz:
-            np.savez(
-                poses_npz_path,
-                video_id=np.asarray(video_id),
-                fps=np.asarray(fps, dtype=np.int32),
-                total_frames=np.asarray(total_frames, dtype=np.int32),
-                frame_widths=np.asarray(frame_widths, dtype=np.int32),
-                frame_heights=np.asarray(frame_heights, dtype=np.int32),
-                frame_payloads=np.asarray(aggregated_payloads, dtype=object),
-            )
-
-        complete_marker.write_text(
-            f"video_id={video_id}\nfps={fps}\nframes={total_frames}\noutput_mode={'single_poses_npy' if single_poses_npz else 'per_frame_npz'}\ncompleted_at={time.strftime('%Y-%m-%d %H:%M:%S')}\n",
-            encoding="utf-8",
+            if frame_index == 1 or frame_index % 100 == 0:
+                print(f"{video_id}: processed {frame_index} frames")
+        if optimized_mode and frame_batch:
+            for result_index, pose_data, result_width, result_height in optimized_process_frame_batch(detector, frame_batch, optimized_detect_resolution):
+                payload = build_npz_payload(pose_data, result_width, result_height)
+                if single_poses_npz:
+                    aggregated_payloads.append(payload)
+                    frame_widths.append(result_width)
+                    frame_heights.append(result_height)
+                    frame_indices.append(result_index)
+                else:
+                    np.savez(output_npz_dir / f"{result_index:08d}.npz", **payload)
+                if result_index == 1 or result_index % 100 == 0:
+                    print(f"{video_id}: processed {result_index} frames")
+    else:
+        print(f"{video_id}: decoding mode=jpg-spill fps={fps} optimized={optimized_mode}")
+        tmp_root.mkdir(parents=True, exist_ok=True)
+        frame_dir = Path(tempfile.mkdtemp(prefix=f"sign_dwpose_{video_id}_", dir=str(tmp_root)))
+        try:
+            extract_frames_to_jpg(video_path, frame_dir, fps)
+            frame_paths = sorted(frame_dir.glob("*.jpg"))
+            total_frames = len(frame_paths)
+            print(f"{video_id}: extracted {total_frames} frames at {fps} fps")
+            process_start = time.perf_counter()
+            for frame_index, frame_path in enumerate(frame_paths, start=1):
+                with Image.open(frame_path) as image:
+                    frame = np.asarray(image.convert("RGB"))
+                    height, width = frame.shape[:2]
+                    if optimized_mode:
+                        pose_data = optimized_detector_call(
+                            detector,
+                            frame,
+                            optimized_detect_resolution,
+                            include_hands=True,
+                            include_face=True,
+                        )
+                    else:
+                        pose_data = detector(frame, draw_pose=False, include_hands=True, include_face=True)
+                payload = build_npz_payload(pose_data, width, height)
+                if single_poses_npz:
+                    aggregated_payloads.append(payload)
+                    frame_widths.append(width)
+                    frame_heights.append(height)
+                    frame_indices.append(frame_index)
+                    frame_indices.append(frame_index)
+                else:
+                    np.savez(output_npz_dir / f"{frame_index:08d}.npz", **payload)
+                if frame_index == 1 or frame_index % 100 == 0 or frame_index == total_frames:
+                    print(f"{video_id}: processed {frame_index}/{total_frames} frames")
+        finally:
+            shutil.rmtree(frame_dir, ignore_errors=True)
+
+    decode_process_elapsed = time.perf_counter() - decode_start
+    print(f"{video_id}: processed total_frames={total_frames} elapsed={decode_process_elapsed:.2f}s mode={'stream' if stream_frames else 'jpg-spill'} optimized={optimized_mode}")
+
+    if single_poses_npz:
+        np.savez(
+            poses_npz_path,
+            video_id=np.asarray(video_id),
+            fps=np.asarray(fps, dtype=np.int32),
+            total_frames=np.asarray(total_frames, dtype=np.int32),
+            frame_widths=np.asarray(frame_widths, dtype=np.int32),
+            frame_heights=np.asarray(frame_heights, dtype=np.int32),
+            frame_indices=np.asarray(frame_indices, dtype=np.int32),
+            frame_payloads=np.asarray(aggregated_payloads, dtype=object),
         )
-    finally:
-        shutil.rmtree(frame_dir, ignore_errors=True)
+
+    complete_marker.write_text(
+        f"video_id={video_id}\nfps={fps}\nframes={total_frames}\noutput_mode={'single_poses_npy' if single_poses_npz else 'per_frame_npz'}\ndecode_mode={'stream' if stream_frames else 'jpg-spill'}\noptimized_mode={optimized_mode}\noptimized_detect_resolution={optimized_detect_resolution}\noptimized_frame_stride={optimized_frame_stride}\ncompleted_at={time.strftime('%Y-%m-%d %H:%M:%S')}\n",
+        encoding="utf-8",
+    )
 
 
 def worker(rank: int, worker_count: int, video_paths: Sequence[Path], args: argparse.Namespace) -> None:
@@ -216,7 +714,18 @@ def worker(rank: int, worker_count: int, video_paths: Sequence[Path], args: argp
             f"CUDA device rank {rank} is unavailable; visible device_count={device_count}"
         )
     device = f"cuda:{rank}"
-    detector = DWposeDetector(device=device)
+    detector = create_detector(
+        device=device,
+        optimized_mode=args.optimized_mode,
+        optimized_provider=args.optimized_provider,
+        tmp_root=args.tmp_root,
+    )
+    if args.optimized_mode:
+        detector._optimized_device_id = int(device.split(":", 1)[1]) if ":" in device else 0
+        detector._optimized_io_binding = bool(args.optimized_io_binding)
+        detector._optimized_gpu_detector_postprocess = bool(args.optimized_gpu_detector_postprocess)
+    if args.optimized_mode and (args.optimized_gpu_pose_preprocess or args.optimized_gpu_detector_postprocess):
+        detector._optimized_torch_device = torch.device(device)
     print(f"Worker {rank}: device={device}, cuda_device_count={device_count}", flush=True)
 
     for index, video_path in enumerate(video_paths):
@@ -238,6 +747,11 @@ def worker(rank: int, worker_count: int, video_paths: Sequence[Path], args: argp
                 tmp_root=args.tmp_root,
                 force=args.force,
                 single_poses_npz=args.single_poses_npz,
+                stream_frames=args.stream_frames,
+                optimized_mode=args.optimized_mode,
+                optimized_frame_batch_size=args.optimized_frame_batch_size,
+                optimized_detect_resolution=args.optimized_detect_resolution,
+                optimized_frame_stride=args.optimized_frame_stride,
             )
             update_video_stats(
                 args.stats_npz,
@@ -284,7 +798,7 @@ def main() -> None:
             f"Requested workers={worker_count}, but only {visible_gpu_count} CUDA device(s) are visible"
         )
     worker_count = min(worker_count, len(video_paths))
-    print(f"DWpose main: visible_cuda_devices={visible_gpu_count}, worker_count={worker_count}", flush=True)
+    print(f"DWpose main: visible_cuda_devices={visible_gpu_count}, worker_count={worker_count}, stream_frames={args.stream_frames}, optimized_mode={args.optimized_mode}, optimized_frame_batch_size={args.optimized_frame_batch_size}, optimized_detect_resolution={args.optimized_detect_resolution}, optimized_frame_stride={args.optimized_frame_stride}, optimized_provider={args.optimized_provider}, optimized_gpu_pose_preprocess={args.optimized_gpu_pose_preprocess}, optimized_gpu_detector_postprocess={args.optimized_gpu_detector_postprocess}, optimized_io_binding={args.optimized_io_binding}", flush=True)
 
     if worker_count == 1:
         worker(0, 1, video_paths, args)

scripts/pipeline03_upload_to_huggingface.py

@@ -54,7 +54,8 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--repo-type", default="dataset")
     parser.add_argument("--target-bytes", type=int, default=DEFAULT_TARGET_BYTES)
     parser.add_argument("--target-folders", type=int, default=DEFAULT_TARGET_FOLDERS)
-    parser.add_argument("--require-target-bytes", action="store_true")
+    parser.add_argument("--require-target-bytes", action="store_true", default=True)
+    parser.add_argument("--allow-small-final-batch", action="store_true")
     parser.add_argument("--dry-run", action="store_true")
     parser.add_argument("--upload-mode", choices=["git-ssh", "api", "api-stream"], default=os.environ.get("HF_UPLOAD_MODE", "api"))
     parser.add_argument("--git-clone-dir", type=Path, default=DEFAULT_GIT_CLONE_DIR)
@@ -372,7 +373,11 @@ def main() -> None:
     args = parse_args()
     print(f"[pipeline03] start upload_mode={args.upload_mode} repo_id={args.repo_id}", flush=True)
     progress = load_progress(args.progress_path)
-    print(f"[pipeline03] loaded progress archives={len(progress.get("archives", {}))} uploaded_folders={len(progress.get("uploaded_folders", {}))}", flush=True)
+    print(
+        f"[pipeline03] loaded progress archives={len(progress.get('archives', {}))} "
+        f"uploaded_folders={len(progress.get('uploaded_folders', {}))}",
+        flush=True,
+    )
     resolved_token = resolve_token(args.token)
     print(f"[pipeline03] token_present={bool(resolved_token)}", flush=True)
     api = HfApi(token=resolved_token) if args.upload_mode in {"api", "api-stream"} else None
@@ -380,8 +385,8 @@ def main() -> None:
 
     try:
         if args.upload_mode in {"api", "api-stream"}:
-            print("[pipeline03] listing repo files via api", flush=True)
-            repo_files = api.list_repo_files(repo_id=args.repo_id, repo_type=args.repo_type)
+            print("[pipeline03] skipping repo file listing for api mode; using local progress for archive index", flush=True)
+            repo_files = []
         else:
             print("[pipeline03] listing repo files via git", flush=True)
             repo_files = list_repo_files_via_git(args.git_clone_dir, args.repo_id, args.repo_type)
@@ -413,7 +418,8 @@ def main() -> None:
         else:
             remaining_folders = enrich_folder_sizes(remaining_folder_paths)
             remaining_bytes = total_batchable_bytes(remaining_folders)
-            if args.require_target_bytes and remaining_bytes < args.target_bytes:
+            require_target_bytes = args.require_target_bytes and not args.allow_small_final_batch
+            if require_target_bytes and remaining_bytes < args.target_bytes:
                 print(
                     f"Skip upload: only {format_size(remaining_bytes)} across {remaining_count} completed NPZ folders available, below targets {format_size(args.target_bytes)} or {args.target_folders} folders."
                 )
@@ -434,8 +440,7 @@ def main() -> None:
             break
 
         args.archive_dir.mkdir(parents=True, exist_ok=True)
-        update_many_video_stats_best_effort(
-            args.stats_npz,
+        append_status_journal(
             args.status_journal_path,
             batch_names,
             upload_status="uploading",

scripts/runtime_status.py

@@ -0,0 +1,348 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import re
+import subprocess
+from collections import Counter
+from pathlib import Path
+
+VIDEO_EXTS = {'.mp4', '.mkv', '.webm', '.mov'}
+ARRAY_RANGE_RE = re.compile(r'^(\d+)_(\[(.+)\])$')
+PROCESSED_REQUIRED_COLUMNS = {
+    'video_id',
+    'download_status',
+    'process_status',
+    'upload_status',
+    'archive_name',
+}
+
+
+def run_command(cmd: list[str]) -> str:
+    try:
+        proc = subprocess.run(cmd, check=False, capture_output=True, text=True)
+    except OSError:
+        return ''
+    return (proc.stdout or '').strip()
+
+
+def count_claims(directory: Path) -> int:
+    if not directory.exists():
+        return 0
+    return sum(1 for _ in directory.glob('*.claim'))
+
+
+def count_complete(dataset_dir: Path) -> int:
+    if not dataset_dir.exists():
+        return 0
+    return sum(1 for _ in dataset_dir.glob('*/npz/.complete'))
+
+
+def sum_file_sizes(paths: list[Path]) -> int:
+    total = 0
+    for path in paths:
+        try:
+            total += path.stat().st_size
+        except FileNotFoundError:
+            continue
+    return total
+
+
+def count_uploaded(progress_path: Path) -> tuple[int, int]:
+    if not progress_path.exists():
+        return 0, 0
+    try:
+        data = json.loads(progress_path.read_text())
+    except Exception:
+        return 0, 0
+    archives = data.get('archives', {})
+    uploaded_folders = data.get('uploaded_folders', {})
+    return len(archives), len(uploaded_folders)
+
+
+def expand_task_count(jobid_token: str) -> int:
+    m = ARRAY_RANGE_RE.match(jobid_token)
+    if not m:
+        return 1
+    body = m.group(3)
+    if '%' in body:
+        body = body.split('%', 1)[0]
+    total = 0
+    for part in body.split(','):
+        part = part.strip()
+        if not part:
+            continue
+        if '-' in part:
+            a, b = part.split('-', 1)
+            try:
+                total += int(b) - int(a) + 1
+            except ValueError:
+                total += 1
+        else:
+            total += 1
+    return max(total, 1)
+
+
+def queue_status(username: str) -> dict[str, object]:
+    output = run_command(['squeue', '-u', username, '-h', '-o', '%i|%j|%T|%P'])
+    job_counts: Counter[str] = Counter()
+    partition_counts: Counter[str] = Counter()
+    running_dwpose = 0
+    running_download = 0
+    pending_download = 0
+    if output:
+        for line in output.splitlines():
+            parts = line.split('|')
+            if len(parts) != 4:
+                continue
+            jobid_token, job, state, partition = parts
+            count = expand_task_count(jobid_token)
+            job_counts[f'{job}|{state}'] += count
+            partition_counts[f'{job}|{partition}|{state}'] += count
+            if job == 'dwpose' and state == 'RUNNING':
+                running_dwpose += count
+            if job == 'download' and state == 'RUNNING':
+                running_download += count
+            if job == 'download' and state in {'PENDING', 'CONFIGURING'}:
+                pending_download += count
+    total_download = running_download + pending_download
+    return {
+        'running_dwpose': running_dwpose,
+        'running_download': running_download,
+        'pending_download_jobs': pending_download,
+        'total_download_jobs': total_download,
+        'job_state_counts': dict(job_counts),
+        'job_partition_state_counts': dict(partition_counts),
+    }
+
+
+def filesystem_avail_bytes(path: Path) -> int:
+    try:
+        proc = subprocess.run(['df', '-B1', str(path)], check=False, capture_output=True, text=True)
+        lines = (proc.stdout or '').splitlines()
+        if len(lines) < 2:
+            return 0
+        fields = lines[1].split()
+        if len(fields) < 4:
+            return 0
+        return int(fields[3])
+    except Exception:
+        return 0
+
+
+def human_bytes(num: int) -> str:
+    value = float(num)
+    for unit in ['B', 'KB', 'MB', 'GB', 'TB', 'PB']:
+        if value < 1024.0:
+            return f'{value:.1f}{unit}'
+        value /= 1024.0
+    return f'{value:.1f}EB'
+
+
+def read_source_manifest_count(path: Path) -> int:
+    if not path.exists():
+        return 0
+    count = 0
+    with path.open('r', encoding='utf-8-sig', newline='') as f:
+        reader = csv.reader(f)
+        for row in reader:
+            if not row:
+                continue
+            if not (row[0] or '').strip():
+                continue
+            count += 1
+    return count
+
+
+def read_processed_progress(path: Path) -> dict[str, object]:
+    result = {
+        'csv_exists': path.exists(),
+        'csv_ok': False,
+        'csv_error': '',
+        'processed_rows': 0,
+        'download_ok_rows': 0,
+        'download_skipped_rows': 0,
+        'download_running_rows': 0,
+        'download_pending_rows': 0,
+        'process_ok_rows': 0,
+        'process_running_rows': 0,
+        'upload_uploaded_rows': 0,
+    }
+    if not path.exists():
+        result['csv_error'] = 'missing'
+        return result
+    try:
+        with path.open('r', encoding='utf-8-sig', newline='') as f:
+            reader = csv.DictReader(f)
+            fieldnames = list(reader.fieldnames or [])
+            missing = sorted(PROCESSED_REQUIRED_COLUMNS - set(fieldnames))
+            if missing:
+                result['csv_error'] = f'missing_columns:{",".join(missing)}'
+                return result
+            rows = list(reader)
+        result['processed_rows'] = len(rows)
+        for row in rows:
+            d = (row.get('download_status') or '').strip()
+            p = (row.get('process_status') or '').strip()
+            u = (row.get('upload_status') or '').strip()
+            if d == 'ok':
+                result['download_ok_rows'] += 1
+            elif d == 'skipped':
+                result['download_skipped_rows'] += 1
+            elif d == 'running':
+                result['download_running_rows'] += 1
+            else:
+                result['download_pending_rows'] += 1
+            if p == 'ok':
+                result['process_ok_rows'] += 1
+            elif p == 'running':
+                result['process_running_rows'] += 1
+            if u == 'uploaded':
+                result['upload_uploaded_rows'] += 1
+        result['csv_ok'] = True
+        return result
+    except Exception as exc:
+        result['csv_error'] = str(exc)
+        return result
+
+
+def run_sync(runtime_root: Path) -> str:
+    sync_script = Path('/cache/home/sf895/Sign-DWPose-2M/scripts/sync_processed_csv_from_runtime.py')
+    if not sync_script.exists():
+        return 'missing_sync_script'
+    cmd = [
+        'python3', str(sync_script),
+        '--source-metadata-csv', str(runtime_root / 'Sign-DWPose-2M-metadata_ori.csv'),
+        '--output-metadata-csv', str(runtime_root / 'Sign-DWPose-2M-metadata_processed.csv'),
+        '--raw-video-dir', str(runtime_root / 'raw_video'),
+        '--raw-caption-dir', str(runtime_root / 'raw_caption'),
+        '--raw-metadata-dir', str(runtime_root / 'raw_metadata'),
+        '--dataset-dir', str(runtime_root / 'dataset'),
+        '--progress-path', str(runtime_root / 'archive_upload_progress.json'),
+        '--status-journal-path', str(runtime_root / 'upload_status_journal.jsonl'),
+    ]
+    try:
+        proc = subprocess.run(cmd, check=False, capture_output=True, text=True)
+    except OSError as exc:
+        return f'error:{exc}'
+    if proc.returncode == 0:
+        return (proc.stdout or '').strip() or 'ok'
+    err = (proc.stderr or proc.stdout or '').strip()
+    return f'failed:{err}'
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description='Report Sign-DWPose runtime status.')
+    parser.add_argument('--runtime-root', default='/home/sf895/Sign-DWPose-2M-runtime')
+    parser.add_argument('--username', default='sf895')
+    parser.add_argument('--no-sync', action='store_true')
+    parser.add_argument('--json', action='store_true')
+    args = parser.parse_args()
+
+    runtime_root = Path(args.runtime_root)
+    raw_dir = runtime_root / 'raw_video'
+    dataset_dir = runtime_root / 'dataset'
+    claims_dir = runtime_root / 'slurm' / 'state' / 'claims'
+    download_claims_dir = runtime_root / 'slurm' / 'state' / 'download_claims'
+    progress_path = runtime_root / 'archive_upload_progress.json'
+    source_csv = runtime_root / 'Sign-DWPose-2M-metadata_ori.csv'
+    processed_csv = runtime_root / 'Sign-DWPose-2M-metadata_processed.csv'
+
+    sync_result = 'skipped'
+    if not args.no_sync:
+        sync_result = run_sync(runtime_root)
+
+    raw_complete: list[Path] = []
+    raw_temp: list[Path] = []
+    if raw_dir.exists():
+        for path in raw_dir.iterdir():
+            if not path.is_file():
+                continue
+            if path.suffix.lower() in VIDEO_EXTS:
+                raw_complete.append(path)
+            else:
+                raw_temp.append(path)
+
+    raw_size = sum_file_sizes(raw_complete)
+    runtime_size = 0
+    if runtime_root.exists():
+        for path in runtime_root.rglob('*'):
+            try:
+                if path.is_file():
+                    runtime_size += path.stat().st_size
+            except FileNotFoundError:
+                continue
+
+    source_rows = read_source_manifest_count(source_csv)
+    progress = read_processed_progress(processed_csv)
+
+    payload = {
+        'sync_result': sync_result,
+        'download_normal': len(raw_temp) == 0,
+        'raw_videos': len(raw_complete),
+        'raw_temp_files': len(raw_temp),
+        'sent_to_gpu': count_claims(claims_dir),
+        'processed_complete': count_complete(dataset_dir),
+        'active_downloads': count_claims(download_claims_dir),
+        'uploaded_archives': 0,
+        'uploaded_folders': 0,
+        'raw_size_bytes': raw_size,
+        'runtime_size_bytes': runtime_size,
+        'filesystem_avail_bytes': filesystem_avail_bytes(runtime_root),
+        'source_rows': source_rows,
+        'csv_exists': progress['csv_exists'],
+        'csv_ok': progress['csv_ok'],
+        'csv_error': progress['csv_error'],
+        'processed_rows': progress['processed_rows'],
+        'download_ok_rows': progress['download_ok_rows'],
+        'download_skipped_rows': progress['download_skipped_rows'],
+        'download_running_rows': progress['download_running_rows'],
+        'download_pending_rows': progress['download_pending_rows'],
+        'process_ok_rows': progress['process_ok_rows'],
+        'process_running_rows': progress['process_running_rows'],
+        'upload_uploaded_rows': progress['upload_uploaded_rows'],
+    }
+    uploaded_archives, uploaded_folders = count_uploaded(progress_path)
+    payload['uploaded_archives'] = uploaded_archives
+    payload['uploaded_folders'] = uploaded_folders
+    payload.update(queue_status(args.username))
+    payload['csv_row_match'] = (payload['processed_rows'] == payload['source_rows']) if payload['csv_ok'] else False
+
+    if args.json:
+        print(json.dumps(payload, ensure_ascii=False, indent=2, sort_keys=True))
+        return
+
+    print(f"sync_result={payload['sync_result']}")
+    print(f"download_normal={payload['download_normal']}")
+    print(f"raw_videos={payload['raw_videos']}")
+    print(f"raw_temp_files={payload['raw_temp_files']}")
+    print(f"sent_to_gpu={payload['sent_to_gpu']}")
+    print(f"running_dwpose={payload['running_dwpose']}")
+    print(f"processed_complete={payload['processed_complete']}")
+    print(f"active_downloads={payload['active_downloads']}")
+    print(f"running_download_jobs={payload['running_download']}")
+    print(f"pending_download_jobs={payload['pending_download_jobs']}")
+    print(f"total_download_jobs={payload['total_download_jobs']}")
+    print(f"uploaded_archives={payload['uploaded_archives']}")
+    print(f"uploaded_folders={payload['uploaded_folders']}")
+    print(f"source_rows={payload['source_rows']}")
+    print(f"processed_rows={payload['processed_rows']}")
+    print(f"csv_ok={payload['csv_ok']}")
+    print(f"csv_row_match={payload['csv_row_match']}")
+    print(f"csv_error={payload['csv_error']}")
+    print(f"download_ok_rows={payload['download_ok_rows']}")
+    print(f"download_skipped_rows={payload['download_skipped_rows']}")
+    print(f"download_running_rows={payload['download_running_rows']}")
+    print(f"download_pending_rows={payload['download_pending_rows']}")
+    print(f"process_ok_rows={payload['process_ok_rows']}")
+    print(f"process_running_rows={payload['process_running_rows']}")
+    print(f"upload_uploaded_rows={payload['upload_uploaded_rows']}")
+    print(f"raw_size={human_bytes(payload['raw_size_bytes'])}")
+    print(f"runtime_size={human_bytes(payload['runtime_size_bytes'])}")
+    print(f"filesystem_avail={human_bytes(payload['filesystem_avail_bytes'])}")
+
+
+if __name__ == '__main__':
+    main()

scripts/sync_processed_csv_from_runtime.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+import argparse
+import csv
+import json
+from pathlib import Path
+from typing import Dict, List, Tuple
+
+DEFAULT_COLUMNS = [
+    'video_id',
+    'sign_language',
+    'title',
+    'duration_sec',
+    'start_sec',
+    'end_sec',
+    'subtitle_languages',
+    'subtitle_dir_path',
+    'subtitle_en_source',
+    'raw_video_path',
+    'raw_metadata_path',
+    'metadata_status',
+    'subtitle_status',
+    'download_status',
+    'failure_count',
+    'error',
+    'processed_at',
+    'subtitle_json_path',
+    'subtitle_en',
+    'subtitle_texts_json',
+    'process_status',
+    'upload_status',
+    'local_cleanup_status',
+    'archive_name',
+]
+
+VIDEO_EXTS = {'.mp4', '.mkv', '.webm', '.mov'}
+
+
+def read_csv_rows(path: Path) -> Tuple[List[Dict[str, str]], List[str]]:
+    text = path.read_text(encoding='utf-8-sig')
+    lines = [line for line in text.splitlines() if line.strip()]
+    if not lines:
+        return [], []
+
+    first = next(csv.reader([lines[0]]), [])
+    first0 = first[0].strip() if first else ''
+    if first0 == 'video_id' or 'download_status' in first or 'process_status' in first:
+        with path.open('r', encoding='utf-8-sig', newline='') as f:
+            reader = csv.DictReader(f)
+            rows = [dict(r) for r in reader]
+            fieldnames = list(reader.fieldnames or [])
+        return rows, fieldnames
+
+    rows: List[Dict[str, str]] = []
+    with path.open('r', encoding='utf-8-sig', newline='') as f:
+        reader = csv.reader(f)
+        for parts in reader:
+            if not parts:
+                continue
+            video_id = (parts[0] or '').strip()
+            sign_language = (parts[1] or '').strip() if len(parts) > 1 else ''
+            if not video_id:
+                continue
+            rows.append({'video_id': video_id, 'sign_language': sign_language})
+    return rows, ['video_id', 'sign_language']
+
+
+def write_csv_rows(path: Path, rows: List[Dict[str, str]], fieldnames: List[str]):
+    tmp = path.with_suffix(path.suffix + '.tmp')
+    with tmp.open('w', encoding='utf-8', newline='') as f:
+        writer = csv.DictWriter(f, fieldnames=fieldnames)
+        writer.writeheader()
+        for row in rows:
+            writer.writerow({k: row.get(k, '') for k in fieldnames})
+    tmp.replace(path)
+
+
+def load_progress(progress_path: Path):
+    if not progress_path.exists():
+        return {}, {}
+    obj = json.loads(progress_path.read_text())
+    return obj.get('uploaded_folders', {}), obj.get('archives', {})
+
+
+def load_journal(journal_path: Path):
+    updates: Dict[str, Dict[str, str]] = {}
+    if not journal_path.exists():
+        return updates
+    for line in journal_path.read_text(encoding='utf-8').splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            obj = json.loads(line)
+        except Exception:
+            continue
+        row_updates = {k: str(v) for k, v in (obj.get('updates') or {}).items()}
+        for vid in obj.get('video_ids') or []:
+            updates[str(vid)] = row_updates
+    return updates
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument('--source-metadata-csv', type=Path, required=True)
+    ap.add_argument('--output-metadata-csv', type=Path, required=True)
+    ap.add_argument('--raw-video-dir', type=Path, required=True)
+    ap.add_argument('--raw-caption-dir', type=Path, required=True)
+    ap.add_argument('--raw-metadata-dir', type=Path, required=True)
+    ap.add_argument('--dataset-dir', type=Path, required=True)
+    ap.add_argument('--progress-path', type=Path, required=True)
+    ap.add_argument('--status-journal-path', type=Path, required=True)
+    args = ap.parse_args()
+
+    source_rows, source_fields = read_csv_rows(args.source_metadata_csv)
+    output_rows, output_fields = (read_csv_rows(args.output_metadata_csv) if args.output_metadata_csv.exists() else ([], []))
+    fields: List[str] = []
+    for col in DEFAULT_COLUMNS + source_fields + output_fields:
+        if col and col not in fields:
+            fields.append(col)
+
+    out_by_id = {r.get('video_id', '').strip(): r for r in output_rows if r.get('video_id', '').strip()}
+    rows: List[Dict[str, str]] = []
+    for src in source_rows:
+        vid = (src.get('video_id') or '').strip()
+        if not vid:
+            continue
+        merged = {k: src.get(k, '') for k in fields}
+        if vid in out_by_id:
+            for k in fields:
+                if k in out_by_id[vid]:
+                    merged[k] = out_by_id[vid].get(k, '')
+        rows.append(merged)
+
+    raw_videos = {p.stem: p for p in args.raw_video_dir.iterdir() if p.is_file() and p.suffix.lower() in VIDEO_EXTS} if args.raw_video_dir.exists() else {}
+    raw_metadata = {p.stem: p for p in args.raw_metadata_dir.glob('*.json')} if args.raw_metadata_dir.exists() else {}
+    complete = {p.parent.parent.name for p in args.dataset_dir.glob('*/npz/.complete')} if args.dataset_dir.exists() else set()
+    process_claims_dir = args.dataset_dir.parent / 'slurm' / 'state' / 'claims'
+    download_claims_dir = args.dataset_dir.parent / 'slurm' / 'state' / 'download_claims'
+    process_claims = {p.stem for p in process_claims_dir.glob('*.claim')} if process_claims_dir.exists() else set()
+    download_claims = {p.stem for p in download_claims_dir.glob('*.claim')} if download_claims_dir.exists() else set()
+    uploaded_folders, _archives = load_progress(args.progress_path)
+    journal_updates = load_journal(args.status_journal_path)
+
+    for row in rows:
+        vid = (row.get('video_id') or '').strip()
+        if not vid:
+            continue
+        if vid in raw_metadata:
+            row['raw_metadata_path'] = str(raw_metadata[vid])
+            row['metadata_status'] = 'ok'
+        if vid in raw_videos:
+            row['raw_video_path'] = str(raw_videos[vid])
+            row['download_status'] = 'ok'
+        elif vid in download_claims and row.get('download_status', '') not in {'ok', 'skipped'}:
+            row['download_status'] = 'running'
+        if vid in complete:
+            row['process_status'] = 'ok'
+        elif vid in process_claims and row.get('process_status', '') != 'ok':
+            row['process_status'] = 'running'
+        if vid in uploaded_folders:
+            row['upload_status'] = 'uploaded'
+            row['archive_name'] = uploaded_folders[vid]
+            row['local_cleanup_status'] = 'deleted'
+            row['process_status'] = 'ok'
+            row['download_status'] = 'ok'
+            if not row.get('metadata_status'):
+                row['metadata_status'] = 'ok'
+        elif vid in complete:
+            row['upload_status'] = ''
+            row['archive_name'] = ''
+            row['local_cleanup_status'] = ''
+        elif vid in journal_updates:
+            for k, v in journal_updates[vid].items():
+                if k in {'upload_status', 'archive_name', 'local_cleanup_status'}:
+                    row[k] = v
+
+    write_csv_rows(args.output_metadata_csv, rows, fields)
+    print(f'synced_rows={len(rows)}')
+
+if __name__ == '__main__':
+    main()

scripts/visualize_dwpose_npz.py

@@ -398,8 +398,8 @@ def render_pose_image(frame: Dict[str, object], draw_style: str, transparent: bo
 
 def save_frame_previews(npz_paths: Iterable[Path], single_frame_dir: Path, draw_style: str, conf_threshold: float) -> None:
     single_frame_dir.mkdir(parents=True, exist_ok=True)
-    for npz_path in npz_paths:
-        frame = load_npz_frame(npz_path, aggregated_index=index - 1 if npz_path.name == "poses.npz" else 0)
+    for preview_index, npz_path in enumerate(npz_paths, start=1):
+        frame = load_npz_frame(npz_path, aggregated_index=preview_index - 1 if npz_path.name == "poses.npz" else 0)
         image = render_pose_image(frame, draw_style=draw_style, transparent=False, conf_threshold=conf_threshold)
         image.save(single_frame_dir / f"{npz_path.stem}.png")
 

slurm/orchestrator_autorestart.slurm

@@ -0,0 +1,106 @@
+#!/usr/bin/env bash
+#SBATCH --partition=main
+#SBATCH --job-name=sign-dwpose-launcher
+#SBATCH --nodes=1
+#SBATCH --ntasks=1
+#SBATCH --cpus-per-task=1
+#SBATCH --mem=512M
+#SBATCH --time=12:30:00
+#SBATCH --output=/home/sf895/Sign-DWPose-2M-runtime/slurm/logs/orchestrator_launcher_%j.out
+#SBATCH --error=/home/sf895/Sign-DWPose-2M-runtime/slurm/logs/orchestrator_launcher_%j.err
+
+set -euo pipefail
+
+ROOT_DIR="${ROOT_DIR:-/cache/home/sf895/Sign-DWPose-2M}"
+RUNTIME_ROOT="${RUNTIME_ROOT:-/home/sf895/Sign-DWPose-2M-runtime}"
+ORCH_SUBMIT_SCRIPT="${ORCH_SUBMIT_SCRIPT:-$ROOT_DIR/reproduce_independently_slurm.sh}"
+STOP_FILE="${STOP_FILE:-$RUNTIME_ROOT/STOP_AUTORESTART}"
+ROTATE_SECONDS="${ROTATE_SECONDS:-43200}"
+CHECK_INTERVAL_SECONDS="${CHECK_INTERVAL_SECONDS:-60}"
+ORCHESTRATOR_TIME="${ORCHESTRATOR_TIME:-12:00:00}"
+LAUNCHER_SCRIPT="${LAUNCHER_SCRIPT:-$(readlink -f "$0")}"
+LAUNCHER_PARTITION="${LAUNCHER_PARTITION:-main}"
+LAUNCHER_ACCOUNT="${LAUNCHER_ACCOUNT:-}"
+LAUNCHER_TIME="${LAUNCHER_TIME:-12:30:00}"
+LAUNCHER_CPUS_PER_TASK="${LAUNCHER_CPUS_PER_TASK:-1}"
+LAUNCHER_MEM="${LAUNCHER_MEM:-512M}"
+
+mkdir -p "$RUNTIME_ROOT/slurm/logs"
+
+now_ts() {
+  date '+%Y-%m-%d %H:%M:%S'
+}
+
+log() {
+  echo "[$(now_ts)] [launcher] $*"
+}
+
+current_orchestrator_ids() {
+  squeue -u "$USER" -h -o '%A|%j|%T' | awk -F'|' '$2=="sign-dwpose-orch" && ($3=="RUNNING" || $3=="PENDING" || $3=="CONFIGURING") {print $1}'
+}
+
+submit_orchestrator() {
+  log "submitting orchestration with ORCHESTRATOR_TIME=$ORCHESTRATOR_TIME"
+  env     -u SLURM_JOB_ID     -u SLURM_JOB_NAME     -u SLURM_JOB_NODELIST     -u SLURM_ARRAY_JOB_ID     -u SLURM_ARRAY_TASK_ID     ORCHESTRATOR_TIME="$ORCHESTRATOR_TIME"     bash "$ORCH_SUBMIT_SCRIPT"
+}
+
+cancel_orchestrators() {
+  local ids
+  ids="$(current_orchestrator_ids || true)"
+  if [[ -n "$ids" ]]; then
+    log "cancelling orchestrators: $(echo "$ids" | tr '\n' ' ')"
+    scancel $ids || true
+  fi
+}
+
+submit_next_launcher() {
+  if [[ -f "$STOP_FILE" ]]; then
+    log "stop file present; not submitting next launcher"
+    return 0
+  fi
+  local cmd=(sbatch "--partition=$LAUNCHER_PARTITION" "--time=$LAUNCHER_TIME" "--cpus-per-task=$LAUNCHER_CPUS_PER_TASK" "--mem=$LAUNCHER_MEM")
+  if [[ -n "$LAUNCHER_ACCOUNT" ]]; then
+    cmd+=("--account=$LAUNCHER_ACCOUNT")
+  fi
+  cmd+=("--export=ALL,ROOT_DIR=$ROOT_DIR,RUNTIME_ROOT=$RUNTIME_ROOT,ORCH_SUBMIT_SCRIPT=$ORCH_SUBMIT_SCRIPT,STOP_FILE=$STOP_FILE,ROTATE_SECONDS=$ROTATE_SECONDS,CHECK_INTERVAL_SECONDS=$CHECK_INTERVAL_SECONDS,ORCHESTRATOR_TIME=$ORCHESTRATOR_TIME,LAUNCHER_SCRIPT=$LAUNCHER_SCRIPT,LAUNCHER_PARTITION=$LAUNCHER_PARTITION,LAUNCHER_ACCOUNT=$LAUNCHER_ACCOUNT,LAUNCHER_TIME=$LAUNCHER_TIME,LAUNCHER_CPUS_PER_TASK=$LAUNCHER_CPUS_PER_TASK,LAUNCHER_MEM=$LAUNCHER_MEM")
+  cmd+=("$LAUNCHER_SCRIPT")
+  log "submitting next launcher"
+  "${cmd[@]}"
+}
+
+elapsed=0
+if [[ -f "$STOP_FILE" ]]; then
+  log "stop file present at startup; exiting"
+  exit 0
+fi
+
+if [[ -z "$(current_orchestrator_ids || true)" ]]; then
+  submit_orchestrator
+else
+  log "existing orchestration detected; not submitting a duplicate"
+fi
+
+while (( elapsed < ROTATE_SECONDS )); do
+  if [[ -f "$STOP_FILE" ]]; then
+    log "stop file detected during monitoring; exiting without resubmitting"
+    exit 0
+  fi
+  if [[ -z "$(current_orchestrator_ids || true)" ]]; then
+    log "no live orchestration detected; submitting a replacement"
+    submit_orchestrator
+  fi
+  sleep "$CHECK_INTERVAL_SECONDS"
+  elapsed=$((elapsed + CHECK_INTERVAL_SECONDS))
+done
+
+if [[ -f "$STOP_FILE" ]]; then
+  log "stop file present at rotation boundary; exiting"
+  exit 0
+fi
+
+log "rotation boundary reached; restarting orchestration and handing off to next launcher"
+cancel_orchestrators
+sleep 5
+submit_orchestrator
+submit_next_launcher
+log "handoff complete; exiting"

slurm/process_download_array.slurm

@@ -52,9 +52,21 @@ fi
 
 mkdir -p "$DOWNLOAD_CLAIM_DIR"
 CLAIM_PATH="$DOWNLOAD_CLAIM_DIR/${VIDEO_ID}.claim"
+write_claim() {
+  cat > "$CLAIM_PATH" <<CLAIM
+job_id=${SLURM_ARRAY_JOB_ID:-${SLURM_JOB_ID:-}}
+task_id=${SLURM_ARRAY_TASK_ID}
+job_key=${SLURM_ARRAY_JOB_ID:-${SLURM_JOB_ID:-}}_${SLURM_ARRAY_TASK_ID}
+video_id=${VIDEO_ID}
+host=$(hostname)
+pid=$$
+claimed_at=$(date '+%F %T')
+CLAIM
+}
 cleanup_claim() {
   rm -f "$CLAIM_PATH"
 }
+write_claim
 trap cleanup_claim EXIT
 
 echo "[$(date '+%F %T')] job=${SLURM_JOB_ID:-na} task=${SLURM_ARRAY_TASK_ID} host=$(hostname) video_id=$VIDEO_ID"
@@ -78,7 +90,7 @@ cmd=(python "$PIPELINE01"
   --stats-npz "$STATS_NPZ"
   --csv-lock-path "$DOWNLOAD_CSV_LOCK_PATH"
   --limit 1
-  --video-ids "$VIDEO_ID"
+  --video-ids="$VIDEO_ID"
 )
 if [[ "${FORCE_METADATA:-0}" == "1" ]]; then
   cmd+=(--force-metadata)

slurm/submit_download_slurm.sh

@@ -26,8 +26,9 @@ MEMORY="4G"
 LIMIT=""
 ARRAY_PARALLEL=""
 MAX_BACKLOG_VIDEOS="180"
-MAX_ACTIVE_DOWNLOADS="30"
-WORKERS="4"
+MAX_ACTIVE_DOWNLOADS="60"
+DOWNLOAD_CLAIM_GRACE_SECONDS="${DOWNLOAD_CLAIM_GRACE_SECONDS:-600}"
+WORKERS="60"
 VIDEO_IDS=()
 FORCE_METADATA=0
 FORCE_SUBTITLES=0
@@ -50,12 +51,12 @@ Options:
   --account NAME             Optional Slurm account
   --time HH:MM:SS            Default: 04:00:00
   --cpus-per-task N          Default: 1
-  --mem SIZE                 Default: 4G
+  --mem SIZE                 Default: 60G
   --limit N                  Only submit the first N pending, unclaimed videos this cycle
   --array-parallel N         Add a %N cap to the array
   --max-backlog-videos N     Max raw backlog + active download claims allowed. Default: 180
   --max-active-downloads N   Max active download claims allowed at once. Default: 30
-  --workers N                Max download tasks to submit in one cycle. Default: 4
+  --workers N                Max download tasks to submit in one cycle. Default: 60
   --claim-dir DIR            Download claim directory
   --csv-lock-path PATH       CSV lock path
   --video-ids ID [ID ...]    Restrict this cycle to specific videos
@@ -117,10 +118,12 @@ fi
 TIMESTAMP="$(date '+%Y%m%d_%H%M%S')"
 BASE_MANIFEST="$MANIFEST_DIR/pending_download_${TIMESTAMP}.txt"
 ACTIVE_JOBS_FILE="$STATE_DIR/active_download_jobs_${TIMESTAMP}.txt"
+ACTIVE_DOWNLOAD_TASKS_FILE="$STATE_DIR/active_download_tasks_${TIMESTAMP}.txt"
 
 squeue -h -u "$USER" -o "%A" | sed 's/_.*//' | sort -u > "$ACTIVE_JOBS_FILE"
+squeue -h -u "$USER" -n download -t RUNNING,PENDING,CONFIGURING -o "%i" > "$ACTIVE_DOWNLOAD_TASKS_FILE"
 
-SELECTED_COUNT="$(python - "$SOURCE_METADATA_CSV" "$OUTPUT_METADATA_CSV" "$RAW_VIDEO_DIR" "$DOWNLOAD_CLAIM_DIR" "$ACTIVE_JOBS_FILE" "$MAX_BACKLOG_VIDEOS" "$MAX_ACTIVE_DOWNLOADS" "$LIMIT" "$WORKERS" "$BASE_MANIFEST" "${VIDEO_IDS[*]:-}" <<'PY'
+SELECTED_COUNT="$(python - "$SOURCE_METADATA_CSV" "$OUTPUT_METADATA_CSV" "$RAW_VIDEO_DIR" "$DOWNLOAD_CLAIM_DIR" "$ACTIVE_JOBS_FILE" "$ACTIVE_DOWNLOAD_TASKS_FILE" "$MAX_BACKLOG_VIDEOS" "$MAX_ACTIVE_DOWNLOADS" "$LIMIT" "$WORKERS" "$BASE_MANIFEST" "${VIDEO_IDS[*]:-}" <<'PY'
 import csv
 import sys
 from pathlib import Path
@@ -130,12 +133,13 @@ processed_csv = Path(sys.argv[2])
 raw_video_dir = Path(sys.argv[3])
 claim_dir = Path(sys.argv[4])
 active_jobs_path = Path(sys.argv[5])
-max_backlog = int(sys.argv[6])
-max_active_downloads = int(sys.argv[7])
-limit_arg = sys.argv[8]
-workers = int(sys.argv[9])
-manifest_path = Path(sys.argv[10])
-video_ids_joined = sys.argv[11].strip()
+active_download_tasks_path = Path(sys.argv[6])
+max_backlog = int(sys.argv[7])
+max_active_downloads = int(sys.argv[8])
+limit_arg = sys.argv[9]
+workers = int(sys.argv[10])
+manifest_path = Path(sys.argv[11])
+video_ids_joined = sys.argv[12].strip()
 limit = int(limit_arg) if limit_arg else None
 video_filter = set(video_ids_joined.split()) if video_ids_joined else None
 
@@ -143,6 +147,9 @@ video_extensions = {'.mp4', '.mkv', '.webm', '.mov'}
 active_jobs = set()
 if active_jobs_path.exists():
     active_jobs = {line.strip() for line in active_jobs_path.read_text(encoding='utf-8').splitlines() if line.strip()}
+active_download_tasks = 0
+if active_download_tasks_path.exists():
+    active_download_tasks = sum(1 for line in active_download_tasks_path.read_text(encoding='utf-8').splitlines() if line.strip())
 
 claim_dir.mkdir(parents=True, exist_ok=True)
 active_claims = set()
@@ -153,6 +160,7 @@ for claim_path in claim_dir.glob('*.claim'):
         continue
     job_id = ''
     pid = None
+    submitted_at = ''
     for line in lines:
         if line.startswith('job_id='):
             job_id = line.split('=', 1)[1].strip()
@@ -161,10 +169,20 @@ for claim_path in claim_dir.glob('*.claim'):
                 pid = int(line.split('=', 1)[1].strip())
             except ValueError:
                 pid = None
+        elif line.startswith('submitted_at='):
+            submitted_at = line.split('=', 1)[1].strip()
     alive = False
-    if job_id:
+    if submitted_at:
+        try:
+            from datetime import datetime, timedelta
+            submitted_dt = datetime.strptime(submitted_at, '%Y-%m-%d %H:%M:%S')
+            if (datetime.now() - submitted_dt) <= timedelta(seconds=int("$DOWNLOAD_CLAIM_GRACE_SECONDS")):
+                alive = True
+        except Exception:
+            pass
+    if (not alive) and job_id:
         alive = job_id in active_jobs
-    elif pid is not None:
+    elif (not alive) and pid is not None:
         try:
             import os
             os.kill(pid, 0)
@@ -184,8 +202,9 @@ if raw_video_dir.exists():
             raw_backlog += 1
             existing_raw.add(path.stem)
 
+effective_active_downloads = max(active_download_tasks, len(active_claims))
 remaining_slots = max(0, max_backlog - raw_backlog - len(active_claims))
-remaining_slots = min(remaining_slots, max(0, max_active_downloads - len(active_claims)))
+remaining_slots = min(remaining_slots, max(0, max_active_downloads - effective_active_downloads))
 remaining_slots = min(remaining_slots, workers)
 if limit is not None:
     remaining_slots = min(remaining_slots, limit)
@@ -223,7 +242,7 @@ manifest_path.write_text(''.join(f'{video_id}\n' for video_id in selected), enco
 print(len(selected))
 PY
 )"
-rm -f "$ACTIVE_JOBS_FILE"
+rm -f "$ACTIVE_JOBS_FILE" "$ACTIVE_DOWNLOAD_TASKS_FILE"
 
 if [[ "$SELECTED_COUNT" == "0" ]]; then
   echo "No pending videos to download, or download backlog cap already reached."
@@ -258,13 +277,17 @@ cmd+=("$SLURM_SCRIPT")
 JOB_ID="$("${cmd[@]}")"
 echo "Submitted download array job: $JOB_ID"
 
+task_id=0
 while IFS= read -r video_id; do
   [[ -z "$video_id" ]] && continue
   cat > "$DOWNLOAD_CLAIM_DIR/${video_id}.claim" <<CLAIM
 job_id=$JOB_ID
+task_id=$task_id
+job_key=${JOB_ID}_${task_id}
 video_id=$video_id
 submitted_at=$(date '+%F %T')
 CLAIM
+  task_id=$((task_id + 1))
 done < "$BASE_MANIFEST"
 
 echo "SUBMITTED_DOWNLOAD_COUNT=$SELECTED_COUNT"

slurm/submit_dwpose_slurm.sh

@@ -216,13 +216,17 @@ echo "Submitting now: $TARGET_COUNT"
 write_claims() {
   local manifest="$1"
   local job_id="$2"
+  local task_id=0
   while IFS= read -r video_id; do
     [[ -z "$video_id" ]] && continue
     cat > "$CLAIM_DIR/${video_id}.claim" <<CLAIM
 job_id=$job_id
+task_id=$task_id
+job_key=${job_id}_${task_id}
 video_id=$video_id
 submitted_at=$(date '+%F %T')
 CLAIM
+    task_id=$((task_id + 1))
   done < "$manifest"
 }
 

utils/stats_npz.py

@@ -39,15 +39,15 @@ def _load_stats_unlocked(stats_path: Path) -> Dict[str, Dict[str, str]]:
     if not stats_path.exists() or stats_path.stat().st_size == 0:
         return {}
 
-    data = np.load(stats_path, allow_pickle=True)
-    video_ids = [str(item) for item in data.get("video_ids", np.asarray([], dtype=object)).tolist()]
     stats: Dict[str, Dict[str, str]] = {}
-    for index, video_id in enumerate(video_ids):
-        record = {}
-        for field in STATUS_FIELDS:
-            values = data.get(field)
-            record[field] = str(values[index]) if values is not None and index < len(values) else ""
-        stats[video_id] = record
+    with np.load(stats_path, allow_pickle=True) as data:
+        video_ids = [str(item) for item in data.get("video_ids", np.asarray([], dtype=object)).tolist()]
+        for index, video_id in enumerate(video_ids):
+            record = {}
+            for field in STATUS_FIELDS:
+                values = data.get(field)
+                record[field] = str(values[index]) if values is not None and index < len(values) else ""
+            stats[video_id] = record
     return stats