Update orchestration, CPU download scheduling, and upload/runtime fixes

reproduce_independently.sh

@@ -24,7 +24,8 @@ LIMIT=""
 VIDEO_IDS=()
 FPS="24"
 WORKERS=""
-TARGET_BYTES="$((14 * 1024 * 1024 * 1024))"
+TARGET_BYTES="$((10 * 1024 * 1024 * 1024))"
+TARGET_FOLDERS="${TARGET_FOLDERS:-40}"
 DOWNLOAD_BATCH_SIZE="1"
 PROCESS_BATCH_SIZE=""
 RAW_BACKLOG_LIMIT="340"
@@ -57,6 +58,7 @@ Options:
   --fps N
   --workers N
   --target-bytes N
+  --target-folders N
   --download-batch-size N
   --process-batch-size N
   --raw-backlog-limit N
@@ -300,6 +302,7 @@ run_upload_stage() {
     --stats-npz "$STATS_NPZ"
     --repo-id "$REPO_ID"
     --target-bytes "$TARGET_BYTES"
+    --target-folders "$TARGET_FOLDERS"
   )
 
   if [[ "$require_target" == "1" ]]; then
@@ -511,7 +514,7 @@ upload_loop() {
       continue
     fi
 
-    if [[ "$complete_pending_upload_bytes" -lt "$TARGET_BYTES" && ( "$pending_download" -gt 0 || "$pending_process" -gt 0 ) ]]; then
+    if [[ "$complete_pending_upload_bytes" -lt "$TARGET_BYTES" && "$complete_pending_upload" -lt "$TARGET_FOLDERS" && ( "$pending_download" -gt 0 || "$pending_process" -gt 0 ) ]]; then
       sleep "$IDLE_SLEEP_SECONDS"
       continue
     fi

reproduce_independently_slurm.sh

@@ -29,27 +29,39 @@ LIMIT="${LIMIT:-}"
 VIDEO_IDS=()
 FPS="${FPS:-24}"
 WORKERS="${WORKERS:-}"
-TARGET_BYTES="${TARGET_BYTES:-$((14 * 1024 * 1024 * 1024))}"
+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}"
+USE_SLURM_DOWNLOAD="${USE_SLURM_DOWNLOAD:-1}"
 PROCESS_BATCH_SIZE="${PROCESS_BATCH_SIZE:-}"
 MIN_PROCESS_START_BACKLOG="${MIN_PROCESS_START_BACKLOG:-4}"
-RAW_BACKLOG_LIMIT="${RAW_BACKLOG_LIMIT:-340}"
+RAW_BACKLOG_LIMIT="${RAW_BACKLOG_LIMIT:-180}"
 MAX_RAW_VIDEO_BYTES="${MAX_RAW_VIDEO_BYTES:-0}"
 MAX_ITERATIONS="${MAX_ITERATIONS:-0}"
 IDLE_SLEEP_SECONDS="${IDLE_SLEEP_SECONDS:-5}"
 REPO_ID="${REPO_ID:-SignerX/Sign-DWPose-2M}"
-COOKIES_FILE="${COOKIES_FILE:-}"
+COOKIES_FILE="${COOKIES_FILE:-$ROOT_DIR/www.youtube.com_cookies (2).txt}"
 COOKIES_FROM_BROWSER="${COOKIES_FROM_BROWSER:-}"
 EXTRACTOR_ARGS="${EXTRACTOR_ARGS:-}"
 SLURM_PROCESS_SUBMIT_SCRIPT="${SLURM_PROCESS_SUBMIT_SCRIPT:-$ROOT_DIR/slurm/submit_dwpose_slurm.sh}"
-GPU_PARTITIONS="${GPU_PARTITIONS:-gpu}"
+SLURM_DOWNLOAD_SUBMIT_SCRIPT="${SLURM_DOWNLOAD_SUBMIT_SCRIPT:-$ROOT_DIR/slurm/submit_download_slurm.sh}"
+GPU_PARTITIONS="gpu,gpu-redhat,cgpu"
 GPU_ACCOUNT="${GPU_ACCOUNT:-}"
 ARRAY_PARALLEL="${ARRAY_PARALLEL:-}"
-MAX_BACKLOG_VIDEOS="${MAX_BACKLOG_VIDEOS:-340}"
+MAX_BACKLOG_VIDEOS="${MAX_BACKLOG_VIDEOS:-180}"
+DOWNLOAD_CLAIM_DIR="${DOWNLOAD_CLAIM_DIR:-$STATE_ROOT/slurm/state/download_claims}"
+DOWNLOAD_CSV_LOCK_PATH="${DOWNLOAD_CSV_LOCK_PATH:-$RUNTIME_ROOT/Sign-DWPose-2M-metadata_processed.csv.lock}"
+DOWNLOAD_PARTITIONS="${DOWNLOAD_PARTITIONS:-main}"
+DOWNLOAD_ACCOUNT="${DOWNLOAD_ACCOUNT:-}"
+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}"
 ORCHESTRATOR_PARTITION="${ORCHESTRATOR_PARTITION:-main}"
 ORCHESTRATOR_ACCOUNT="${ORCHESTRATOR_ACCOUNT:-}"
 ORCHESTRATOR_TIME="${ORCHESTRATOR_TIME:-24:00:00}"
-ORCHESTRATOR_CPUS_PER_TASK="${ORCHESTRATOR_CPUS_PER_TASK:-2}"
+ORCHESTRATOR_CPUS_PER_TASK="${ORCHESTRATOR_CPUS_PER_TASK:-4}"
 ORCHESTRATOR_MEM="${ORCHESTRATOR_MEM:-8G}"
 RUN_LOCAL="${RUN_LOCAL:-0}"
 
@@ -87,8 +99,16 @@ Options:
   --orchestrator-mem SIZE
   --run-local
   --target-bytes N
+  --target-folders N
   --download-batch-size N
   --process-batch-size N
+  --use-slurm-download {0,1}
+  --download-partitions P1[,P2,...]
+  --download-account NAME
+  --download-time HH:MM:SS
+  --download-cpus-per-task N
+  --download-mem SIZE
+  --download-array-parallel N
   --raw-backlog-limit N
   --max-raw-video-bytes N
   --max-iterations N
@@ -110,7 +130,7 @@ Examples:
   bash reproduce_independently_slurm.sh --stage download --limit 10 --skip-video-download
   bash reproduce_independently_slurm.sh --stage process --video-id Bdj5MUf_3Hc
   bash reproduce_independently_slurm.sh --stage upload --target-bytes 500000000
-  bash reproduce_independently_slurm.sh --stage all --gpu-partitions gpu,gpu-redhat,cgpu --array-parallel 128
+  bash reproduce_independently_slurm.sh
   bash reproduce_independently_slurm.sh --stage all --run-local
 EOF
 }
@@ -202,6 +222,38 @@ while [[ $# -gt 0 ]]; do
       DOWNLOAD_BATCH_SIZE="$2"
       shift 2
       ;;
+    --download-workers)
+      DOWNLOAD_WORKERS="$2"
+      shift 2
+      ;;
+    --use-slurm-download)
+      USE_SLURM_DOWNLOAD="$2"
+      shift 2
+      ;;
+    --download-partitions)
+      DOWNLOAD_PARTITIONS="$2"
+      shift 2
+      ;;
+    --download-account)
+      DOWNLOAD_ACCOUNT="$2"
+      shift 2
+      ;;
+    --download-time)
+      DOWNLOAD_TIME="$2"
+      shift 2
+      ;;
+    --download-cpus-per-task)
+      DOWNLOAD_CPUS_PER_TASK="$2"
+      shift 2
+      ;;
+    --download-mem)
+      DOWNLOAD_MEM="$2"
+      shift 2
+      ;;
+    --download-array-parallel)
+      DOWNLOAD_ARRAY_PARALLEL="$2"
+      shift 2
+      ;;
     --process-batch-size)
       PROCESS_BATCH_SIZE="$2"
       shift 2
@@ -294,7 +346,7 @@ if [[ -z "${SLURM_JOB_ID:-}" && "$RUN_LOCAL" != "1" ]]; then
     echo "Missing orchestration wrapper: $wrapper" >&2
     exit 1
   fi
-  export_args="ALL,ROOT_DIR=$ROOT_DIR,RUNTIME_ROOT=$RUNTIME_ROOT,STATE_ROOT=$STATE_ROOT,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,ARCHIVE_DIR=$ARCHIVE_DIR,STATS_NPZ=$STATS_NPZ,PROGRESS_JSON=$PROGRESS_JSON,STAGE=$STAGE,LIMIT=$LIMIT,FPS=$FPS,WORKERS=$WORKERS,TARGET_BYTES=$TARGET_BYTES,DOWNLOAD_BATCH_SIZE=$DOWNLOAD_BATCH_SIZE,PROCESS_BATCH_SIZE=$PROCESS_BATCH_SIZE,MIN_PROCESS_START_BACKLOG=$MIN_PROCESS_START_BACKLOG,RAW_BACKLOG_LIMIT=$RAW_BACKLOG_LIMIT,MAX_RAW_VIDEO_BYTES=$MAX_RAW_VIDEO_BYTES,MAX_ITERATIONS=$MAX_ITERATIONS,IDLE_SLEEP_SECONDS=$IDLE_SLEEP_SECONDS,REPO_ID=$REPO_ID,COOKIES_FILE=$COOKIES_FILE,COOKIES_FROM_BROWSER=$COOKIES_FROM_BROWSER,EXTRACTOR_ARGS=$EXTRACTOR_ARGS,GPU_PARTITIONS=$GPU_PARTITIONS,GPU_ACCOUNT=$GPU_ACCOUNT,ARRAY_PARALLEL=$ARRAY_PARALLEL,MAX_BACKLOG_VIDEOS=$MAX_BACKLOG_VIDEOS,FORCE_METADATA=$FORCE_METADATA,FORCE_SUBTITLES=$FORCE_SUBTITLES,FORCE_DOWNLOAD=$FORCE_DOWNLOAD,FORCE_PROCESS=$FORCE_PROCESS,SKIP_VIDEO_DOWNLOAD=$SKIP_VIDEO_DOWNLOAD,SKIP_SUBTITLES=$SKIP_SUBTITLES,DRY_RUN_UPLOAD=$DRY_RUN_UPLOAD,RUN_LOCAL=1"
+  export_args="ALL,ROOT_DIR=$ROOT_DIR,RUNTIME_ROOT=$RUNTIME_ROOT,STATE_ROOT=$STATE_ROOT,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,ARCHIVE_DIR=$ARCHIVE_DIR,STATS_NPZ=$STATS_NPZ,PROGRESS_JSON=$PROGRESS_JSON,STAGE=$STAGE,LIMIT=$LIMIT,FPS=$FPS,WORKERS=$WORKERS,TARGET_BYTES=$TARGET_BYTES,DOWNLOAD_BATCH_SIZE=$DOWNLOAD_BATCH_SIZE,DOWNLOAD_WORKERS=$DOWNLOAD_WORKERS,USE_SLURM_DOWNLOAD=$USE_SLURM_DOWNLOAD,SLURM_DOWNLOAD_SUBMIT_SCRIPT=$SLURM_DOWNLOAD_SUBMIT_SCRIPT,DOWNLOAD_PARTITIONS=$DOWNLOAD_PARTITIONS,DOWNLOAD_ACCOUNT=$DOWNLOAD_ACCOUNT,DOWNLOAD_TIME=$DOWNLOAD_TIME,DOWNLOAD_CPUS_PER_TASK=$DOWNLOAD_CPUS_PER_TASK,DOWNLOAD_MEM=$DOWNLOAD_MEM,DOWNLOAD_ARRAY_PARALLEL=$DOWNLOAD_ARRAY_PARALLEL,PROCESS_BATCH_SIZE=$PROCESS_BATCH_SIZE,DOWNLOAD_CLAIM_DIR=$DOWNLOAD_CLAIM_DIR,DOWNLOAD_CSV_LOCK_PATH=$DOWNLOAD_CSV_LOCK_PATH,MIN_PROCESS_START_BACKLOG=$MIN_PROCESS_START_BACKLOG,RAW_BACKLOG_LIMIT=$RAW_BACKLOG_LIMIT,MAX_RAW_VIDEO_BYTES=$MAX_RAW_VIDEO_BYTES,MAX_ITERATIONS=$MAX_ITERATIONS,IDLE_SLEEP_SECONDS=$IDLE_SLEEP_SECONDS,REPO_ID=$REPO_ID,COOKIES_FILE=$COOKIES_FILE,COOKIES_FROM_BROWSER=$COOKIES_FROM_BROWSER,EXTRACTOR_ARGS=$EXTRACTOR_ARGS,GPU_PARTITIONS=$GPU_PARTITIONS,GPU_ACCOUNT=$GPU_ACCOUNT,ARRAY_PARALLEL=$ARRAY_PARALLEL,MAX_BACKLOG_VIDEOS=$MAX_BACKLOG_VIDEOS,FORCE_METADATA=$FORCE_METADATA,FORCE_SUBTITLES=$FORCE_SUBTITLES,FORCE_DOWNLOAD=$FORCE_DOWNLOAD,FORCE_PROCESS=$FORCE_PROCESS,SKIP_VIDEO_DOWNLOAD=$SKIP_VIDEO_DOWNLOAD,SKIP_SUBTITLES=$SKIP_SUBTITLES,DRY_RUN_UPLOAD=$DRY_RUN_UPLOAD,RUN_LOCAL=1"
   if [[ ${#VIDEO_IDS[@]} -gt 0 ]]; then
     export VIDEO_IDS_JOINED
     VIDEO_IDS_JOINED="${VIDEO_IDS[*]}"
@@ -334,48 +386,119 @@ run_in_dwpose() {
 
 run_download_stage() {
   local stage_limit="${1:-$LIMIT}"
-  local cmd=(python "$PIPELINE01"
-    --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"
-    --stats-npz "$STATS_NPZ"
-  )
 
-  if [[ -n "$stage_limit" ]]; then
-    cmd+=(--limit "$stage_limit")
-  fi
-  if [[ ${#VIDEO_IDS[@]} -gt 0 ]]; then
-    cmd+=(--video-ids "${VIDEO_IDS[@]}")
-  fi
-  if [[ $FORCE_METADATA -eq 1 ]]; then
-    cmd+=(--force-metadata)
-  fi
-  if [[ $FORCE_SUBTITLES -eq 1 ]]; then
-    cmd+=(--force-subtitles)
-  fi
-  if [[ $FORCE_DOWNLOAD -eq 1 ]]; then
-    cmd+=(--force-download)
-  fi
-  if [[ $SKIP_VIDEO_DOWNLOAD -eq 1 ]]; then
-    cmd+=(--skip-video-download)
-  fi
-  if [[ $SKIP_SUBTITLES -eq 1 ]]; then
-    cmd+=(--skip-subtitles)
-  fi
-  if [[ -n "$COOKIES_FROM_BROWSER" ]]; then
-    cmd+=(--cookies-from-browser "$COOKIES_FROM_BROWSER")
-  fi
-  if [[ -n "$COOKIES_FILE" ]]; then
-    cmd+=(--cookies "$COOKIES_FILE")
-  fi
-  if [[ -n "$EXTRACTOR_ARGS" ]]; then
-    cmd+=(--extractor-args "$EXTRACTOR_ARGS")
+  if [[ "$USE_SLURM_DOWNLOAD" == "1" ]]; then
+    local cmd=(bash "$SLURM_DOWNLOAD_SUBMIT_SCRIPT"
+      --partitions "$DOWNLOAD_PARTITIONS"
+      --runtime-root "$RUNTIME_ROOT"
+      --state-root "$STATE_ROOT"
+      --time "$DOWNLOAD_TIME"
+      --cpus-per-task "$DOWNLOAD_CPUS_PER_TASK"
+      --mem "$DOWNLOAD_MEM"
+      --max-backlog-videos "$RAW_BACKLOG_LIMIT"
+      --workers "$DOWNLOAD_WORKERS"
+      --claim-dir "$DOWNLOAD_CLAIM_DIR"
+      --csv-lock-path "$DOWNLOAD_CSV_LOCK_PATH"
+    )
+
+    if [[ -n "$DOWNLOAD_ARRAY_PARALLEL" ]]; then
+      cmd+=(--array-parallel "$DOWNLOAD_ARRAY_PARALLEL")
+    fi
+    if [[ -n "$DOWNLOAD_ACCOUNT" ]]; then
+      cmd+=(--account "$DOWNLOAD_ACCOUNT")
+    fi
+    if [[ ${#VIDEO_IDS[@]} -gt 0 ]]; then
+      cmd+=(--video-ids "${VIDEO_IDS[@]}")
+    fi
+    if [[ $FORCE_METADATA -eq 1 ]]; then
+      cmd+=(--force-metadata)
+    fi
+    if [[ $FORCE_SUBTITLES -eq 1 ]]; then
+      cmd+=(--force-subtitles)
+    fi
+    if [[ $FORCE_DOWNLOAD -eq 1 ]]; then
+      cmd+=(--force-download)
+    fi
+    if [[ $SKIP_VIDEO_DOWNLOAD -eq 1 ]]; then
+      cmd+=(--skip-video-download)
+    fi
+    if [[ $SKIP_SUBTITLES -eq 1 ]]; then
+      cmd+=(--skip-subtitles)
+    fi
+    if [[ -n "$COOKIES_FROM_BROWSER" ]]; then
+      cmd+=(--cookies-from-browser "$COOKIES_FROM_BROWSER")
+    fi
+    if [[ -n "$COOKIES_FILE" ]]; then
+      cmd+=(--cookies "$COOKIES_FILE")
+    fi
+    if [[ -n "$EXTRACTOR_ARGS" ]]; then
+      cmd+=(--extractor-args "$EXTRACTOR_ARGS")
+    fi
+
+    "${cmd[@]}"
+    return $?
   fi
 
-  run_in_dwpose "${cmd[@]}"
+  local worker_count="${DOWNLOAD_WORKERS:-1}"
+  local pids=()
+  local failed=0
+  local i
+
+  for ((i=1; i<=worker_count; i++)); do
+    local cmd=(python "$PIPELINE01"
+      --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"
+      --stats-npz "$STATS_NPZ"
+      --claim-dir "$DOWNLOAD_CLAIM_DIR"
+      --csv-lock-path "$DOWNLOAD_CSV_LOCK_PATH"
+    )
+
+    if [[ -n "$stage_limit" ]]; then
+      cmd+=(--limit "$stage_limit")
+    fi
+    if [[ ${#VIDEO_IDS[@]} -gt 0 ]]; then
+      cmd+=(--video-ids "${VIDEO_IDS[@]}")
+    fi
+    if [[ $FORCE_METADATA -eq 1 ]]; then
+      cmd+=(--force-metadata)
+    fi
+    if [[ $FORCE_SUBTITLES -eq 1 ]]; then
+      cmd+=(--force-subtitles)
+    fi
+    if [[ $FORCE_DOWNLOAD -eq 1 ]]; then
+      cmd+=(--force-download)
+    fi
+    if [[ $SKIP_VIDEO_DOWNLOAD -eq 1 ]]; then
+      cmd+=(--skip-video-download)
+    fi
+    if [[ $SKIP_SUBTITLES -eq 1 ]]; then
+      cmd+=(--skip-subtitles)
+    fi
+    if [[ -n "$COOKIES_FROM_BROWSER" ]]; then
+      cmd+=(--cookies-from-browser "$COOKIES_FROM_BROWSER")
+    fi
+    if [[ -n "$COOKIES_FILE" ]]; then
+      cmd+=(--cookies "$COOKIES_FILE")
+    fi
+    if [[ -n "$EXTRACTOR_ARGS" ]]; then
+      cmd+=(--extractor-args "$EXTRACTOR_ARGS")
+    fi
+
+    run_in_dwpose "${cmd[@]}" &
+    pids+=("$!")
+  done
+
+  for pid in "${pids[@]}"; do
+    if ! wait "$pid"; then
+      failed=1
+    fi
+  done
+
+  return "$failed"
 }
 
 RUN_PROCESS_STAGE_SUBMITTED_COUNT=0
@@ -424,6 +547,7 @@ run_upload_stage() {
     --stats-npz "$STATS_NPZ"
     --repo-id "$REPO_ID"
     --target-bytes "$TARGET_BYTES"
+    --target-folders "$TARGET_FOLDERS"
   )
 
   if [[ "$require_target" == "1" ]]; then
@@ -441,43 +565,33 @@ prune_processed_raw_videos() {
 from pathlib import Path
 raw_dir = Path("$RAW_VIDEO_DIR")
 dataset_dir = Path("$DATASET_DIR")
-deleted = 0
+video_extensions = {".mp4", ".mkv", ".webm", ".mov"}
+removed = 0
 if raw_dir.exists():
     for video_path in raw_dir.iterdir():
-        if not video_path.is_file():
+        if not video_path.is_file() or video_path.suffix.lower() not in video_extensions:
             continue
-        marker = dataset_dir / video_path.stem / "npz" / ".complete"
-        if marker.exists():
+        video_id = video_path.stem
+        if (dataset_dir / video_id / "npz" / ".complete").exists():
             video_path.unlink(missing_ok=True)
-            deleted += 1
-print(deleted)
+            removed += 1
+print(removed)
 PY
 }
 
-dir_size_bytes() {
-  local dir_path="$1"
-  if [[ ! -d "$dir_path" ]]; then
-    echo 0
-    return
-  fi
-  find "$dir_path" -type f -printf '%s\n' | awk '{sum+=$1} END {print sum+0}'
-}
-
 count_pending_downloads() {
   python - <<PY
-import csv, sys
+import csv
 from pathlib import Path
-csv.field_size_limit(min(sys.maxsize, 10 * 1024 * 1024))
-path = Path("$OUTPUT_METADATA_CSV")
-if not path.exists():
-    path = Path("$SOURCE_METADATA_CSV")
+csv_path = Path("$OUTPUT_METADATA_CSV")
 pending = 0
-with path.open("r", encoding="utf-8-sig", newline="") as handle:
-    reader = csv.DictReader(handle)
-    for row in reader:
-        if (row.get("download_status") or "").strip() == "ok":
-            continue
-        pending += 1
+if csv_path.exists():
+    with csv_path.open("r", encoding="utf-8", newline="") as handle:
+        reader = csv.DictReader(handle)
+        for row in reader:
+            if (row.get("download_status") or "").strip() in {"ok", "skipped"}:
+                continue
+            pending += 1
 print(pending)
 PY
 }
@@ -486,20 +600,81 @@ count_pending_process() {
   python - <<PY
 from pathlib import Path
 raw_dir = Path("$RAW_VIDEO_DIR")
+video_extensions = {".mp4", ".mkv", ".webm", ".mov"}
 pending = 0
 if raw_dir.exists():
     for video_path in raw_dir.iterdir():
-        if video_path.is_file():
+        if video_path.is_file() and video_path.suffix.lower() in video_extensions:
             pending += 1
 print(pending)
 PY
 }
 
+cleanup_stale_download_claims() {
+  python - <<PY
+import os
+import subprocess
+from pathlib import Path
+claim_dir = Path("$DOWNLOAD_CLAIM_DIR")
+claim_dir.mkdir(parents=True, exist_ok=True)
+removed = 0
+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()}
+except Exception:
+    active_jobs = set()
+for claim_path in claim_dir.glob("*.claim"):
+    try:
+        lines = claim_path.read_text(encoding="utf-8").splitlines()
+    except OSError:
+        continue
+    pid = None
+    job_id = ""
+    for line in lines:
+        if line.startswith("pid="):
+            try:
+                pid = int(line.split("=", 1)[1].strip())
+            except ValueError:
+                pid = None
+        elif line.startswith("job_id="):
+            job_id = line.split("=", 1)[1].strip()
+    alive = False
+    if job_id:
+        alive = job_id in active_jobs
+    elif pid is not None:
+        try:
+            os.kill(pid, 0)
+            alive = True
+        except OSError:
+            alive = False
+    if not alive:
+        claim_path.unlink(missing_ok=True)
+        removed += 1
+print(removed)
+PY
+}
+
+dir_size_bytes() {
+  python - <<PY
+from pathlib import Path
+root = Path("$1")
+total = 0
+if root.exists():
+    for path in root.rglob("*"):
+        if path.is_file():
+            try:
+                total += path.stat().st_size
+            except OSError:
+                pass
+print(total)
+PY
+}
+
 count_active_process_claims() {
   python - <<PY
 import subprocess
 from pathlib import Path
-claim_dir = Path("$ROOT_DIR/slurm/state/claims")
+claim_dir = Path("$STATE_ROOT/slurm/state/claims")
 claim_dir.mkdir(parents=True, exist_ok=True)
 try:
     result = subprocess.run(["squeue", "-h", "-u", "$USER", "-o", "%A"], check=True, capture_output=True, text=True)
@@ -535,13 +710,14 @@ uploaded = set()
 if progress_path.exists():
     uploaded = set(json.loads(progress_path.read_text()).get("uploaded_folders", {}).keys())
 count = 0
-for folder_path in dataset_dir.iterdir():
-    if not folder_path.is_dir():
-        continue
-    if folder_path.name in uploaded:
-        continue
-    if (folder_path / "npz" / ".complete").exists():
-        count += 1
+if dataset_dir.exists():
+    for folder_path in dataset_dir.iterdir():
+        if not folder_path.is_dir():
+            continue
+        if folder_path.name in uploaded:
+            continue
+        if (folder_path / "npz" / ".complete").exists():
+            count += 1
 print(count)
 PY
 }
@@ -556,16 +732,20 @@ uploaded = set()
 if progress_path.exists():
     uploaded = set(json.loads(progress_path.read_text()).get("uploaded_folders", {}).keys())
 total = 0
-for folder_path in dataset_dir.iterdir():
-    if not folder_path.is_dir():
-        continue
-    if folder_path.name in uploaded:
-        continue
-    if not (folder_path / "npz" / ".complete").exists():
-        continue
-    for path in folder_path.rglob("*"):
-        if path.is_file():
-            total += path.stat().st_size
+if dataset_dir.exists():
+    for folder_path in dataset_dir.iterdir():
+        if not folder_path.is_dir():
+            continue
+        if folder_path.name in uploaded:
+            continue
+        if not (folder_path / "npz" / ".complete").exists():
+            continue
+        for path in folder_path.rglob("*"):
+            if path.is_file():
+                try:
+                    total += path.stat().st_size
+                except OSError:
+                    pass
 print(total)
 PY
 }
@@ -574,13 +754,14 @@ download_loop() {
   local iteration=0
   while true; do
     iteration=$((iteration + 1))
-    local pruned
+    local pruned stale_download_claims
     pruned="$(prune_processed_raw_videos)"
+    stale_download_claims="$(cleanup_stale_download_claims)"
     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"
+    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"
 
     if [[ "$MAX_ITERATIONS" -gt 0 && "$iteration" -gt "$MAX_ITERATIONS" ]]; then
       echo "[download] reached max iterations: $MAX_ITERATIONS"
@@ -699,7 +880,7 @@ upload_loop() {
       continue
     fi
 
-    if [[ "$complete_pending_upload_bytes" -lt "$TARGET_BYTES" && ( "$pending_download" -gt 0 || "$pending_process" -gt 0 ) ]]; then
+    if [[ "$complete_pending_upload_bytes" -lt "$TARGET_BYTES" && "$complete_pending_upload" -lt "$TARGET_FOLDERS" && ( "$pending_download" -gt 0 || "$pending_process" -gt 0 ) ]]; then
       sleep "$IDLE_SLEEP_SECONDS"
       continue
     fi

scripts/pipeline01_download_video_fix_caption.py

@@ -2,8 +2,10 @@
 
 import argparse
 import csv
+import fcntl
 import html
 import json
+import os
 import re
 import shutil
 import subprocess
@@ -19,7 +21,7 @@ REPO_ROOT = Path(__file__).resolve().parents[1]
 if str(REPO_ROOT) not in sys.path:
     sys.path.insert(0, str(REPO_ROOT))
 
-from utils.stats_npz import ensure_record, load_stats, save_stats
+from utils.stats_npz import update_video_stats
 
 
 DEFAULT_SOURCE_METADATA_CSV = REPO_ROOT / "Sign-DWPose-2M-metadata_ori.csv"
@@ -81,6 +83,8 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--cookies-from-browser", default=None)
     parser.add_argument("--extractor-args", default=DEFAULT_YT_DLP_EXTRACTOR_ARGS)
     parser.add_argument("--max-failures-before-skip", type=int, default=2)
+    parser.add_argument("--claim-dir", type=Path, default=None)
+    parser.add_argument("--csv-lock-path", type=Path, default=None)
     return parser.parse_args()
 
 
@@ -127,6 +131,39 @@ def read_manifest(csv_path: Path) -> Tuple[List[Dict[str, str]], List[str]]:
     return manifest_rows, ordered_fieldnames
 
 
+def read_state_manifest(source_csv: Path, output_csv: Path) -> Tuple[List[Dict[str, str]], List[str]]:
+    source_rows, source_fieldnames = read_manifest(source_csv)
+    if not output_csv.exists():
+        return source_rows, source_fieldnames
+
+    output_rows, output_fieldnames = read_manifest(output_csv)
+    ordered_fieldnames: List[str] = []
+    for column in list(source_fieldnames) + list(output_fieldnames):
+        if column and column not in ordered_fieldnames:
+            ordered_fieldnames.append(column)
+
+    merged_rows: List[Dict[str, str]] = []
+    output_by_id = {row.get("video_id", "").strip(): row for row in output_rows if row.get("video_id", "").strip()}
+    seen = set()
+    for source_row in source_rows:
+        video_id = source_row.get("video_id", "").strip()
+        if not video_id:
+            continue
+        merged = {column: source_row.get(column, "") for column in ordered_fieldnames}
+        if video_id in output_by_id:
+            merge_row_values(merged, output_by_id[video_id], ordered_fieldnames)
+        merged_rows.append(merged)
+        seen.add(video_id)
+
+    for video_id, row in output_by_id.items():
+        if video_id in seen:
+            continue
+        merged = {column: row.get(column, "") for column in ordered_fieldnames}
+        merged_rows.append(merged)
+
+    return merged_rows, ordered_fieldnames
+
+
 def write_manifest(csv_path: Path, rows: Sequence[Dict[str, str]], fieldnames: Sequence[str]) -> None:
     tmp_path = csv_path.with_suffix(csv_path.suffix + ".tmp")
     with tmp_path.open("w", encoding="utf-8", newline="") as handle:
@@ -137,6 +174,103 @@ def write_manifest(csv_path: Path, rows: Sequence[Dict[str, str]], fieldnames: S
     tmp_path.replace(csv_path)
 
 
+def lock_path_for_manifest(output_csv: Path, explicit_lock_path: Path | None) -> Path:
+    return explicit_lock_path or output_csv.with_suffix(output_csv.suffix + ".lock")
+
+
+def claim_path_for_video(claim_dir: Path, video_id: str) -> Path:
+    return claim_dir / f"{video_id}.claim"
+
+
+def with_manifest_lock(lock_path: Path):
+    lock_path.parent.mkdir(parents=True, exist_ok=True)
+    handle = lock_path.open("a+", encoding="utf-8")
+    fcntl.flock(handle.fileno(), fcntl.LOCK_EX)
+    return handle
+
+
+def merge_row_values(target_row: Dict[str, str], updates: Dict[str, str], fieldnames: Sequence[str]) -> None:
+    for field in fieldnames:
+        if field in updates:
+            target_row[field] = updates.get(field, "")
+
+
+def claim_target_rows(args: argparse.Namespace) -> Tuple[List[Dict[str, str]], List[Dict[str, str]], List[str], Path]:
+    manifest_input_path = args.output_metadata_csv if args.output_metadata_csv.exists() else args.source_metadata_csv
+    claim_dir = args.claim_dir
+    if claim_dir is None:
+        rows, fieldnames = read_state_manifest(args.source_metadata_csv, args.output_metadata_csv)
+        local_video_ids = collect_local_video_ids(args) if args.local_only else None
+        selected_rows = iter_target_rows(rows, args.video_ids, args.limit, local_video_ids, args)
+        return rows, selected_rows, fieldnames, manifest_input_path
+
+    claim_dir.mkdir(parents=True, exist_ok=True)
+    lock_path = lock_path_for_manifest(args.output_metadata_csv, args.csv_lock_path)
+    handle = with_manifest_lock(lock_path)
+    try:
+        rows, fieldnames = read_state_manifest(args.source_metadata_csv, args.output_metadata_csv)
+        local_video_ids = collect_local_video_ids(args) if args.local_only else None
+        selected_rows: List[Dict[str, str]] = []
+        video_id_filter = set(args.video_ids or [])
+        limit = args.limit
+        for row in rows:
+            video_id = row["video_id"].strip()
+            if not video_id:
+                continue
+            if video_id_filter and video_id not in video_id_filter:
+                continue
+            if local_video_ids is not None and video_id not in local_video_ids:
+                continue
+            if not row_needs_processing(row, args):
+                continue
+            claim_path = claim_path_for_video(claim_dir, video_id)
+            try:
+                fd = os.open(claim_path, os.O_CREAT | os.O_EXCL | os.O_WRONLY)
+            except FileExistsError:
+                continue
+            with os.fdopen(fd, "w", encoding="utf-8") as claim_handle:
+                claim_handle.write(f"pid={os.getpid()}\n")
+                claim_handle.write(f"video_id={video_id}\n")
+                claim_handle.write(f"claimed_at={time.strftime('%Y-%m-%d %H:%M:%S')}\n")
+            selected_rows.append(dict(row))
+            if limit is not None and len(selected_rows) >= limit:
+                break
+        return rows, selected_rows, fieldnames, manifest_input_path
+    finally:
+        fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+        handle.close()
+
+
+def release_claim(args: argparse.Namespace, video_id: str) -> None:
+    if args.claim_dir is None:
+        return
+    claim_path_for_video(args.claim_dir, video_id).unlink(missing_ok=True)
+
+
+def persist_row_update(args: argparse.Namespace, video_id: str, updated_row: Dict[str, str], fieldnames: Sequence[str]) -> None:
+    lock_path = lock_path_for_manifest(args.output_metadata_csv, args.csv_lock_path)
+    handle = with_manifest_lock(lock_path)
+    try:
+        rows, current_fieldnames = read_state_manifest(args.source_metadata_csv, args.output_metadata_csv)
+        ordered_fieldnames = []
+        for column in list(current_fieldnames) + list(fieldnames):
+            if column and column not in ordered_fieldnames:
+                ordered_fieldnames.append(column)
+        found = False
+        for row in rows:
+            if row.get("video_id", "").strip() == video_id:
+                merge_row_values(row, updated_row, ordered_fieldnames)
+                found = True
+                break
+        if not found:
+            new_row = {column: updated_row.get(column, "") for column in ordered_fieldnames}
+            rows.append(new_row)
+        write_manifest(args.output_metadata_csv, rows, ordered_fieldnames)
+    finally:
+        fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+        handle.close()
+
+
 def repo_relative_or_absolute(path: Path) -> str:
     resolved_path = path.resolve()
     try:
@@ -543,6 +677,51 @@ def select_english_subtitle(subtitle_payloads: Dict[str, Dict[str, object]]) ->
     return "", ""
 
 
+def subtitle_json_path_for_video(subtitle_dir: Path, video_id: str) -> Path:
+    return subtitle_dir / f"{video_id}.captions.json"
+
+
+def build_subtitle_json_payload(
+    video_id: str,
+    subtitle_payloads: Dict[str, Dict[str, object]],
+    subtitle_en: str,
+    subtitle_en_source: str,
+) -> Dict[str, object]:
+    languages: Dict[str, Dict[str, object]] = {}
+    compact_texts: Dict[str, str] = {}
+    for lang, payload in sorted(subtitle_payloads.items()):
+        compact_texts[lang] = str(payload.get("text") or "")
+        languages[lang] = {
+            "text": compact_texts[lang],
+            "segments": payload.get("segments") or [],
+            "vtt_path": payload.get("vtt_path") or "",
+        }
+    return {
+        "video_id": video_id,
+        "subtitle_languages": sorted(subtitle_payloads),
+        "subtitle_en": subtitle_en,
+        "subtitle_en_source": subtitle_en_source,
+        "subtitle_texts": compact_texts,
+        "languages": languages,
+    }
+
+
+def write_subtitle_json(
+    subtitle_dir: Path,
+    video_id: str,
+    subtitle_payloads: Dict[str, Dict[str, object]],
+    subtitle_en: str,
+    subtitle_en_source: str,
+) -> Path | None:
+    json_path = subtitle_json_path_for_video(subtitle_dir, video_id)
+    if not subtitle_payloads:
+        json_path.unlink(missing_ok=True)
+        return None
+    payload = build_subtitle_json_payload(video_id, subtitle_payloads, subtitle_en, subtitle_en_source)
+    json_path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
+    return json_path
+
+
 def persist_raw_metadata(raw_metadata_dir: Path, video_id: str, metadata: Dict[str, object]) -> str:
     raw_metadata_dir.mkdir(parents=True, exist_ok=True)
     metadata_path = raw_metadata_dir / f"{video_id}.json"
@@ -636,11 +815,7 @@ def main() -> None:
         args._effective_cookies = temp_cookie_path
     else:
         args._effective_cookies = None
-    manifest_input_path = args.output_metadata_csv if args.output_metadata_csv.exists() else args.source_metadata_csv
-    rows, fieldnames = read_manifest(manifest_input_path)
-    local_video_ids = collect_local_video_ids(args) if args.local_only else None
-    selected_rows = iter_target_rows(rows, args.video_ids, args.limit, local_video_ids, args)
-    stats = load_stats(args.stats_npz)
+    rows, selected_rows, fieldnames, _manifest_input_path = claim_target_rows(args)
 
     try:
         args.raw_video_dir.mkdir(parents=True, exist_ok=True)
@@ -651,7 +826,7 @@ def main() -> None:
             video_id = row["video_id"].strip()
             if not video_id:
                 continue
-            stats_record = ensure_record(stats, video_id)
+            stats_record = {}
 
             print(f"[{index}/{len(selected_rows)}] Processing {video_id}")
             metadata_error = ""
@@ -677,8 +852,8 @@ def main() -> None:
                 stats_record["updated_at"] = row["processed_at"]
                 failure_count, should_skip = record_row_failure(row, stats_record, metadata_error, args.max_failures_before_skip)
                 stats_record["last_error"] = row["error"]
-                write_manifest(args.output_metadata_csv, rows, fieldnames)
-                save_stats(args.stats_npz, stats)
+                persist_row_update(args, video_id, row, fieldnames)
+                update_video_stats(args.stats_npz, video_id, **stats_record)
                 print(f"  metadata failed: {metadata_error}")
                 if should_skip:
                     print(f"  skipping after {failure_count} failures")
@@ -771,8 +946,8 @@ def main() -> None:
             stats_record["download_status"] = row["download_status"]
             stats_record["last_error"] = row["error"]
             stats_record["updated_at"] = row["processed_at"]
-            write_manifest(args.output_metadata_csv, rows, fieldnames)
-            save_stats(args.stats_npz, stats)
+            persist_row_update(args, video_id, row, fieldnames)
+            update_video_stats(args.stats_npz, video_id, **stats_record)
 
             if row["download_status"] == "failed":
                 print(f"  video download failed: {download_error}")

scripts/pipeline02_extract_dwpose_from_video.py

@@ -44,6 +44,19 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--delete-source-on-success", action="store_true")
     parser.add_argument("--tmp-root", type=Path, default=Path("/tmp"))
     parser.add_argument("--stats-npz", type=Path, default=DEFAULT_STATS_NPZ)
+    parser.add_argument(
+        "--single-poses-npz",
+        dest="single_poses_npz",
+        action="store_true",
+        default=True,
+        help="Save one aggregated poses.npz per video (default).",
+    )
+    parser.add_argument(
+        "--per-frame-npz",
+        dest="single_poses_npz",
+        action="store_false",
+        help="Save one NPZ file per frame under the npz directory.",
+    )
     return parser.parse_args()
 
 
@@ -125,10 +138,19 @@ def build_npz_payload(pose_data: Dict[str, np.ndarray], width: int, height: int)
     return payload
 
 
-def process_video(video_path: Path, dataset_dir: Path, fps: int, detector: DWposeDetector, tmp_root: Path, force: bool) -> None:
+def process_video(
+    video_path: Path,
+    dataset_dir: Path,
+    fps: int,
+    detector: DWposeDetector,
+    tmp_root: Path,
+    force: bool,
+    single_poses_npz: bool,
+) -> None:
     video_id = video_path.stem
     output_npz_dir = dataset_dir / video_id / "npz"
     complete_marker = output_npz_dir / COMPLETE_MARKER_NAME
+    poses_npz_path = output_npz_dir / "poses.npz"
     if output_npz_dir.exists() and complete_marker.exists() and not force:
         print(f"Skip {video_id}: NPZ files already exist")
         return
@@ -146,18 +168,39 @@ def process_video(video_path: Path, dataset_dir: Path, fps: int, detector: DWpos
         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)
             payload = build_npz_payload(pose_data, width, height)
-            np.savez(output_npz_dir / f"{frame_index:08d}.npz", **payload)
+            if single_poses_npz:
+                aggregated_payloads.append(payload)
+                frame_widths.append(width)
+                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}\ncompleted_at={time.strftime('%Y-%m-%d %H:%M:%S')}\n",
+            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",
         )
     finally:
@@ -194,6 +237,7 @@ def worker(rank: int, worker_count: int, video_paths: Sequence[Path], args: argp
                 detector=detector,
                 tmp_root=args.tmp_root,
                 force=args.force,
+                single_poses_npz=args.single_poses_npz,
             )
             update_video_stats(
                 args.stats_npz,

scripts/pipeline03_upload_to_huggingface.py

@@ -7,6 +7,8 @@ import shutil
 import subprocess
 import sys
 import tarfile
+import threading
+import traceback
 import time
 from pathlib import Path
 from typing import Dict, List, Sequence, Tuple
@@ -18,7 +20,7 @@ REPO_ROOT = Path(__file__).resolve().parents[1]
 if str(REPO_ROOT) not in sys.path:
     sys.path.insert(0, str(REPO_ROOT))
 
-from utils.stats_npz import update_many_video_stats
+from utils.stats_npz import update_many_video_stats_with_retry
 
 
 DEFAULT_DATASET_DIR = REPO_ROOT / "dataset"
@@ -27,9 +29,12 @@ DEFAULT_RAW_CAPTION_DIR = REPO_ROOT / "raw_caption"
 DEFAULT_RAW_METADATA_DIR = REPO_ROOT / "raw_metadata"
 DEFAULT_ARCHIVE_DIR = REPO_ROOT / "archives"
 DEFAULT_PROGRESS_PATH = REPO_ROOT / "archive_upload_progress.json"
+DEFAULT_STATUS_JOURNAL_PATH = REPO_ROOT / "upload_status_journal.jsonl"
 DEFAULT_STATS_NPZ = REPO_ROOT / "stats.npz"
 DEFAULT_GIT_CLONE_DIR = DEFAULT_ARCHIVE_DIR / ".hf_git_repo"
-DEFAULT_TARGET_BYTES = 14 * 1024 * 1024 * 1024
+DEFAULT_TOKEN_PATH = Path.home() / ".hf_token.txt"
+DEFAULT_TARGET_BYTES = 10 * 1024 * 1024 * 1024
+DEFAULT_TARGET_FOLDERS = 40
 COMPLETE_MARKER_NAME = ".complete"
 
 
@@ -44,17 +49,54 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--archive-dir", type=Path, default=DEFAULT_ARCHIVE_DIR)
     parser.add_argument("--progress-path", type=Path, default=DEFAULT_PROGRESS_PATH)
     parser.add_argument("--stats-npz", type=Path, default=DEFAULT_STATS_NPZ)
+    parser.add_argument("--status-journal-path", type=Path, default=DEFAULT_STATUS_JOURNAL_PATH)
     parser.add_argument("--repo-id", default="SignerX/Sign-DWPose-2M")
     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("--dry-run", action="store_true")
-    parser.add_argument("--upload-mode", choices=["git-ssh", "api"], default=os.environ.get("HF_UPLOAD_MODE", "git-ssh"))
+    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)
-    parser.add_argument("--token", default=os.environ.get("HF_TOKEN") or os.environ.get("HUGGINGFACE_HUB_TOKEN"))
+    parser.add_argument("--token", default=None)
     return parser.parse_args()
 
 
+
+
+def resolve_token(cli_token: str | None) -> str | None:
+    if cli_token:
+        return cli_token
+    env_token = os.environ.get("HF_TOKEN") or os.environ.get("HUGGINGFACE_HUB_TOKEN")
+    if env_token:
+        return env_token
+    if DEFAULT_TOKEN_PATH.exists():
+        token = DEFAULT_TOKEN_PATH.read_text(encoding="utf-8").strip()
+        return token or None
+    return None
+
+
+
+def append_status_journal(journal_path: Path, video_ids: Sequence[str], **updates: str) -> None:
+    journal_path.parent.mkdir(parents=True, exist_ok=True)
+    payload = {
+        "video_ids": list(video_ids),
+        "updates": {k: ("" if v is None else str(v)) for k, v in updates.items()},
+        "recorded_at": time.strftime("%Y-%m-%d %H:%M:%S"),
+    }
+    with journal_path.open("a", encoding="utf-8") as handle:
+        handle.write(json.dumps(payload, ensure_ascii=False) + "\n")
+
+
+def update_many_video_stats_best_effort(stats_path: Path, journal_path: Path, video_ids: Sequence[str], **updates: str) -> None:
+    try:
+        update_many_video_stats_with_retry(stats_path, video_ids, **updates)
+    except Exception as exc:
+        payload = dict(updates)
+        payload["last_error"] = str(exc) if not payload.get("last_error") else payload["last_error"]
+        append_status_journal(journal_path, video_ids, **payload)
+        print(f"Warning: stats.npz update deferred to journal due to: {exc}")
+
 def load_progress(progress_path: Path) -> Dict[str, object]:
     if progress_path.exists():
         with progress_path.open("r", encoding="utf-8") as handle:
@@ -71,12 +113,18 @@ def save_progress(progress_path: Path, progress: Dict[str, object]) -> None:
 def folder_size_bytes(folder_path: Path) -> int:
     total = 0
     for path in folder_path.rglob("*"):
-        if path.is_file():
-            total += path.stat().st_size
+        if not path.is_file():
+            continue
+        stat_result = path.stat()
+        # Use allocated blocks so upload triggering follows quota pressure,
+        # not just logical payload bytes. This avoids undercounting millions
+        # of tiny NPZ files.
+        allocated_bytes = getattr(stat_result, "st_blocks", 0) * 512
+        total += allocated_bytes if allocated_bytes > 0 else stat_result.st_size
     return total
 
 
-def list_unuploaded_folders(dataset_dir: Path, progress: Dict[str, object]) -> List[Tuple[str, Path, int]]:
+def list_unuploaded_folder_paths(dataset_dir: Path, progress: Dict[str, object]) -> List[Tuple[str, Path]]:
     uploaded_folders = progress.get("uploaded_folders", {})
     folders = []
     for folder_path in sorted(dataset_dir.iterdir()):
@@ -88,10 +136,14 @@ def list_unuploaded_folders(dataset_dir: Path, progress: Dict[str, object]) -> L
         npz_dir = folder_path / "npz"
         if not (npz_dir / COMPLETE_MARKER_NAME).exists():
             continue
-        folders.append((folder_name, folder_path, folder_size_bytes(folder_path)))
+        folders.append((folder_name, folder_path))
     return folders
 
 
+def enrich_folder_sizes(folders: Sequence[Tuple[str, Path]]) -> List[Tuple[str, Path, int]]:
+    return [(folder_name, folder_path, folder_size_bytes(folder_path)) for folder_name, folder_path in folders]
+
+
 def build_batch(folders: Sequence[Tuple[str, Path, int]], target_bytes: int) -> List[Tuple[str, Path, int]]:
     batch = []
     total_bytes = 0
@@ -122,6 +174,19 @@ def next_archive_index(progress: Dict[str, object], repo_files: Sequence[str]) -
     return (max(indices) + 1) if indices else 1
 
 
+
+
+def preferred_temp_archive_dir() -> Path:
+    for key in ("SLURM_TMPDIR", "TMPDIR"):
+        value = os.environ.get(key)
+        if value:
+            path = Path(value)
+            path.mkdir(parents=True, exist_ok=True)
+            return path
+    path = Path("/tmp")
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
 def create_tar_archive(archive_path: Path, dataset_dir: Path, folder_names: Sequence[str]) -> None:
     archive_path.parent.mkdir(parents=True, exist_ok=True)
     with tarfile.open(archive_path, mode="w") as tar:
@@ -132,10 +197,63 @@ def create_tar_archive(archive_path: Path, dataset_dir: Path, folder_names: Sequ
 def upload_archive(api: HfApi, repo_id: str, repo_type: str, archive_path: Path) -> None:
     api.upload_file(
         path_or_fileobj=str(archive_path),
-        path_in_repo=archive_path.name,
+        path_in_repo=f"dataset/{archive_path.name}",
+        repo_id=repo_id,
+        repo_type=repo_type,
+    )
+
+
+def upload_runtime_state_files(api: HfApi | None, repo_id: str, repo_type: str, progress_path: Path, journal_path: Path) -> None:
+    if api is None:
+        return
+    api.upload_file(
+        path_or_fileobj=str(progress_path),
+        path_in_repo="runtime_state/archive_upload_progress.json",
         repo_id=repo_id,
         repo_type=repo_type,
     )
+    if journal_path.exists():
+        api.upload_file(
+            path_or_fileobj=str(journal_path),
+            path_in_repo="runtime_state/upload_status_journal.jsonl",
+            repo_id=repo_id,
+            repo_type=repo_type,
+        )
+
+
+def upload_archive_streaming(api: HfApi, repo_id: str, repo_type: str, dataset_dir: Path, folder_names: Sequence[str], archive_name: str) -> None:
+    if api is None:
+        raise RuntimeError('api-stream upload requires a Hugging Face token')
+    command = ['tar', '-cf', '-', '-C', str(dataset_dir), *folder_names]
+    process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    assert process.stdout is not None
+    stderr_chunks = []
+
+    def _read_stderr() -> None:
+        assert process.stderr is not None
+        data = process.stderr.read()
+        if data:
+            stderr_chunks.append(data.decode('utf-8', errors='replace'))
+
+    stderr_thread = threading.Thread(target=_read_stderr, daemon=True)
+    stderr_thread.start()
+    try:
+        api.upload_file(
+            path_or_fileobj=process.stdout,
+            path_in_repo=f"dataset/{archive_name}",
+            repo_id=repo_id,
+            repo_type=repo_type,
+        )
+    finally:
+        try:
+            process.stdout.close()
+        except Exception:
+            pass
+    return_code = process.wait()
+    stderr_thread.join(timeout=5)
+    if return_code != 0:
+        stderr_text = ''.join(stderr_chunks).strip()
+        raise RuntimeError(stderr_text or f'tar streaming command failed with exit code {return_code}')
 
 
 def repo_git_url(repo_id: str, repo_type: str) -> str:
@@ -218,6 +336,29 @@ def cleanup_local_assets(
             metadata_path.unlink()
 
 
+def prune_uploaded_runtime_residue(
+    progress: Dict[str, object],
+    dataset_dir: Path,
+    raw_video_dir: Path,
+    raw_caption_dir: Path,
+    raw_metadata_dir: Path,
+) -> None:
+    uploaded = set(progress.get("uploaded_folders", {}))
+    for video_id in uploaded:
+        for path in raw_video_dir.glob(f"{video_id}.*"):
+            if path.is_file():
+                path.unlink(missing_ok=True)
+        caption_dir = raw_caption_dir / video_id
+        if caption_dir.exists():
+            shutil.rmtree(caption_dir, ignore_errors=True)
+        metadata_path = raw_metadata_dir / f"{video_id}.json"
+        if metadata_path.exists():
+            metadata_path.unlink()
+        dataset_video_dir = dataset_dir / video_id
+        if dataset_video_dir.exists() and not (dataset_video_dir / "npz" / COMPLETE_MARKER_NAME).exists():
+            shutil.rmtree(dataset_video_dir, ignore_errors=True)
+
+
 def format_size(num_bytes: int) -> str:
     size = float(num_bytes)
     for unit in ["B", "KB", "MB", "GB", "TB"]:
@@ -229,36 +370,61 @@ def format_size(num_bytes: int) -> str:
 
 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)
-    api = HfApi(token=args.token) if args.upload_mode == "api" else None
+    print(f"[pipeline03] loaded progress archives={len(progress.get("archives", {}))} 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
     args.dataset_dir.mkdir(parents=True, exist_ok=True)
 
     try:
-        if args.upload_mode == "api":
+        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)
         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)
-    except Exception:
+    except Exception as exc:
+        print(f"[pipeline03] repo file listing failed: {exc}", flush=True)
+        traceback.print_exc()
         repo_files = []
 
     while True:
-        remaining_folders = list_unuploaded_folders(args.dataset_dir, progress)
-        if not remaining_folders:
+        prune_uploaded_runtime_residue(
+            progress,
+            args.dataset_dir,
+            args.raw_video_dir,
+            args.raw_caption_dir,
+            args.raw_metadata_dir,
+        )
+        remaining_folder_paths = list_unuploaded_folder_paths(args.dataset_dir, progress)
+        if not remaining_folder_paths:
             print("No unuploaded dataset folders remain.")
             break
-        remaining_bytes = total_batchable_bytes(remaining_folders)
-        if args.require_target_bytes and remaining_bytes < args.target_bytes:
-            print(
-                f"Skip upload: only {format_size(remaining_bytes)} of completed NPZ folders available, below target {format_size(args.target_bytes)}."
-            )
-            break
-
-        batch = build_batch(remaining_folders, args.target_bytes)
-        batch_names = [name for name, _, _ in batch]
-        batch_bytes = sum(folder_bytes for _, _, folder_bytes in batch)
+        remaining_count = len(remaining_folder_paths)
+        print(f"[pipeline03] remaining completed folders available={remaining_count}", flush=True)
+        if remaining_count >= args.target_folders:
+            selected_folder_paths = remaining_folder_paths[: args.target_folders]
+            batch = enrich_folder_sizes(selected_folder_paths)
+            batch_names = [name for name, _, _ in batch]
+            batch_bytes = sum(folder_bytes for _, _, folder_bytes in batch)
+            print(f"[pipeline03] folder threshold reached; selecting first {len(batch_names)} folders without global size scan", flush=True)
+        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:
+                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."
+                )
+                break
+            batch = build_batch(remaining_folders, args.target_bytes)
+            batch_names = [name for name, _, _ in batch]
+            batch_bytes = sum(folder_bytes for _, _, folder_bytes in batch)
         archive_index = next_archive_index(progress, repo_files)
         archive_name = f"Sign_DWPose_NPZ_{archive_index:06d}.tar"
-        archive_path = args.archive_dir / archive_name
+        archive_root = args.archive_dir if args.upload_mode == "git-ssh" else preferred_temp_archive_dir()
+        archive_path = archive_root / archive_name
 
         print(f"Create archive {archive_name} with {len(batch_names)} folders ({format_size(batch_bytes)})")
         for folder_name in batch_names:
@@ -268,8 +434,9 @@ def main() -> None:
             break
 
         args.archive_dir.mkdir(parents=True, exist_ok=True)
-        update_many_video_stats(
+        update_many_video_stats_best_effort(
             args.stats_npz,
+            args.status_journal_path,
             batch_names,
             upload_status="uploading",
             archive_name=archive_name,
@@ -277,14 +444,18 @@ def main() -> None:
             updated_at=time.strftime("%Y-%m-%d %H:%M:%S"),
         )
         try:
-            create_tar_archive(archive_path, args.dataset_dir, batch_names)
-            if args.upload_mode == "api":
-                upload_archive(api, args.repo_id, args.repo_type, archive_path)
+            if args.upload_mode == "api-stream":
+                upload_archive_streaming(api, args.repo_id, args.repo_type, args.dataset_dir, batch_names, archive_name)
             else:
-                upload_archive_via_git(args.git_clone_dir, args.repo_id, args.repo_type, archive_path)
+                create_tar_archive(archive_path, args.dataset_dir, batch_names)
+                if args.upload_mode == "api":
+                    upload_archive(api, args.repo_id, args.repo_type, archive_path)
+                else:
+                    upload_archive_via_git(args.git_clone_dir, args.repo_id, args.repo_type, archive_path)
         except Exception as exc:
-            update_many_video_stats(
+            update_many_video_stats_best_effort(
                 args.stats_npz,
+                args.status_journal_path,
                 batch_names,
                 upload_status="failed",
                 local_cleanup_status="pending",
@@ -292,6 +463,8 @@ def main() -> None:
                 last_error=str(exc),
                 updated_at=time.strftime("%Y-%m-%d %H:%M:%S"),
             )
+            if archive_path.exists():
+                archive_path.unlink(missing_ok=True)
             raise
 
         progress["archives"][archive_name] = {
@@ -312,12 +485,14 @@ def main() -> None:
                 args.raw_caption_dir,
                 args.raw_metadata_dir,
             )
-            archive_path.unlink(missing_ok=True)
+            if archive_path.exists():
+                archive_path.unlink(missing_ok=True)
         except Exception as exc:
             cleanup_error = str(exc)
-        repo_files.append(archive_name)
-        update_many_video_stats(
+        repo_files.append(f"dataset/{archive_name}")
+        update_many_video_stats_best_effort(
             args.stats_npz,
+            args.status_journal_path,
             batch_names,
             upload_status="uploaded",
             local_cleanup_status="deleted" if not cleanup_error else "failed",
@@ -325,10 +500,23 @@ def main() -> None:
             last_error=cleanup_error,
             updated_at=time.strftime("%Y-%m-%d %H:%M:%S"),
         )
+        upload_runtime_state_files(api, args.repo_id, args.repo_type, args.progress_path, args.status_journal_path)
+        prune_uploaded_runtime_residue(
+            progress,
+            args.dataset_dir,
+            args.raw_video_dir,
+            args.raw_caption_dir,
+            args.raw_metadata_dir,
+        )
         if cleanup_error:
             raise RuntimeError(f"Uploaded {archive_name} but local cleanup failed: {cleanup_error}")
         print(f"Uploaded {archive_name} and cleaned raw assets for {len(batch_names)} videos.")
 
 
 if __name__ == "__main__":
-    main()
+    try:
+        main()
+    except Exception as exc:
+        print(f"[pipeline03] fatal: {exc}", file=sys.stderr, flush=True)
+        traceback.print_exc()
+        raise

scripts/visualize_dwpose_npz.py

@@ -93,12 +93,26 @@ def get_stablesigner_openpose_draw():
     return _STABLE_SIGNER_OPENPOSE_DRAW
 
 
-def load_npz_frame(npz_path: Path) -> Dict[str, object]:
+def load_npz_frame(npz_path: Path, aggregated_index: int = 0) -> Dict[str, object]:
     payload = np.load(npz_path, allow_pickle=True)
-    frame: Dict[str, object] = {}
-    frame["num_persons"] = int(payload["num_persons"])
-    frame["frame_width"] = int(payload["frame_width"])
-    frame["frame_height"] = int(payload["frame_height"])
+    if "frame_payloads" in payload.files:
+        frame_payloads = payload["frame_payloads"]
+        if aggregated_index >= len(frame_payloads):
+            raise IndexError(f"Aggregated frame index {aggregated_index} out of range for {npz_path}")
+        payload_dict = frame_payloads[aggregated_index]
+        if hasattr(payload_dict, "item"):
+            payload_dict = payload_dict.item()
+        frame: Dict[str, object] = {}
+        frame["num_persons"] = int(payload_dict["num_persons"])
+        frame["frame_width"] = int(payload_dict["frame_width"])
+        frame["frame_height"] = int(payload_dict["frame_height"])
+        source = payload_dict
+    else:
+        frame = {}
+        frame["num_persons"] = int(payload["num_persons"])
+        frame["frame_width"] = int(payload["frame_width"])
+        frame["frame_height"] = int(payload["frame_height"])
+        source = payload
 
     for person_idx in range(frame["num_persons"]):
         source_prefix = f"person_{person_idx:03d}"
@@ -115,8 +129,8 @@ def load_npz_frame(npz_path: Path) -> Dict[str, object]:
             "right_hand_scores",
         ):
             key = f"{source_prefix}_{suffix}"
-            if key in payload.files:
-                person_data[suffix] = payload[key]
+            if key in source:
+                person_data[suffix] = source[key]
         if person_data:
             frame[target_prefix] = person_data
     return frame
@@ -385,7 +399,7 @@ 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)
+        frame = load_npz_frame(npz_path, aggregated_index=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")
 
@@ -394,7 +408,7 @@ def render_pose_frames(npz_paths: List[Path], pose_frame_dir: Path, draw_style:
     pose_frame_dir.mkdir(parents=True, exist_ok=True)
     total = len(npz_paths)
     for index, npz_path in enumerate(npz_paths, start=1):
-        frame = load_npz_frame(npz_path)
+        frame = load_npz_frame(npz_path, aggregated_index=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(pose_frame_dir / f"{npz_path.stem}.png")
         if index == 1 or index % 100 == 0 or index == total:
@@ -463,7 +477,7 @@ def render_overlay_frames(
     overlay_dir.mkdir(parents=True, exist_ok=True)
     frame_count = min(len(npz_paths), len(raw_frame_paths))
     for index, (npz_path, raw_frame_path) in enumerate(zip(npz_paths[:frame_count], raw_frame_paths[:frame_count]), start=1):
-        frame = load_npz_frame(npz_path)
+        frame = load_npz_frame(npz_path, aggregated_index=index - 1 if npz_path.name == "poses.npz" else 0)
         pose_rgba = render_pose_image(frame, draw_style=draw_style, transparent=True, conf_threshold=conf_threshold)
         with Image.open(raw_frame_path) as raw_image:
             base = raw_image.convert("RGBA")
@@ -488,7 +502,11 @@ def main() -> None:
     if not npz_dir.exists():
         raise FileNotFoundError(f"NPZ directory not found: {npz_dir}")
 
-    npz_paths = sorted(npz_dir.glob("*.npz"))
+    poses_npz_path = npz_dir / "poses.npz"
+    if poses_npz_path.exists():
+        npz_paths = [poses_npz_path]
+    else:
+        npz_paths = sorted(npz_dir.glob("*.npz"))
     if args.max_frames is not None:
         npz_paths = npz_paths[: args.max_frames]
     if not npz_paths:

slurm/process_download_array.slurm

@@ -0,0 +1,100 @@
+#!/usr/bin/env bash
+#SBATCH --job-name=download
+#SBATCH --nodes=1
+#SBATCH --ntasks=1
+#SBATCH --cpus-per-task=1
+#SBATCH --mem=4G
+#SBATCH --time=04:00:00
+#SBATCH --output=%x_%A_%a.out
+#SBATCH --error=%x_%A_%a.err
+
+set -euo pipefail
+
+ROOT_DIR="${ROOT_DIR:-/home/sf895/Sign-DWPose-2M}"
+RUNTIME_ROOT="${RUNTIME_ROOT:-/home/sf895/Sign-DWPose-2M-runtime}"
+STATE_ROOT="${STATE_ROOT:-/home/sf895/Sign-DWPose-2M-runtime}"
+CONDA_SH="${CONDA_SH:-/home/sf895/miniconda3/etc/profile.d/conda.sh}"
+CONDA_ENV="${CONDA_ENV:-signx2}"
+SOURCE_METADATA_CSV="${SOURCE_METADATA_CSV:-$RUNTIME_ROOT/Sign-DWPose-2M-metadata_ori.csv}"
+OUTPUT_METADATA_CSV="${OUTPUT_METADATA_CSV:-$RUNTIME_ROOT/Sign-DWPose-2M-metadata_processed.csv}"
+RAW_VIDEO_DIR="${RAW_VIDEO_DIR:-$RUNTIME_ROOT/raw_video}"
+RAW_CAPTION_DIR="${RAW_CAPTION_DIR:-$RUNTIME_ROOT/raw_caption}"
+RAW_METADATA_DIR="${RAW_METADATA_DIR:-$RUNTIME_ROOT/raw_metadata}"
+DATASET_DIR="${DATASET_DIR:-$RUNTIME_ROOT/dataset}"
+STATS_NPZ="${STATS_NPZ:-$RUNTIME_ROOT/stats.npz}"
+PIPELINE01="${PIPELINE01:-$ROOT_DIR/scripts/pipeline01_download_video_fix_caption.py}"
+DOWNLOAD_CLAIM_DIR="${DOWNLOAD_CLAIM_DIR:-$STATE_ROOT/slurm/state/download_claims}"
+DOWNLOAD_CSV_LOCK_PATH="${DOWNLOAD_CSV_LOCK_PATH:-$STATE_ROOT/Sign-DWPose-2M-metadata_processed.csv.lock}"
+MANIFEST="${MANIFEST:-${1:-}}"
+
+if [[ -z "$MANIFEST" ]]; then
+  echo "MANIFEST is required (env var or first positional arg)." >&2
+  exit 1
+fi
+if [[ ! -f "$MANIFEST" ]]; then
+  echo "Manifest not found: $MANIFEST" >&2
+  exit 1
+fi
+if [[ -z "${SLURM_ARRAY_TASK_ID:-}" ]]; then
+  echo "SLURM_ARRAY_TASK_ID is required." >&2
+  exit 1
+fi
+if [[ ! -f "$CONDA_SH" ]]; then
+  echo "Missing conda init script: $CONDA_SH" >&2
+  exit 1
+fi
+
+VIDEO_ID="$(sed -n "$((SLURM_ARRAY_TASK_ID + 1))p" "$MANIFEST")"
+if [[ -z "$VIDEO_ID" ]]; then
+  echo "No video id found for task index ${SLURM_ARRAY_TASK_ID} in manifest $MANIFEST" >&2
+  exit 1
+fi
+
+mkdir -p "$DOWNLOAD_CLAIM_DIR"
+CLAIM_PATH="$DOWNLOAD_CLAIM_DIR/${VIDEO_ID}.claim"
+cleanup_claim() {
+  rm -f "$CLAIM_PATH"
+}
+trap cleanup_claim EXIT
+
+echo "[$(date '+%F %T')] job=${SLURM_JOB_ID:-na} task=${SLURM_ARRAY_TASK_ID} host=$(hostname) video_id=$VIDEO_ID"
+
+# shellcheck disable=SC1090
+source "$CONDA_SH"
+cmd=(python "$PIPELINE01"
+  --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"
+  --stats-npz "$STATS_NPZ"
+  --csv-lock-path "$DOWNLOAD_CSV_LOCK_PATH"
+  --limit 1
+  --video-ids "$VIDEO_ID"
+)
+if [[ "${FORCE_METADATA:-0}" == "1" ]]; then
+  cmd+=(--force-metadata)
+fi
+if [[ "${FORCE_SUBTITLES:-0}" == "1" ]]; then
+  cmd+=(--force-subtitles)
+fi
+if [[ "${FORCE_DOWNLOAD:-0}" == "1" ]]; then
+  cmd+=(--force-download)
+fi
+if [[ "${SKIP_VIDEO_DOWNLOAD:-0}" == "1" ]]; then
+  cmd+=(--skip-video-download)
+fi
+if [[ "${SKIP_SUBTITLES:-0}" == "1" ]]; then
+  cmd+=(--skip-subtitles)
+fi
+if [[ -n "${COOKIES_FROM_BROWSER:-}" ]]; then
+  cmd+=(--cookies-from-browser "$COOKIES_FROM_BROWSER")
+fi
+if [[ -n "${COOKIES_FILE:-}" ]]; then
+  cmd+=(--cookies "$COOKIES_FILE")
+fi
+if [[ -n "${EXTRACTOR_ARGS:-}" ]]; then
+  cmd+=(--extractor-args "$EXTRACTOR_ARGS")
+fi
+CONDA_NO_PLUGINS=true conda run -n "$CONDA_ENV" "${cmd[@]}"

slurm/process_dwpose_array.slurm

@@ -25,6 +25,8 @@ TMP_ROOT="${TMP_ROOT:-${SLURM_TMPDIR:-/tmp}}"
 FORCE_PROCESS="${FORCE_PROCESS:-0}"
 DELETE_SOURCE_ON_SUCCESS="${DELETE_SOURCE_ON_SUCCESS:-0}"
 CLAIM_DIR="${CLAIM_DIR:-$STATE_ROOT/slurm/state/claims}"
+RETRY_DIR="${RETRY_DIR:-$STATE_ROOT/slurm/state/gpu_init_retries}"
+MAX_GPU_INIT_RETRIES="${MAX_GPU_INIT_RETRIES:-3}"
 
 MANIFEST="${MANIFEST:-${1:-}}"
 if [[ -z "$MANIFEST" ]]; then
@@ -50,7 +52,9 @@ if [[ -z "$VIDEO_ID" ]]; then
   exit 1
 fi
 
+mkdir -p "$CLAIM_DIR" "$RETRY_DIR"
 CLAIM_PATH="$CLAIM_DIR/${VIDEO_ID}.claim"
+RETRY_STATE_PATH="$RETRY_DIR/${VIDEO_ID}.state"
 cleanup_claim() {
   rm -f "$CLAIM_PATH"
 }
@@ -63,6 +67,91 @@ echo "[$(date '+%F %T')] job=${SLURM_JOB_ID:-na} task=${SLURM_ARRAY_TASK_ID} hos
 
 # shellcheck disable=SC1090
 source "$CONDA_SH"
+CONDA_ENV_PREFIX="$(conda env list | awk '$1 == env {print $NF}' env="$CONDA_ENV")"
+if [[ -z "$CONDA_ENV_PREFIX" ]]; then
+  echo "Unable to resolve conda env prefix for $CONDA_ENV" >&2
+  exit 1
+fi
+export LD_LIBRARY_PATH="$CONDA_ENV_PREFIX/lib${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
+export PATH="$CONDA_ENV_PREFIX/bin:$PATH"
+LIBSTDCXX_PATH="$CONDA_ENV_PREFIX/lib/libstdc++.so.6"
+LIBGCC_PATH="$CONDA_ENV_PREFIX/lib/libgcc_s.so.1"
+LD_PRELOAD_VALUE=""
+if [[ -f "$LIBSTDCXX_PATH" ]]; then
+  LD_PRELOAD_VALUE="$LIBSTDCXX_PATH"
+fi
+if [[ -f "$LIBGCC_PATH" ]]; then
+  LD_PRELOAD_VALUE="${LD_PRELOAD_VALUE:+$LD_PRELOAD_VALUE:}$LIBGCC_PATH"
+fi
+export LD_PRELOAD="${LD_PRELOAD_VALUE}${LD_PRELOAD:+:$LD_PRELOAD}"
+echo "Using conda env prefix=$CONDA_ENV_PREFIX"
+echo "Using LD_PRELOAD=$LD_PRELOAD"
+
+gpu_init_retry_state() {
+  local attempts="$1"
+  local host_name="$2"
+  local gpu_id="$3"
+  local reason="$4"
+  cat > "$RETRY_STATE_PATH" <<STATE
+attempts=$attempts
+host=$host_name
+gpu=$gpu_id
+updated_at=$(date '+%F %T')
+reason=$reason
+STATE
+}
+
+get_retry_attempts() {
+  if [[ -f "$RETRY_STATE_PATH" ]]; then
+    awk -F'=' '/^attempts=/{print $2}' "$RETRY_STATE_PATH" | tail -n 1
+  else
+    echo 0
+  fi
+}
+
+mark_retry_exhausted() {
+  local attempts="$1"
+  local reason="$2"
+  python - <<PY
+from pathlib import Path
+import sys, time
+root = Path(r"$ROOT_DIR")
+stats_path = Path(r"$STATS_NPZ")
+video_id = r"$VIDEO_ID"
+attempts = int(r"$attempts")
+reason = r'''$reason'''
+sys.path.insert(0, str(root))
+from utils.stats_npz import update_video_stats
+update_video_stats(
+    stats_path,
+    video_id,
+    process_status="skipped",
+    last_error=f"gpu_init_retry_exhausted after {attempts} attempts: {reason}",
+    updated_at=time.strftime("%Y-%m-%d %H:%M:%S"),
+)
+PY
+  rm -f "$RAW_VIDEO_DIR/$VIDEO_ID.mp4" "$RAW_VIDEO_DIR/$VIDEO_ID.mkv" "$RAW_VIDEO_DIR/$VIDEO_ID.webm" "$RAW_VIDEO_DIR/$VIDEO_ID.mov"
+}
+
+should_retry_gpu_init_failure() {
+  local log_path="$1"
+  local npz_dir="$2"
+  local npz_count="0"
+  if [[ -d "$npz_dir" ]]; then
+    npz_count="$(find "$npz_dir" -maxdepth 1 -name '*.npz' | wc -l | tr -d '[:space:]')"
+  fi
+  if [[ "$npz_count" != "0" ]]; then
+    return 1
+  fi
+  grep -Eiq 'CUDA failure 2: out of memory|Failed to create CUDAExecutionProvider|libcudnn\.so\.8|CUDA is not available|CUDAExecutionProvider|onnxruntime' "$log_path"
+}
+
+env_cmd=(env
+  "LD_LIBRARY_PATH=$LD_LIBRARY_PATH"
+  "LD_PRELOAD=$LD_PRELOAD"
+  "PATH=$PATH"
+  "CONDA_NO_PLUGINS=true"
+)
 
 cmd=(python -u "$PIPELINE02"
   --raw-video-dir "$RAW_VIDEO_DIR"
@@ -80,4 +169,28 @@ if [[ "$DELETE_SOURCE_ON_SUCCESS" == "1" ]]; then
   cmd+=(--delete-source-on-success)
 fi
 
-CONDA_NO_PLUGINS=true conda run -n "$CONDA_ENV" "${cmd[@]}"
+TMP_LOG="$(mktemp "${TMP_ROOT%/}/dwpose_${VIDEO_ID}_XXXX.log")"
+set +e
+"${env_cmd[@]}" conda run -n "$CONDA_ENV" "${cmd[@]}" 2>&1 | tee "$TMP_LOG"
+cmd_status=${PIPESTATUS[0]}
+set -e
+
+if [[ "$cmd_status" -ne 0 ]]; then
+  npz_dir="$DATASET_DIR/$VIDEO_ID/npz"
+  if should_retry_gpu_init_failure "$TMP_LOG" "$npz_dir"; then
+    attempts="$(get_retry_attempts)"
+    attempts="$((attempts + 1))"
+    last_reason="$(tail -n 80 "$TMP_LOG" | tr '\n' ' ' | sed 's/[[:space:]]\+/ /g' | cut -c1-1200)"
+    gpu_init_retry_state "$attempts" "$(hostname)" "${CUDA_VISIBLE_DEVICES:-unset}" "$last_reason"
+    if [[ "$attempts" -ge "$MAX_GPU_INIT_RETRIES" ]]; then
+      echo "GPU init failed on multiple GPUs; marking $VIDEO_ID as skipped after $attempts attempts." >&2
+      mark_retry_exhausted "$attempts" "$last_reason"
+      exit 0
+    fi
+    echo "GPU init failure for $VIDEO_ID on host=$(hostname) gpu=${CUDA_VISIBLE_DEVICES:-unset}; retry attempt $attempts/$MAX_GPU_INIT_RETRIES will be resubmitted later." >&2
+    exit 0
+  fi
+  exit "$cmd_status"
+fi
+
+rm -f "$RETRY_STATE_PATH"

slurm/submit_download_slurm.sh

@@ -0,0 +1,265 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="${ROOT_DIR:-/home/sf895/Sign-DWPose-2M}"
+RUNTIME_ROOT="${RUNTIME_ROOT:-/home/sf895/Sign-DWPose-2M-runtime}"
+STATE_ROOT="${STATE_ROOT:-/home/sf895/Sign-DWPose-2M-runtime}"
+SOURCE_METADATA_CSV="${SOURCE_METADATA_CSV:-$RUNTIME_ROOT/Sign-DWPose-2M-metadata_ori.csv}"
+OUTPUT_METADATA_CSV="${OUTPUT_METADATA_CSV:-$RUNTIME_ROOT/Sign-DWPose-2M-metadata_processed.csv}"
+RAW_VIDEO_DIR="${RAW_VIDEO_DIR:-$RUNTIME_ROOT/raw_video}"
+RAW_CAPTION_DIR="${RAW_CAPTION_DIR:-$RUNTIME_ROOT/raw_caption}"
+RAW_METADATA_DIR="${RAW_METADATA_DIR:-$RUNTIME_ROOT/raw_metadata}"
+DATASET_DIR="${DATASET_DIR:-$RUNTIME_ROOT/dataset}"
+STATS_NPZ="${STATS_NPZ:-$RUNTIME_ROOT/stats.npz}"
+SLURM_SCRIPT="$ROOT_DIR/slurm/process_download_array.slurm"
+MANIFEST_DIR="${MANIFEST_DIR:-$STATE_ROOT/slurm/manifests}"
+LOG_DIR="${LOG_DIR:-$STATE_ROOT/slurm/logs}"
+STATE_DIR="${STATE_DIR:-$STATE_ROOT/slurm/state}"
+DOWNLOAD_CLAIM_DIR="${DOWNLOAD_CLAIM_DIR:-$STATE_DIR/download_claims}"
+LOCK_FILE="$STATE_DIR/submit_download.lock"
+DOWNLOAD_CSV_LOCK_PATH="${DOWNLOAD_CSV_LOCK_PATH:-$STATE_ROOT/Sign-DWPose-2M-metadata_processed.csv.lock}"
+PARTITIONS="main"
+ACCOUNT=""
+TIME_LIMIT="04:00:00"
+CPUS_PER_TASK="1"
+MEMORY="4G"
+LIMIT=""
+ARRAY_PARALLEL=""
+MAX_BACKLOG_VIDEOS="180"
+WORKERS="4"
+VIDEO_IDS=()
+FORCE_METADATA=0
+FORCE_SUBTITLES=0
+FORCE_DOWNLOAD=0
+SKIP_VIDEO_DOWNLOAD=0
+SKIP_SUBTITLES=0
+COOKIES_FROM_BROWSER="${COOKIES_FROM_BROWSER:-}"
+COOKIES_FILE="${COOKIES_FILE:-}"
+EXTRACTOR_ARGS="${EXTRACTOR_ARGS:-}"
+
+usage() {
+  cat <<USAGE
+Usage:
+  bash slurm/submit_download_slurm.sh [options]
+
+Options:
+  --partitions P1[,P2,...]   Comma-separated CPU partitions. Default: main
+  --runtime-root DIR         Shared runtime root
+  --state-root DIR           Shared state/log root
+  --account NAME             Optional Slurm account
+  --time HH:MM:SS            Default: 04:00:00
+  --cpus-per-task N          Default: 1
+  --mem SIZE                 Default: 4G
+  --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
+  --workers N                Max download tasks to submit in one cycle. Default: 4
+  --claim-dir DIR            Download claim directory
+  --csv-lock-path PATH       CSV lock path
+  --video-ids ID [ID ...]    Restrict this cycle to specific videos
+  --force-metadata
+  --force-subtitles
+  --force-download
+  --skip-video-download
+  --skip-subtitles
+  --cookies PATH
+  --cookies-from-browser SPEC
+  --extractor-args TEXT
+  --help
+USAGE
+}
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --partitions) PARTITIONS="$2"; shift 2 ;;
+    --runtime-root) RUNTIME_ROOT="$2"; shift 2 ;;
+    --state-root) STATE_ROOT="$2"; shift 2 ;;
+    --account) ACCOUNT="$2"; shift 2 ;;
+    --time) TIME_LIMIT="$2"; shift 2 ;;
+    --cpus-per-task) CPUS_PER_TASK="$2"; shift 2 ;;
+    --mem) MEMORY="$2"; shift 2 ;;
+    --limit) LIMIT="$2"; shift 2 ;;
+    --array-parallel) ARRAY_PARALLEL="$2"; shift 2 ;;
+    --max-backlog-videos) MAX_BACKLOG_VIDEOS="$2"; shift 2 ;;
+    --workers) WORKERS="$2"; shift 2 ;;
+    --claim-dir) DOWNLOAD_CLAIM_DIR="$2"; shift 2 ;;
+    --csv-lock-path) DOWNLOAD_CSV_LOCK_PATH="$2"; shift 2 ;;
+    --video-ids)
+      shift
+      while [[ $# -gt 0 && "$1" != --* ]]; do
+        VIDEO_IDS+=("$1")
+        shift
+      done
+      ;;
+    --force-metadata) FORCE_METADATA=1; shift ;;
+    --force-subtitles) FORCE_SUBTITLES=1; shift ;;
+    --force-download) FORCE_DOWNLOAD=1; shift ;;
+    --skip-video-download) SKIP_VIDEO_DOWNLOAD=1; shift ;;
+    --skip-subtitles) SKIP_SUBTITLES=1; shift ;;
+    --cookies) COOKIES_FILE="$2"; shift 2 ;;
+    --cookies-from-browser) COOKIES_FROM_BROWSER="$2"; shift 2 ;;
+    --extractor-args) EXTRACTOR_ARGS="$2"; shift 2 ;;
+    -h|--help) usage; exit 0 ;;
+    *) echo "Unknown argument: $1" >&2; usage >&2; exit 1 ;;
+  esac
+done
+
+mkdir -p "$MANIFEST_DIR" "$LOG_DIR" "$DOWNLOAD_CLAIM_DIR" "$STATE_DIR"
+exec 9>"$LOCK_FILE"
+if ! flock -n 9; then
+  echo "Another submit_download_slurm.sh instance is running; skip this cycle."
+  exit 0
+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"
+
+squeue -h -u "$USER" -o "%A" | sed 's/_.*//' | sort -u > "$ACTIVE_JOBS_FILE"
+
+SELECTED_COUNT="$(python - "$SOURCE_METADATA_CSV" "$OUTPUT_METADATA_CSV" "$RAW_VIDEO_DIR" "$DOWNLOAD_CLAIM_DIR" "$ACTIVE_JOBS_FILE" "$MAX_BACKLOG_VIDEOS" "$LIMIT" "$WORKERS" "$BASE_MANIFEST" "${VIDEO_IDS[*]:-}" <<'PY'
+import csv
+import sys
+from pathlib import Path
+
+source_csv = Path(sys.argv[1])
+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])
+limit_arg = sys.argv[7]
+workers = int(sys.argv[8])
+manifest_path = Path(sys.argv[9])
+video_ids_joined = sys.argv[10].strip()
+limit = int(limit_arg) if limit_arg else None
+video_filter = set(video_ids_joined.split()) if video_ids_joined else None
+
+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()}
+
+claim_dir.mkdir(parents=True, exist_ok=True)
+active_claims = set()
+for claim_path in claim_dir.glob('*.claim'):
+    try:
+        lines = claim_path.read_text(encoding='utf-8').splitlines()
+    except OSError:
+        continue
+    job_id = ''
+    pid = None
+    for line in lines:
+        if line.startswith('job_id='):
+            job_id = line.split('=', 1)[1].strip()
+        elif line.startswith('pid='):
+            try:
+                pid = int(line.split('=', 1)[1].strip())
+            except ValueError:
+                pid = None
+    alive = False
+    if job_id:
+        alive = job_id in active_jobs
+    elif pid is not None:
+        try:
+            import os
+            os.kill(pid, 0)
+            alive = True
+        except OSError:
+            alive = False
+    if alive:
+        active_claims.add(claim_path.stem)
+    else:
+        claim_path.unlink(missing_ok=True)
+
+raw_backlog = 0
+existing_raw = set()
+if raw_video_dir.exists():
+    for path in raw_video_dir.iterdir():
+        if path.is_file() and path.suffix.lower() in video_extensions:
+            raw_backlog += 1
+            existing_raw.add(path.stem)
+
+remaining_slots = max(0, max_backlog - raw_backlog - len(active_claims))
+remaining_slots = min(remaining_slots, workers)
+if limit is not None:
+    remaining_slots = min(remaining_slots, limit)
+if remaining_slots <= 0:
+    manifest_path.write_text('', encoding='utf-8')
+    print(0)
+    raise SystemExit
+
+rows = []
+fieldnames = None
+csv_path = processed_csv if processed_csv.exists() else source_csv
+with csv_path.open('r', encoding='utf-8', newline='') as handle:
+    reader = csv.DictReader(handle)
+    fieldnames = reader.fieldnames or []
+    for row in reader:
+        rows.append(row)
+
+selected = []
+for row in rows:
+    video_id = (row.get('video_id') or '').strip()
+    if not video_id:
+        continue
+    if video_filter is not None and video_id not in video_filter:
+        continue
+    if video_id in active_claims or video_id in existing_raw:
+        continue
+    download_status = (row.get('download_status') or '').strip()
+    if download_status in {'ok', 'skipped'}:
+        continue
+    selected.append(video_id)
+    if len(selected) >= remaining_slots:
+        break
+
+manifest_path.write_text(''.join(f'{video_id}\n' for video_id in selected), encoding='utf-8')
+print(len(selected))
+PY
+)"
+rm -f "$ACTIVE_JOBS_FILE"
+
+if [[ "$SELECTED_COUNT" == "0" ]]; then
+  echo "No pending videos to download, or download backlog cap already reached."
+  rm -f "$BASE_MANIFEST"
+  exit 0
+fi
+
+echo "Created manifest: $BASE_MANIFEST"
+echo "Pending videos selected this cycle: $SELECTED_COUNT"
+
+ARRAY_SPEC="0-$((SELECTED_COUNT - 1))"
+if [[ -n "$ARRAY_PARALLEL" ]]; then
+  ARRAY_SPEC+="%$ARRAY_PARALLEL"
+fi
+
+cmd=(sbatch
+  --parsable
+  --partition "$PARTITIONS"
+  --time "$TIME_LIMIT"
+  --cpus-per-task "$CPUS_PER_TASK"
+  --mem "$MEMORY"
+  --array "$ARRAY_SPEC"
+  --output "$LOG_DIR/download_%A_%a.out"
+  --error "$LOG_DIR/download_%A_%a.err"
+  --export "ALL,ROOT_DIR=$ROOT_DIR,RUNTIME_ROOT=$RUNTIME_ROOT,STATE_ROOT=$STATE_ROOT,CONDA_SH=/home/sf895/miniconda3/etc/profile.d/conda.sh,CONDA_ENV=signx2,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,STATS_NPZ=$STATS_NPZ,PIPELINE01=$ROOT_DIR/scripts/pipeline01_download_video_fix_caption.py,DOWNLOAD_CLAIM_DIR=$DOWNLOAD_CLAIM_DIR,DOWNLOAD_CSV_LOCK_PATH=$DOWNLOAD_CSV_LOCK_PATH,MANIFEST=$BASE_MANIFEST,FORCE_METADATA=$FORCE_METADATA,FORCE_SUBTITLES=$FORCE_SUBTITLES,FORCE_DOWNLOAD=$FORCE_DOWNLOAD,SKIP_VIDEO_DOWNLOAD=$SKIP_VIDEO_DOWNLOAD,SKIP_SUBTITLES=$SKIP_SUBTITLES,COOKIES_FILE=$COOKIES_FILE,COOKIES_FROM_BROWSER=$COOKIES_FROM_BROWSER,EXTRACTOR_ARGS=$EXTRACTOR_ARGS"
+)
+if [[ -n "$ACCOUNT" ]]; then
+  cmd+=(--account "$ACCOUNT")
+fi
+cmd+=("$SLURM_SCRIPT")
+
+JOB_ID="$("${cmd[@]}")"
+echo "Submitted download array job: $JOB_ID"
+
+while IFS= read -r video_id; do
+  [[ -z "$video_id" ]] && continue
+  cat > "$DOWNLOAD_CLAIM_DIR/${video_id}.claim" <<CLAIM
+job_id=$JOB_ID
+video_id=$video_id
+submitted_at=$(date '+%F %T')
+CLAIM
+done < "$BASE_MANIFEST"
+
+echo "SUBMITTED_DOWNLOAD_COUNT=$SELECTED_COUNT"

slurm/submit_dwpose_slurm.sh

@@ -15,7 +15,7 @@ LOG_DIR="${LOG_DIR:-$STATE_ROOT/slurm/logs}"
 STATE_DIR="${STATE_DIR:-$STATE_ROOT/slurm/state}"
 CLAIM_DIR="${CLAIM_DIR:-$STATE_DIR/claims}"
 LOCK_FILE="$STATE_DIR/submit.lock"
-PARTITIONS="gpu"
+PARTITIONS="gpu,gpu-redhat,cgpu"
 ACCOUNT=""
 TIME_LIMIT="24:00:00"
 CPUS_PER_TASK="8"
@@ -23,9 +23,10 @@ MEMORY="32G"
 FPS="24"
 LIMIT=""
 ARRAY_PARALLEL=""
-MAX_BACKLOG_VIDEOS="340"
+MAX_BACKLOG_VIDEOS="180"
 FORCE_PROCESS=0
 DELETE_SOURCE_ON_SUCCESS=0
+MAX_PER_NODE=""
 
 usage() {
   cat <<USAGE
@@ -33,98 +34,42 @@ Usage:
   bash slurm/submit_dwpose_slurm.sh [options]
 
 Options:
-  --partitions P1[,P2,...]   Comma-separated partitions. Default: gpu
+  --partitions P1[,P2,...]   Comma-separated partitions. Default: gpu,gpu-redhat,cgpu
   --runtime-root DIR         Shared runtime root for data/state
   --state-root DIR           Shared state/log root (default: runtime root)
-  --account NAME            Optional Slurm account
-  --time HH:MM:SS           Default: 24:00:00
-  --cpus-per-task N         Default: 8
-  --mem SIZE                Default: 32G
-  --fps N                   Default: 24
-  --limit N                 Only submit the first N pending, unclaimed videos this cycle
-  --max-backlog-videos N    Max claimed queued/running videos allowed at once. Default: 340
-  --array-parallel N        Add a %N cap to each array
-  --force-process           Re-run videos even if marked complete
+  --account NAME             Optional Slurm account
+  --time HH:MM:SS            Default: 24:00:00
+  --cpus-per-task N          Default: 8
+  --mem SIZE                 Default: 32G
+  --fps N                    Default: 24
+  --limit N                  Only submit the first N pending, unclaimed videos this cycle
+  --max-backlog-videos N     Max claimed queued/running videos allowed at once. Default: 180
+  --array-parallel N         Add a %N cap to each node-local array
+  --max-per-node N           Cap submissions per node in a cycle
+  --force-process            Re-run videos even if marked complete
   --delete-source-on-success Delete raw videos after successful processing
   --help
-
-Behavior:
-  - Uses a claim directory to avoid resubmitting videos that are already queued/running.
-  - Cleans stale claims whose Slurm jobs are no longer active.
-  - Builds a manifest of pending raw videos.
-  - Submits one Slurm array per partition.
-  - Each array task uses 1 GPU and processes exactly 1 video.
-
-Examples:
-  bash slurm/submit_dwpose_slurm.sh
-  bash slurm/submit_dwpose_slurm.sh --partitions gpu --array-parallel 32
-  bash slurm/submit_dwpose_slurm.sh --partitions gpu --limit 500
 USAGE
 }
 
 while [[ $# -gt 0 ]]; do
   case "$1" in
-    --partitions)
-      PARTITIONS="$2"
-      shift 2
-      ;;
-    --runtime-root)
-      RUNTIME_ROOT="$2"
-      shift 2
-      ;;
-    --state-root)
-      STATE_ROOT="$2"
-      shift 2
-      ;;
-    --account)
-      ACCOUNT="$2"
-      shift 2
-      ;;
-    --time)
-      TIME_LIMIT="$2"
-      shift 2
-      ;;
-    --cpus-per-task)
-      CPUS_PER_TASK="$2"
-      shift 2
-      ;;
-    --mem)
-      MEMORY="$2"
-      shift 2
-      ;;
-    --fps)
-      FPS="$2"
-      shift 2
-      ;;
-    --limit)
-      LIMIT="$2"
-      shift 2
-      ;;
-    --max-backlog-videos)
-      MAX_BACKLOG_VIDEOS="$2"
-      shift 2
-      ;;
-    --array-parallel)
-      ARRAY_PARALLEL="$2"
-      shift 2
-      ;;
-    --force-process)
-      FORCE_PROCESS=1
-      shift
-      ;;
-    --delete-source-on-success)
-      DELETE_SOURCE_ON_SUCCESS=1
-      shift
-      ;;
-    -h|--help)
-      usage
-      exit 0
-      ;;
-    *)
-      echo "Unknown argument: $1" >&2
-      usage >&2
-      exit 1
-      ;;
+    --partitions) PARTITIONS="$2"; shift 2 ;;
+    --runtime-root) RUNTIME_ROOT="$2"; shift 2 ;;
+    --state-root) STATE_ROOT="$2"; shift 2 ;;
+    --account) ACCOUNT="$2"; shift 2 ;;
+    --time) TIME_LIMIT="$2"; shift 2 ;;
+    --cpus-per-task) CPUS_PER_TASK="$2"; shift 2 ;;
+    --mem) MEMORY="$2"; shift 2 ;;
+    --fps) FPS="$2"; shift 2 ;;
+    --limit) LIMIT="$2"; shift 2 ;;
+    --max-backlog-videos) MAX_BACKLOG_VIDEOS="$2"; shift 2 ;;
+    --array-parallel) ARRAY_PARALLEL="$2"; shift 2 ;;
+    --max-per-node) MAX_PER_NODE="$2"; shift 2 ;;
+    --force-process) FORCE_PROCESS=1; shift ;;
+    --delete-source-on-success) DELETE_SOURCE_ON_SUCCESS=1; shift ;;
+    -h|--help) usage; exit 0 ;;
+    *) echo "Unknown argument: $1" >&2; usage >&2; exit 1 ;;
   esac
 done
 
@@ -135,51 +80,43 @@ if ! flock -n 9; then
   exit 0
 fi
 
-IFS=',' read -r -a PARTITION_LIST <<< "$PARTITIONS"
-
 TIMESTAMP="$(date '+%Y%m%d_%H%M%S')"
 BASE_MANIFEST="$MANIFEST_DIR/pending_videos_${TIMESTAMP}.txt"
 ACTIVE_JOBS_FILE="$STATE_DIR/active_jobs_${TIMESTAMP}.txt"
+NODE_SLOTS_FILE="$STATE_DIR/node_slots_${TIMESTAMP}.txt"
+
 squeue -h -u "$USER" -o "%A" | sed 's/_.*//' | sort -u > "$ACTIVE_JOBS_FILE"
 
-PENDING_COUNT="$({
-  cd "$ROOT_DIR"
-  python - "$ROOT_DIR" "$RAW_VIDEO_DIR" "$DATASET_DIR" "$STATS_NPZ" "$LIMIT" "$FORCE_PROCESS" "$BASE_MANIFEST" "$CLAIM_DIR" "$ACTIVE_JOBS_FILE" "$MAX_BACKLOG_VIDEOS" <<'PY'
+PENDING_COUNT="$(python - "$RAW_VIDEO_DIR" "$DATASET_DIR" "$LIMIT" "$FORCE_PROCESS" "$BASE_MANIFEST" "$CLAIM_DIR" "$ACTIVE_JOBS_FILE" "$MAX_BACKLOG_VIDEOS" <<'PY'
 import sys
 from pathlib import Path
 
-root_dir = Path(sys.argv[1])
-raw_video_dir = Path(sys.argv[2])
-dataset_dir = Path(sys.argv[3])
-stats_npz = Path(sys.argv[4])
-limit_arg = sys.argv[5]
-force = sys.argv[6] == "1"
-manifest_path = Path(sys.argv[7])
-claim_dir = Path(sys.argv[8])
-active_jobs_path = Path(sys.argv[9])
-max_backlog = int(sys.argv[10])
+raw_video_dir = Path(sys.argv[1])
+dataset_dir = Path(sys.argv[2])
+limit_arg = sys.argv[3]
+force = sys.argv[4] == '1'
+manifest_path = Path(sys.argv[5])
+claim_dir = Path(sys.argv[6])
+active_jobs_path = Path(sys.argv[7])
+max_backlog = int(sys.argv[8])
 limit = int(limit_arg) if limit_arg else None
 
-sys.path.insert(0, str(root_dir))
-from utils.stats_npz import load_stats
-
-video_extensions = {".mp4", ".mkv", ".webm", ".mov"}
-stats = load_stats(stats_npz)
+video_extensions = {'.mp4', '.mkv', '.webm', '.mov'}
 claim_dir.mkdir(parents=True, exist_ok=True)
 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_jobs = {line.strip() for line in active_jobs_path.read_text(encoding='utf-8').splitlines() if line.strip()}
 
 active_claims = set()
-for claim_path in claim_dir.glob("*.claim"):
+for claim_path in claim_dir.glob('*.claim'):
     try:
-        lines = claim_path.read_text(encoding="utf-8").splitlines()
+        lines = claim_path.read_text(encoding='utf-8').splitlines()
     except OSError:
         continue
-    job_id = ""
+    job_id = ''
     for line in lines:
-        if line.startswith("job_id="):
-            job_id = line.split("=", 1)[1].strip()
+        if line.startswith('job_id='):
+            job_id = line.split('=', 1)[1].strip()
             break
     video_id = claim_path.stem
     if job_id and job_id in active_jobs:
@@ -188,32 +125,26 @@ for claim_path in claim_dir.glob("*.claim"):
         claim_path.unlink(missing_ok=True)
 
 remaining_slots = max(0, max_backlog - len(active_claims))
-if remaining_slots == 0:
-    manifest_path.write_text("", encoding="utf-8")
-    print(0)
-    raise SystemExit(0)
-
 selected = []
-if raw_video_dir.exists():
+if remaining_slots > 0 and raw_video_dir.exists():
     for path in sorted(raw_video_dir.iterdir()):
         if not path.is_file() or path.suffix.lower() not in video_extensions:
             continue
         video_id = path.stem
         if video_id in active_claims:
             continue
-        npz_dir = dataset_dir / video_id / "npz"
-        complete_marker = npz_dir / ".complete"
-        if not force and npz_dir.exists() and complete_marker.exists() and stats.get(video_id, {}).get("process_status") == "ok":
+        complete_marker = dataset_dir / video_id / 'npz' / '.complete'
+        if not force and complete_marker.exists():
             continue
         selected.append(video_id)
         if len(selected) >= remaining_slots:
             break
         if limit is not None and len(selected) >= limit:
             break
-manifest_path.write_text("".join(f"{video_id}\n" for video_id in selected), encoding="utf-8")
+manifest_path.write_text(''.join(f'{video_id}\n' for video_id in selected), encoding='utf-8')
 print(len(selected))
 PY
-})"
+)"
 rm -f "$ACTIVE_JOBS_FILE"
 
 if [[ "$PENDING_COUNT" == "0" ]]; then
@@ -222,8 +153,65 @@ if [[ "$PENDING_COUNT" == "0" ]]; then
   exit 0
 fi
 
+AVAILABLE_SLOTS="$(python - "$PARTITIONS" "$NODE_SLOTS_FILE" "$MAX_PER_NODE" <<'PY'
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+parts = [p for p in sys.argv[1].split(',') if p]
+out_path = Path(sys.argv[2])
+max_per_node_arg = sys.argv[3]
+max_per_node = int(max_per_node_arg) if max_per_node_arg else None
+slots = []
+for part in parts:
+    proc = subprocess.run(['sinfo', '-h', '-N', '-p', part, '-o', '%N'], capture_output=True, text=True, check=False)
+    if proc.returncode != 0:
+        continue
+    nodes = [line.strip() for line in proc.stdout.splitlines() if line.strip()]
+    for node in nodes:
+        node_proc = subprocess.run(['scontrol', 'show', 'node', node, '-o'], capture_output=True, text=True, check=False)
+        if node_proc.returncode != 0:
+            continue
+        line = node_proc.stdout.strip()
+        if not line:
+            continue
+        state_m = re.search(r'\bState=([^ ]+)', line)
+        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+)', line)
+        alloc_m = re.search(r'\bAllocTRES=.*?(?:,|^)gres/gpu=(\d+)', line)
+        total = int(cfg_m.group(1)) if cfg_m else 0
+        used = int(alloc_m.group(1)) if alloc_m else 0
+        free = total - used
+        if max_per_node is not None:
+            free = min(free, max_per_node)
+        if free > 0:
+            slots.append((part, node, free))
+slots.sort(key=lambda item: (-item[2], item[0], item[1]))
+out_path.write_text(''.join(f'{part}\t{node}\t{free}\n' for part, node, free in slots), encoding='utf-8')
+print(sum(free for _, _, free in slots))
+PY
+)"
+
+if [[ -z "$AVAILABLE_SLOTS" || "$AVAILABLE_SLOTS" == "0" ]]; then
+  echo "No free GPU slots detected across requested partitions."
+  rm -f "$BASE_MANIFEST" "$NODE_SLOTS_FILE"
+  exit 0
+fi
+
+TARGET_COUNT="$PENDING_COUNT"
+if [[ "$TARGET_COUNT" -gt "$AVAILABLE_SLOTS" ]]; then
+  TARGET_COUNT="$AVAILABLE_SLOTS"
+  head -n "$TARGET_COUNT" "$BASE_MANIFEST" > "$BASE_MANIFEST.tmp"
+  mv "$BASE_MANIFEST.tmp" "$BASE_MANIFEST"
+fi
+
 echo "Created manifest: $BASE_MANIFEST"
 echo "Pending videos selected this cycle: $PENDING_COUNT"
+echo "Available GPU slots right now: $AVAILABLE_SLOTS"
+echo "Submitting now: $TARGET_COUNT"
 
 write_claims() {
   local manifest="$1"
@@ -238,32 +226,32 @@ CLAIM
   done < "$manifest"
 }
 
-submit_partition() {
+submit_node() {
   local partition="$1"
-  local manifest="$2"
-  local count="$3"
+  local node="$2"
+  local manifest="$3"
+  local count="$4"
   local array_spec="0-$((count - 1))"
   local job_output job_id
   if [[ -n "$ARRAY_PARALLEL" ]]; then
     array_spec+="%${ARRAY_PARALLEL}"
   fi
-
   local -a cmd=(sbatch
     --partition "$partition"
+    --nodelist "$node"
     --array "$array_spec"
     --cpus-per-task "$CPUS_PER_TASK"
     --mem "$MEMORY"
     --time "$TIME_LIMIT"
-    --output "$LOG_DIR/dwpose_${partition}_%A_%a.out"
-    --error "$LOG_DIR/dwpose_${partition}_%A_%a.err"
+    --output "$LOG_DIR/dwpose_${partition}_${node}_%A_%a.out"
+    --error "$LOG_DIR/dwpose_${partition}_${node}_%A_%a.err"
     --export "ALL,ROOT_DIR=$ROOT_DIR,RUNTIME_ROOT=$RUNTIME_ROOT,STATE_ROOT=$STATE_ROOT,CONDA_SH=$CONDA_SH,CONDA_ENV=$CONDA_ENV,RAW_VIDEO_DIR=$RAW_VIDEO_DIR,DATASET_DIR=$DATASET_DIR,STATS_NPZ=$STATS_NPZ,FPS=$FPS,FORCE_PROCESS=$FORCE_PROCESS,DELETE_SOURCE_ON_SUCCESS=$DELETE_SOURCE_ON_SUCCESS,MANIFEST=$manifest,CLAIM_DIR=$CLAIM_DIR"
   )
   if [[ -n "$ACCOUNT" ]]; then
     cmd+=(--account "$ACCOUNT")
   fi
   cmd+=("$SLURM_SCRIPT")
-
-  echo "Submitting partition=$partition array=$array_spec manifest=$manifest"
+  echo "Submitting partition=$partition node=$node array=$array_spec manifest=$manifest"
   job_output="$("${cmd[@]}")"
   echo "$job_output"
   job_id="$(awk '/Submitted batch job/ {print $4}' <<< "$job_output" | tail -n 1)"
@@ -274,21 +262,37 @@ submit_partition() {
   write_claims "$manifest" "$job_id"
 }
 
-if [[ ${#PARTITION_LIST[@]} -eq 1 ]]; then
-  submit_partition "${PARTITION_LIST[0]}" "$BASE_MANIFEST" "$PENDING_COUNT"
-  echo "SUBMITTED_VIDEO_COUNT=$PENDING_COUNT"
-  exit 0
-fi
-
-for idx in "${!PARTITION_LIST[@]}"; do
-  shard_manifest="$MANIFEST_DIR/pending_videos_${TIMESTAMP}.part${idx}.txt"
-  awk -v mod="${#PARTITION_LIST[@]}" -v rem="$idx" '((NR-1) % mod) == rem { print }' "$BASE_MANIFEST" > "$shard_manifest"
-  shard_count="$(wc -l < "$shard_manifest" | tr -d '[:space:]')"
+submitted_total=0
+failed_nodes=0
+line_no=1
+while IFS=$'\t' read -r partition node free_slots; do
+  [[ -z "$partition" ]] && continue
+  if [[ "$submitted_total" -ge "$TARGET_COUNT" ]]; then
+    break
+  fi
+  remaining=$((TARGET_COUNT - submitted_total))
+  assign_count="$free_slots"
+  if [[ "$assign_count" -gt "$remaining" ]]; then
+    assign_count="$remaining"
+  fi
+  shard_manifest="$MANIFEST_DIR/pending_videos_${TIMESTAMP}.${partition}.${node}.txt"
+  sed -n "${line_no},$((line_no + assign_count - 1))p" "$BASE_MANIFEST" > "$shard_manifest"
+  shard_count="$(wc -l < "$shard_manifest" | tr -d [:space:])"
   if [[ "$shard_count" == "0" ]]; then
     rm -f "$shard_manifest"
     continue
   fi
-  submit_partition "${PARTITION_LIST[$idx]}" "$shard_manifest" "$shard_count"
-done
+  if submit_node "$partition" "$node" "$shard_manifest" "$shard_count"; then
+    submitted_total=$((submitted_total + shard_count))
+    line_no=$((line_no + shard_count))
+  else
+    echo "Node-local submit failed for partition=$partition node=$node; leaving those videos unclaimed for later nodes or the next cycle." >&2
+    rm -f "$shard_manifest"
+    failed_nodes=$((failed_nodes + 1))
+    continue
+  fi
+done < "$NODE_SLOTS_FILE"
 
-echo "SUBMITTED_VIDEO_COUNT=$PENDING_COUNT"
+echo "SUBMITTED_VIDEO_COUNT=$submitted_total"
+echo "FAILED_NODE_SUBMITS=$failed_nodes"
+rm -f "$NODE_SLOTS_FILE"

slurm/watch_submit_dwpose.slurm

@@ -12,12 +12,12 @@ set -euo pipefail
 
 ROOT_DIR="${ROOT_DIR:-$(cd "$(dirname "$0")/.." && pwd)}"
 SUBMIT_SCRIPT="${SUBMIT_SCRIPT:-$ROOT_DIR/slurm/submit_dwpose_slurm.sh}"
-GPU_PARTITIONS="${GPU_PARTITIONS:-gpu}"
+GPU_PARTITIONS="${GPU_PARTITIONS:-gpu,gpu-redhat,cgpu}"
 GPU_ACCOUNT="${GPU_ACCOUNT:-}"
 SCAN_INTERVAL_SECONDS="${SCAN_INTERVAL_SECONDS:-60}"
-SUBMIT_LIMIT="${SUBMIT_LIMIT:-200}"
+SUBMIT_LIMIT="${SUBMIT_LIMIT:-180}"
 ARRAY_PARALLEL="${ARRAY_PARALLEL:-}"
-MAX_BACKLOG_VIDEOS="${MAX_BACKLOG_VIDEOS:-340}"
+MAX_BACKLOG_VIDEOS="${MAX_BACKLOG_VIDEOS:-180}"
 FPS="${FPS:-24}"
 MAX_ITERATIONS="${MAX_ITERATIONS:-0}"
 FORCE_PROCESS="${FORCE_PROCESS:-0}"

utils/stats_npz.py

@@ -1,4 +1,7 @@
 import fcntl
+import os
+import time
+import zipfile
 from pathlib import Path
 from typing import Dict, Iterable
 
@@ -28,8 +31,12 @@ STATUS_FIELDS = [
 ]
 
 
-def load_stats(stats_path: Path) -> Dict[str, Dict[str, str]]:
-    if not stats_path.exists():
+def _lock_path(stats_path: Path) -> Path:
+    return stats_path.with_suffix(stats_path.suffix + ".lock")
+
+
+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)
@@ -44,15 +51,37 @@ def load_stats(stats_path: Path) -> Dict[str, Dict[str, str]]:
     return stats
 
 
+def load_stats(stats_path: Path, retries: int = 8, retry_delay: float = 0.2) -> Dict[str, Dict[str, str]]:
+    if not stats_path.exists():
+        return {}
+
+    lock_path = _lock_path(stats_path)
+    lock_path.parent.mkdir(parents=True, exist_ok=True)
+    last_error: Exception | None = None
+    for _ in range(retries):
+        with lock_path.open("a+", encoding="utf-8") as handle:
+            fcntl.flock(handle.fileno(), fcntl.LOCK_SH)
+            try:
+                return _load_stats_unlocked(stats_path)
+            except (EOFError, ValueError, OSError, zipfile.BadZipFile) as exc:
+                last_error = exc
+            finally:
+                fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+        time.sleep(retry_delay)
+    if last_error is not None:
+        raise last_error
+    return {}
+
+
 def save_stats(stats_path: Path, stats: Dict[str, Dict[str, str]]) -> None:
     stats_path.parent.mkdir(parents=True, exist_ok=True)
     video_ids = sorted(stats)
     payload = {"video_ids": np.asarray(video_ids, dtype=object)}
     for field in STATUS_FIELDS:
         payload[field] = np.asarray([stats[video_id].get(field, "") for video_id in video_ids], dtype=object)
-    tmp_path = stats_path.parent / f".{stats_path.stem}.tmp.npz"
+    tmp_path = stats_path.parent / f".{stats_path.stem}.{os.getpid()}.tmp.npz"
     np.savez(tmp_path, **payload)
-    tmp_path.replace(stats_path)
+    os.replace(tmp_path, stats_path)
 
 
 def ensure_record(stats: Dict[str, Dict[str, str]], video_id: str) -> Dict[str, str]:
@@ -61,16 +90,12 @@ def ensure_record(stats: Dict[str, Dict[str, str]], video_id: str) -> Dict[str,
     return stats[video_id]
 
 
-def _lock_path(stats_path: Path) -> Path:
-    return stats_path.with_suffix(stats_path.suffix + ".lock")
-
-
 def update_video_stats(stats_path: Path, video_id: str, **updates: str) -> Dict[str, str]:
     lock_path = _lock_path(stats_path)
     lock_path.parent.mkdir(parents=True, exist_ok=True)
-    with lock_path.open("w", encoding="utf-8") as handle:
+    with lock_path.open("a+", encoding="utf-8") as handle:
         fcntl.flock(handle.fileno(), fcntl.LOCK_EX)
-        stats = load_stats(stats_path)
+        stats = _load_stats_unlocked(stats_path)
         record = ensure_record(stats, video_id)
         for key, value in updates.items():
             if key in STATUS_FIELDS:
@@ -83,9 +108,9 @@ def update_video_stats(stats_path: Path, video_id: str, **updates: str) -> Dict[
 def update_many_video_stats(stats_path: Path, video_ids: Iterable[str], **updates: str) -> None:
     lock_path = _lock_path(stats_path)
     lock_path.parent.mkdir(parents=True, exist_ok=True)
-    with lock_path.open("w", encoding="utf-8") as handle:
+    with lock_path.open("a+", encoding="utf-8") as handle:
         fcntl.flock(handle.fileno(), fcntl.LOCK_EX)
-        stats = load_stats(stats_path)
+        stats = _load_stats_unlocked(stats_path)
         for video_id in video_ids:
             record = ensure_record(stats, video_id)
             for key, value in updates.items():
@@ -93,3 +118,17 @@ def update_many_video_stats(stats_path: Path, video_ids: Iterable[str], **update
                     record[key] = "" if value is None else str(value)
         save_stats(stats_path, stats)
         fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+
+
+def update_many_video_stats_with_retry(stats_path: Path, video_ids: Iterable[str], retries: int = 8, retry_delay: float = 0.2, **updates: str) -> None:
+    last_error: Exception | None = None
+    for _ in range(retries):
+        try:
+            update_many_video_stats(stats_path, video_ids, **updates)
+            return
+        except (EOFError, ValueError, OSError, zipfile.BadZipFile) as exc:
+            last_error = exc
+            time.sleep(retry_delay)
+    if last_error is not None:
+        raise last_error
+