Add Slurm orchestration and downloader fixes

reproduce_independently_slurm.sh

@@ -0,0 +1,746 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="${ROOT_DIR:-$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)}"
+CONDA_SH="${CONDA_SH:-/home/sf895/miniconda3/etc/profile.d/conda.sh}"
+CONDA_ENV="${CONDA_ENV:-signx2}"
+
+SOURCE_METADATA_CSV="${SOURCE_METADATA_CSV:-$ROOT_DIR/Sign-DWPose-2M-metadata_ori.csv}"
+OUTPUT_METADATA_CSV="${OUTPUT_METADATA_CSV:-$ROOT_DIR/Sign-DWPose-2M-metadata_processed.csv}"
+RAW_VIDEO_DIR="${RAW_VIDEO_DIR:-$ROOT_DIR/raw_video}"
+RAW_CAPTION_DIR="${RAW_CAPTION_DIR:-$ROOT_DIR/raw_caption}"
+RAW_METADATA_DIR="${RAW_METADATA_DIR:-$ROOT_DIR/raw_metadata}"
+DATASET_DIR="${DATASET_DIR:-$ROOT_DIR/dataset}"
+ARCHIVE_DIR="${ARCHIVE_DIR:-$ROOT_DIR/archives}"
+STATS_NPZ="${STATS_NPZ:-$ROOT_DIR/stats.npz}"
+PROGRESS_JSON="${PROGRESS_JSON:-$ROOT_DIR/archive_upload_progress.json}"
+
+PIPELINE01="${PIPELINE01:-$ROOT_DIR/scripts/pipeline01_download_video_fix_caption.py}"
+PIPELINE02="${PIPELINE02:-$ROOT_DIR/scripts/pipeline02_extract_dwpose_from_video.py}"
+PIPELINE03="${PIPELINE03:-$ROOT_DIR/scripts/pipeline03_upload_to_huggingface.py}"
+
+STAGE="${STAGE:-all}"
+LIMIT="${LIMIT:-}"
+VIDEO_IDS=()
+FPS="${FPS:-24}"
+WORKERS="${WORKERS:-}"
+TARGET_BYTES="${TARGET_BYTES:-$((14 * 1024 * 1024 * 1024))}"
+DOWNLOAD_BATCH_SIZE="${DOWNLOAD_BATCH_SIZE:-1}"
+PROCESS_BATCH_SIZE="${PROCESS_BATCH_SIZE:-}"
+MIN_PROCESS_START_BACKLOG="${MIN_PROCESS_START_BACKLOG:-4}"
+RAW_BACKLOG_LIMIT="${RAW_BACKLOG_LIMIT:-340}"
+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_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}"
+GPU_ACCOUNT="${GPU_ACCOUNT:-}"
+ARRAY_PARALLEL="${ARRAY_PARALLEL:-}"
+MAX_BACKLOG_VIDEOS="${MAX_BACKLOG_VIDEOS:-340}"
+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_MEM="${ORCHESTRATOR_MEM:-8G}"
+RUN_LOCAL="${RUN_LOCAL:-0}"
+
+FORCE_METADATA="${FORCE_METADATA:-0}"
+FORCE_SUBTITLES="${FORCE_SUBTITLES:-0}"
+FORCE_DOWNLOAD="${FORCE_DOWNLOAD:-0}"
+FORCE_PROCESS="${FORCE_PROCESS:-0}"
+SKIP_VIDEO_DOWNLOAD="${SKIP_VIDEO_DOWNLOAD:-0}"
+SKIP_SUBTITLES="${SKIP_SUBTITLES:-0}"
+DRY_RUN_UPLOAD="${DRY_RUN_UPLOAD:-0}"
+
+print_usage() {
+  cat <<EOF
+Usage:
+  bash reproduce_independently_slurm.sh [options]
+
+Options:
+  --stage {all,download,process,upload}
+  --limit N                 For stage=process/all, cap total videos submitted in this run
+  --video-id ID
+  --video-ids "ID1 ID2 ..."
+  --fps N
+  --workers N
+  --gpu-partitions P1[,P2,...]
+  --gpu-account NAME
+  --array-parallel N
+  --max-backlog-videos N
+  --min-process-start-backlog N
+  --orchestrator-partition NAME
+  --orchestrator-account NAME
+  --orchestrator-time HH:MM:SS
+  --orchestrator-cpus-per-task N
+  --orchestrator-mem SIZE
+  --run-local
+  --target-bytes N
+  --download-batch-size N
+  --process-batch-size N
+  --raw-backlog-limit N
+  --max-raw-video-bytes N
+  --max-iterations N
+  --idle-sleep-seconds N
+  --repo-id REPO
+  --cookies FILE
+  --cookies-from-browser BROWSER
+  --extractor-args VALUE
+  --force-metadata
+  --force-subtitles
+  --force-download
+  --force-process
+  --skip-video-download
+  --skip-subtitles
+  --dry-run-upload
+  --help
+
+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 --stage all --run-local
+EOF
+}
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --stage)
+      STAGE="$2"
+      shift 2
+      ;;
+    --limit)
+      LIMIT="$2"
+      shift 2
+      ;;
+    --video-id)
+      VIDEO_IDS+=("$2")
+      shift 2
+      ;;
+    --video-ids)
+      IFS=' ' read -r -a EXTRA_IDS <<< "$2"
+      VIDEO_IDS+=("${EXTRA_IDS[@]}")
+      shift 2
+      ;;
+    --fps)
+      FPS="$2"
+      shift 2
+      ;;
+    --workers)
+      WORKERS="$2"
+      shift 2
+      ;;
+    --gpu-partitions)
+      GPU_PARTITIONS="$2"
+      shift 2
+      ;;
+    --gpu-account)
+      GPU_ACCOUNT="$2"
+      shift 2
+      ;;
+    --array-parallel)
+      ARRAY_PARALLEL="$2"
+      shift 2
+      ;;
+    --max-backlog-videos)
+      MAX_BACKLOG_VIDEOS="$2"
+      shift 2
+      ;;
+    --min-process-start-backlog)
+      MIN_PROCESS_START_BACKLOG="$2"
+      shift 2
+      ;;
+    --orchestrator-partition)
+      ORCHESTRATOR_PARTITION="$2"
+      shift 2
+      ;;
+    --orchestrator-account)
+      ORCHESTRATOR_ACCOUNT="$2"
+      shift 2
+      ;;
+    --orchestrator-time)
+      ORCHESTRATOR_TIME="$2"
+      shift 2
+      ;;
+    --orchestrator-cpus-per-task)
+      ORCHESTRATOR_CPUS_PER_TASK="$2"
+      shift 2
+      ;;
+    --orchestrator-mem)
+      ORCHESTRATOR_MEM="$2"
+      shift 2
+      ;;
+    --run-local)
+      RUN_LOCAL=1
+      shift
+      ;;
+    --target-bytes)
+      TARGET_BYTES="$2"
+      shift 2
+      ;;
+    --download-batch-size)
+      DOWNLOAD_BATCH_SIZE="$2"
+      shift 2
+      ;;
+    --process-batch-size)
+      PROCESS_BATCH_SIZE="$2"
+      shift 2
+      ;;
+    --raw-backlog-limit)
+      RAW_BACKLOG_LIMIT="$2"
+      shift 2
+      ;;
+    --max-raw-video-bytes)
+      MAX_RAW_VIDEO_BYTES="$2"
+      shift 2
+      ;;
+    --max-iterations)
+      MAX_ITERATIONS="$2"
+      shift 2
+      ;;
+    --idle-sleep-seconds)
+      IDLE_SLEEP_SECONDS="$2"
+      shift 2
+      ;;
+    --repo-id)
+      REPO_ID="$2"
+      shift 2
+      ;;
+    --cookies)
+      COOKIES_FILE="$2"
+      shift 2
+      ;;
+    --cookies-from-browser)
+      COOKIES_FROM_BROWSER="$2"
+      shift 2
+      ;;
+    --extractor-args)
+      EXTRACTOR_ARGS="$2"
+      shift 2
+      ;;
+    --force-metadata)
+      FORCE_METADATA=1
+      shift
+      ;;
+    --force-subtitles)
+      FORCE_SUBTITLES=1
+      shift
+      ;;
+    --force-download)
+      FORCE_DOWNLOAD=1
+      shift
+      ;;
+    --force-process)
+      FORCE_PROCESS=1
+      shift
+      ;;
+    --skip-video-download)
+      SKIP_VIDEO_DOWNLOAD=1
+      shift
+      ;;
+    --skip-subtitles)
+      SKIP_SUBTITLES=1
+      shift
+      ;;
+    --dry-run-upload)
+      DRY_RUN_UPLOAD=1
+      shift
+      ;;
+    -h|--help)
+      print_usage
+      exit 0
+      ;;
+    *)
+      echo "Unknown argument: $1" >&2
+      print_usage
+      exit 1
+      ;;
+  esac
+done
+
+if [[ ! -f "$CONDA_SH" ]]; then
+  echo "Missing conda init script: $CONDA_SH" >&2
+  exit 1
+fi
+
+if [[ "$STAGE" != "all" && "$STAGE" != "download" && "$STAGE" != "process" && "$STAGE" != "upload" ]]; then
+  echo "Invalid --stage: $STAGE" >&2
+  exit 1
+fi
+
+if [[ -z "${SLURM_JOB_ID:-}" && "$RUN_LOCAL" != "1" ]]; then
+  wrapper="$ROOT_DIR/slurm/run_reproduce_independently_slurm.slurm"
+  if [[ ! -f "$wrapper" ]]; then
+    echo "Missing orchestration wrapper: $wrapper" >&2
+    exit 1
+  fi
+  export_args="ALL,ROOT_DIR=$ROOT_DIR,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"
+  if [[ ${#VIDEO_IDS[@]} -gt 0 ]]; then
+    export VIDEO_IDS_JOINED
+    VIDEO_IDS_JOINED="${VIDEO_IDS[*]}"
+    export_args+=",VIDEO_IDS_JOINED=$VIDEO_IDS_JOINED"
+  fi
+  cmd=(sbatch
+    --partition "$ORCHESTRATOR_PARTITION"
+    --time "$ORCHESTRATOR_TIME"
+    --cpus-per-task "$ORCHESTRATOR_CPUS_PER_TASK"
+    --mem "$ORCHESTRATOR_MEM"
+    --export "$export_args"
+  )
+  if [[ -n "$ORCHESTRATOR_ACCOUNT" ]]; then
+    cmd+=(--account "$ORCHESTRATOR_ACCOUNT")
+  fi
+  cmd+=("$wrapper")
+  echo "Submitting full orchestration job on partition=$ORCHESTRATOR_PARTITION stage=$STAGE"
+  "${cmd[@]}"
+  exit 0
+fi
+
+if [[ -n "${VIDEO_IDS_JOINED:-}" && ${#VIDEO_IDS[@]} -eq 0 ]]; then
+  IFS=' ' read -r -a VIDEO_IDS <<< "$VIDEO_IDS_JOINED"
+fi
+
+mkdir -p "$RAW_VIDEO_DIR" "$RAW_CAPTION_DIR" "$RAW_METADATA_DIR" "$DATASET_DIR"
+if [[ ! -x "$SLURM_PROCESS_SUBMIT_SCRIPT" ]]; then
+  echo "Missing Slurm submit script: $SLURM_PROCESS_SUBMIT_SCRIPT" >&2
+  exit 1
+fi
+
+run_in_dwpose() {
+  # shellcheck disable=SC1090
+  source "$CONDA_SH"
+  CONDA_NO_PLUGINS=true conda run -n "$CONDA_ENV" "$@"
+}
+
+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")
+  fi
+
+  run_in_dwpose "${cmd[@]}"
+}
+
+RUN_PROCESS_STAGE_SUBMITTED_COUNT=0
+
+run_process_stage() {
+  local stage_limit="${1:-$LIMIT}"
+  local cmd=(bash "$SLURM_PROCESS_SUBMIT_SCRIPT"
+    --partitions "$GPU_PARTITIONS"
+    --fps "$FPS"
+    --max-backlog-videos "$MAX_BACKLOG_VIDEOS"
+    --delete-source-on-success
+  )
+  local output status submitted_count
+
+  if [[ -n "$stage_limit" ]]; then
+    cmd+=(--limit "$stage_limit")
+  fi
+  if [[ -n "$ARRAY_PARALLEL" ]]; then
+    cmd+=(--array-parallel "$ARRAY_PARALLEL")
+  fi
+  if [[ -n "$GPU_ACCOUNT" ]]; then
+    cmd+=(--account "$GPU_ACCOUNT")
+  fi
+  if [[ $FORCE_PROCESS -eq 1 ]]; then
+    cmd+=(--force-process)
+  fi
+
+  output="$("${cmd[@]}")"
+  status=$?
+  printf '%s
+' "$output"
+  submitted_count="$(awk -F= '/^SUBMITTED_VIDEO_COUNT=/{print $2}' <<< "$output" | tail -n 1)"
+  RUN_PROCESS_STAGE_SUBMITTED_COUNT="${submitted_count:-0}"
+  return "$status"
+}
+
+run_upload_stage() {
+  local require_target="${1:-0}"
+  local cmd=(python "$PIPELINE03"
+    --dataset-dir "$DATASET_DIR"
+    --raw-video-dir "$RAW_VIDEO_DIR"
+    --raw-caption-dir "$RAW_CAPTION_DIR"
+    --raw-metadata-dir "$RAW_METADATA_DIR"
+    --archive-dir "$ARCHIVE_DIR"
+    --progress-path "$PROGRESS_JSON"
+    --stats-npz "$STATS_NPZ"
+    --repo-id "$REPO_ID"
+    --target-bytes "$TARGET_BYTES"
+  )
+
+  if [[ "$require_target" == "1" ]]; then
+    cmd+=(--require-target-bytes)
+  fi
+  if [[ $DRY_RUN_UPLOAD -eq 1 ]]; then
+    cmd+=(--dry-run)
+  fi
+
+  run_in_dwpose "${cmd[@]}"
+}
+
+prune_processed_raw_videos() {
+  python - <<PY
+from pathlib import Path
+raw_dir = Path("$RAW_VIDEO_DIR")
+dataset_dir = Path("$DATASET_DIR")
+deleted = 0
+if raw_dir.exists():
+    for video_path in raw_dir.iterdir():
+        if not video_path.is_file():
+            continue
+        marker = dataset_dir / video_path.stem / "npz" / ".complete"
+        if marker.exists():
+            video_path.unlink(missing_ok=True)
+            deleted += 1
+print(deleted)
+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
+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")
+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
+print(pending)
+PY
+}
+
+count_pending_process() {
+  python - <<PY
+from pathlib import Path
+raw_dir = Path("$RAW_VIDEO_DIR")
+pending = 0
+if raw_dir.exists():
+    for video_path in raw_dir.iterdir():
+        if video_path.is_file():
+            pending += 1
+print(pending)
+PY
+}
+
+count_active_process_claims() {
+  python - <<PY
+import subprocess
+from pathlib import Path
+claim_dir = Path("$ROOT_DIR/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)
+    active_jobs = {line.split("_", 1)[0].strip() for line in result.stdout.splitlines() if line.strip()}
+except Exception:
+    active_jobs = set()
+count = 0
+for claim_path in claim_dir.glob("*.claim"):
+    try:
+        lines = claim_path.read_text(encoding="utf-8").splitlines()
+    except OSError:
+        continue
+    job_id = ""
+    for line in lines:
+        if line.startswith("job_id="):
+            job_id = line.split("=", 1)[1].strip()
+            break
+    if job_id and job_id in active_jobs:
+        count += 1
+    else:
+        claim_path.unlink(missing_ok=True)
+print(count)
+PY
+}
+
+count_complete_pending_upload() {
+  python - <<PY
+import json
+from pathlib import Path
+dataset_dir = Path("$DATASET_DIR")
+progress_path = Path("$PROGRESS_JSON")
+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
+print(count)
+PY
+}
+
+bytes_complete_pending_upload() {
+  python - <<PY
+import json
+from pathlib import Path
+dataset_dir = Path("$DATASET_DIR")
+progress_path = Path("$PROGRESS_JSON")
+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
+print(total)
+PY
+}
+
+download_loop() {
+  local iteration=0
+  while true; do
+    iteration=$((iteration + 1))
+    local pruned
+    pruned="$(prune_processed_raw_videos)"
+    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"
+
+    if [[ "$MAX_ITERATIONS" -gt 0 && "$iteration" -gt "$MAX_ITERATIONS" ]]; then
+      echo "[download] reached max iterations: $MAX_ITERATIONS"
+      break
+    fi
+    if [[ "$pending_download" -eq 0 ]]; then
+      echo "[download] nothing left to download"
+      break
+    fi
+    if [[ "$pending_process" -ge "$RAW_BACKLOG_LIMIT" ]]; then
+      echo "[download] backpressure: raw backlog $pending_process >= limit $RAW_BACKLOG_LIMIT"
+      sleep "$IDLE_SLEEP_SECONDS"
+      continue
+    fi
+    if [[ "$MAX_RAW_VIDEO_BYTES" -gt 0 && "$raw_video_bytes" -ge "$MAX_RAW_VIDEO_BYTES" ]]; then
+      echo "[download] backpressure: raw_video_bytes $raw_video_bytes >= limit $MAX_RAW_VIDEO_BYTES"
+      sleep "$IDLE_SLEEP_SECONDS"
+      continue
+    fi
+
+    if ! run_download_stage "$DOWNLOAD_BATCH_SIZE"; then
+      echo "[download] pipeline01 failed; retry after sleep"
+      sleep "$IDLE_SLEEP_SECONDS"
+    fi
+  done
+}
+
+process_loop() {
+  local iteration=0
+  local submitted_total=0
+  while true; do
+    iteration=$((iteration + 1))
+    local pruned
+    pruned="$(prune_processed_raw_videos)"
+    local pending_download pending_process active_process_claims remaining_limit cycle_limit
+    pending_download="$(count_pending_downloads)"
+    pending_process="$(count_pending_process)"
+    active_process_claims="$(count_active_process_claims)"
+    echo "[process] iteration=$iteration pending_download=$pending_download raw_backlog=$pending_process slurm_backlog=$active_process_claims submitted_total=$submitted_total pruned_raw_videos=$pruned"
+
+    if [[ "$MAX_ITERATIONS" -gt 0 && "$iteration" -gt "$MAX_ITERATIONS" ]]; then
+      echo "[process] reached max iterations: $MAX_ITERATIONS"
+      break
+    fi
+    if [[ -n "$LIMIT" ]]; then
+      remaining_limit=$((LIMIT - submitted_total))
+      if [[ "$remaining_limit" -le 0 ]]; then
+        if [[ "$active_process_claims" -eq 0 ]]; then
+          echo "[process] reached submission limit: $submitted_total >= $LIMIT"
+          break
+        fi
+        echo "[process] submission limit reached; waiting for in-flight tasks to finish"
+        sleep "$IDLE_SLEEP_SECONDS"
+        continue
+      fi
+    else
+      remaining_limit=-1
+    fi
+    if [[ "$pending_process" -eq 0 ]]; then
+      if [[ "$pending_download" -eq 0 && "$active_process_claims" -eq 0 ]]; then
+        echo "[process] nothing left to process"
+        break
+      fi
+      sleep "$IDLE_SLEEP_SECONDS"
+      continue
+    fi
+    if [[ "$active_process_claims" -eq 0 && "$pending_process" -lt "$MIN_PROCESS_START_BACKLOG" && "$pending_download" -gt 0 ]]; then
+      echo "[process] waiting for minimum raw backlog: $pending_process < $MIN_PROCESS_START_BACKLOG"
+      sleep "$IDLE_SLEEP_SECONDS"
+      continue
+    fi
+    if [[ "$active_process_claims" -ge "$MAX_BACKLOG_VIDEOS" ]]; then
+      echo "[process] backpressure: slurm backlog $active_process_claims >= limit $MAX_BACKLOG_VIDEOS"
+      sleep "$IDLE_SLEEP_SECONDS"
+      continue
+    fi
+
+    cycle_limit="$PROCESS_BATCH_SIZE"
+    if [[ "$remaining_limit" -gt 0 && "$remaining_limit" -lt "$cycle_limit" ]]; then
+      cycle_limit="$remaining_limit"
+    fi
+
+    if ! run_process_stage "$cycle_limit"; then
+      echo "[process] slurm submit failed; retry after sleep"
+      sleep "$IDLE_SLEEP_SECONDS"
+    else
+      submitted_total=$((submitted_total + RUN_PROCESS_STAGE_SUBMITTED_COUNT))
+    fi
+    sleep "$IDLE_SLEEP_SECONDS"
+  done
+}
+
+upload_loop() {
+  local iteration=0
+  while true; do
+    iteration=$((iteration + 1))
+    local pruned
+    pruned="$(prune_processed_raw_videos)"
+    local pending_download pending_process complete_pending_upload complete_pending_upload_bytes
+    pending_download="$(count_pending_downloads)"
+    pending_process="$(count_pending_process)"
+    complete_pending_upload="$(count_complete_pending_upload)"
+    complete_pending_upload_bytes="$(bytes_complete_pending_upload)"
+    echo "[upload] iteration=$iteration pending_download=$pending_download raw_backlog=$pending_process complete_pending_upload=$complete_pending_upload complete_pending_upload_bytes=$complete_pending_upload_bytes pruned_raw_videos=$pruned"
+
+    if [[ "$MAX_ITERATIONS" -gt 0 && "$iteration" -gt "$MAX_ITERATIONS" ]]; then
+      echo "[upload] reached max iterations: $MAX_ITERATIONS"
+      break
+    fi
+    if [[ "$complete_pending_upload" -eq 0 ]]; then
+      if [[ "$pending_download" -eq 0 && "$pending_process" -eq 0 ]]; then
+        echo "[upload] nothing left to upload"
+        break
+      fi
+      sleep "$IDLE_SLEEP_SECONDS"
+      continue
+    fi
+
+    if [[ "$complete_pending_upload_bytes" -lt "$TARGET_BYTES" && ( "$pending_download" -gt 0 || "$pending_process" -gt 0 ) ]]; then
+      sleep "$IDLE_SLEEP_SECONDS"
+      continue
+    fi
+
+    local require_target=1
+    if [[ "$pending_download" -eq 0 && "$pending_process" -eq 0 ]]; then
+      require_target=0
+    fi
+    if ! run_upload_stage "$require_target"; then
+      echo "[upload] pipeline03 failed; retry after sleep"
+      sleep "$IDLE_SLEEP_SECONDS"
+    fi
+  done
+}
+
+cleanup_background_jobs() {
+  local jobs_to_kill=("$@")
+  for job_pid in "${jobs_to_kill[@]}"; do
+    if [[ -n "$job_pid" ]] && kill -0 "$job_pid" 2>/dev/null; then
+      kill "$job_pid" 2>/dev/null || true
+    fi
+  done
+}
+
+run_all_loop() {
+  DOWNLOAD_LOOP_PID=""
+  PROCESS_LOOP_PID=""
+  UPLOAD_LOOP_PID=""
+
+  download_loop &
+  DOWNLOAD_LOOP_PID=$!
+  process_loop &
+  PROCESS_LOOP_PID=$!
+  upload_loop &
+  UPLOAD_LOOP_PID=$!
+
+  trap 'cleanup_background_jobs "$DOWNLOAD_LOOP_PID" "$PROCESS_LOOP_PID" "$UPLOAD_LOOP_PID"' INT TERM EXIT
+
+  wait "$DOWNLOAD_LOOP_PID"
+  wait "$PROCESS_LOOP_PID"
+  wait "$UPLOAD_LOOP_PID"
+
+  trap - INT TERM EXIT
+}
+
+case "$STAGE" in
+  download)
+    run_download_stage
+    ;;
+  process)
+    run_process_stage
+    ;;
+  upload)
+    run_upload_stage
+    ;;
+  all)
+    run_all_loop
+    ;;
+esac

scripts/pipeline01_download_video_fix_caption.py

@@ -29,7 +29,7 @@ DEFAULT_RAW_CAPTION_DIR = REPO_ROOT / "raw_caption"
 DEFAULT_RAW_METADATA_DIR = REPO_ROOT / "raw_metadata"
 DEFAULT_DATASET_DIR = REPO_ROOT / "dataset"
 DEFAULT_STATS_NPZ = REPO_ROOT / "stats.npz"
-DEFAULT_YT_DLP_EXTRACTOR_ARGS = "youtube:player_client=tv,web_safari,web"
+DEFAULT_YT_DLP_EXTRACTOR_ARGS = "youtube:player_client=web_safari,web"
 COOKIE_DOMAINS = ("youtube.com", "google.com", "googlevideo.com", "ytimg.com")
 TIMESTAMP_LINE_RE = re.compile(
     r"^(?P<start>\d{2}:\d{2}:\d{2}\.\d{3})\s+-->\s+(?P<end>\d{2}:\d{2}:\d{2}\.\d{3})"
@@ -51,6 +51,7 @@ DEFAULT_COLUMNS = [
     "metadata_status",
     "subtitle_status",
     "download_status",
+    "failure_count",
     "error",
     "processed_at",
 ]
@@ -79,6 +80,7 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--cookies", type=Path, default=None)
     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)
     return parser.parse_args()
 
 
@@ -135,11 +137,19 @@ def write_manifest(csv_path: Path, rows: Sequence[Dict[str, str]], fieldnames: S
     tmp_path.replace(csv_path)
 
 
+def repo_relative_or_absolute(path: Path) -> str:
+    resolved_path = path.resolve()
+    try:
+        return str(resolved_path.relative_to(REPO_ROOT.resolve()))
+    except ValueError:
+        return str(resolved_path)
+
+
 def build_yt_dlp_base_command(args: argparse.Namespace) -> List[str]:
-    command = ["yt-dlp", "--newline"]
-    node_binary = resolve_node_binary()
-    if node_binary is not None:
-        command.extend(["--js-runtimes", f"node:{node_binary}"])
+    command = ["yt-dlp", "--newline", "--remote-components", "ejs:github"]
+    js_runtime = resolve_js_runtime()
+    if js_runtime is not None:
+        command.extend(["--js-runtimes", js_runtime])
     if getattr(args, "_effective_cookies", None):
         command.extend(["--cookies", str(args._effective_cookies)])
     if args.cookies_from_browser:
@@ -149,19 +159,45 @@ def build_yt_dlp_base_command(args: argparse.Namespace) -> List[str]:
     return command
 
 
-def resolve_node_binary() -> Path | None:
-    node_path = shutil.which("node")
-    if node_path:
-        return Path(node_path)
+def resolve_runtime_binary(name: str) -> Path | None:
+    runtime_path = shutil.which(name)
+    if runtime_path:
+        return Path(runtime_path)
 
     python_path = Path(sys.executable).resolve()
     for parent in python_path.parents:
-        fallback = parent / "bin" / "node"
+        fallback = parent / "bin" / name
         if fallback.exists():
             return fallback
     return None
 
 
+def node_version_is_supported(node_binary: Path) -> bool:
+    try:
+        result = subprocess.run([str(node_binary), "--version"], capture_output=True, text=True, check=False)
+    except OSError:
+        return False
+    version_text = (result.stdout or result.stderr).strip().lstrip("v")
+    if not version_text:
+        return False
+    major_text = version_text.split(".", 1)[0]
+    try:
+        return int(major_text) >= 20
+    except ValueError:
+        return False
+
+
+def resolve_js_runtime() -> str | None:
+    deno_binary = resolve_runtime_binary("deno")
+    if deno_binary is not None:
+        return f"deno:{deno_binary}"
+
+    node_binary = resolve_runtime_binary("node")
+    if node_binary is not None and node_version_is_supported(node_binary):
+        return f"node:{node_binary}"
+    return None
+
+
 def sanitize_cookie_file(cookie_path: Path) -> Path:
     tmp_handle = tempfile.NamedTemporaryFile(
         mode="w",
@@ -308,13 +344,36 @@ def find_video_file(raw_video_dir: Path, video_id: str) -> Path | None:
     return sorted(candidates)[0] if candidates else None
 
 
+def iter_partial_download_files(raw_video_dir: Path, video_id: str) -> Iterable[Path]:
+    seen: set[Path] = set()
+    for path in raw_video_dir.glob(f"{video_id}*"):
+        if not path.is_file():
+            continue
+        suffixes = set(path.suffixes)
+        if ".part" in suffixes or ".ytdl" in suffixes or path.suffix in {".part", ".ytdl"}:
+            resolved = path.resolve()
+            if resolved not in seen:
+                seen.add(resolved)
+                yield path
+
+
+def cleanup_partial_downloads(raw_video_dir: Path, video_id: str) -> None:
+    for partial_path in iter_partial_download_files(raw_video_dir, video_id):
+        partial_path.unlink(missing_ok=True)
+
+
 def download_video(video_id: str, raw_video_dir: Path, args: argparse.Namespace) -> Tuple[str, str]:
     raw_video_dir.mkdir(parents=True, exist_ok=True)
+    cleanup_partial_downloads(raw_video_dir, video_id)
     command = build_yt_dlp_base_command(args)
     command.extend(
         [
             "--output",
             str(raw_video_dir / "%(id)s.%(ext)s"),
+            "--format",
+            "worstvideo*+worstaudio/worst",
+            "--format-sort",
+            "+res,+size,+br,+fps",
             "--merge-output-format",
             "mp4",
             youtube_url(video_id),
@@ -322,9 +381,10 @@ def download_video(video_id: str, raw_video_dir: Path, args: argparse.Namespace)
     )
     result = run_command(command)
     video_path = find_video_file(raw_video_dir, video_id)
+    cleanup_partial_downloads(raw_video_dir, video_id)
     if result.returncode != 0 and not video_path:
         raise RuntimeError(result.stderr.strip() or result.stdout.strip() or "video download failed")
-    return str(video_path.relative_to(REPO_ROOT)) if video_path else "", ""
+    return repo_relative_or_absolute(video_path) if video_path else "", ""
 
 
 def subtitle_file_language(path: Path, video_id: str) -> str:
@@ -488,7 +548,7 @@ def persist_raw_metadata(raw_metadata_dir: Path, video_id: str, metadata: Dict[s
     metadata_path = raw_metadata_dir / f"{video_id}.json"
     with metadata_path.open("w", encoding="utf-8") as handle:
         json.dump(metadata, handle, ensure_ascii=False, indent=2)
-    return str(metadata_path.relative_to(REPO_ROOT))
+    return repo_relative_or_absolute(metadata_path)
 
 
 def iter_target_rows(
@@ -527,15 +587,43 @@ def collect_local_video_ids(args: argparse.Namespace) -> set[str]:
     return local_video_ids
 
 
+def row_failure_count(row: Dict[str, str]) -> int:
+    try:
+        return int((row.get("failure_count") or "0").strip() or "0")
+    except ValueError:
+        return 0
+
+
+def record_row_failure(row: Dict[str, str], stats_record: Dict[str, object], error_text: str, max_failures_before_skip: int) -> tuple[int, bool]:
+    failure_count = row_failure_count(row) + 1
+    row["failure_count"] = str(failure_count)
+    stats_record["failure_count"] = row["failure_count"]
+    should_skip = failure_count >= max_failures_before_skip
+    if should_skip:
+        row["download_status"] = "skipped"
+        row["error"] = f"{error_text} | skipped after {failure_count} failures" if error_text else f"skipped after {failure_count} failures"
+        stats_record["download_status"] = row["download_status"]
+        stats_record["last_error"] = row["error"]
+    return failure_count, should_skip
+
+
+def reset_row_failures(row: Dict[str, str], stats_record: Dict[str, object]) -> None:
+    row["failure_count"] = "0"
+    stats_record["failure_count"] = row["failure_count"]
+
+
 def row_needs_processing(row: Dict[str, str], args: argparse.Namespace) -> bool:
     if args.force_metadata or args.force_subtitles or args.force_download:
         return True
+    if row_failure_count(row) >= args.max_failures_before_skip:
+        return False
     metadata_status = (row.get("metadata_status") or "").strip()
     subtitle_status = (row.get("subtitle_status") or "").strip()
     download_status = (row.get("download_status") or "").strip()
 
     needs_metadata = metadata_status != "ok"
-    needs_subtitles = (not args.skip_subtitles) and subtitle_status != "ok"
+    # Treat missing subtitles as a terminal state so videos without captions are not retried forever.
+    needs_subtitles = (not args.skip_subtitles) and subtitle_status not in {"ok", "missing", "skipped"}
     needs_download = (not args.skip_video_download) and download_status != "ok"
     return needs_metadata or needs_subtitles or needs_download
 
@@ -586,11 +674,14 @@ def main() -> None:
                 row["error"] = metadata_error
                 row["processed_at"] = time.strftime("%Y-%m-%d %H:%M:%S")
                 stats_record["metadata_status"] = "failed"
-                stats_record["last_error"] = metadata_error
                 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)
                 print(f"  metadata failed: {metadata_error}")
+                if should_skip:
+                    print(f"  skipping after {failure_count} failures")
                 if args.sleep_seconds > 0:
                     time.sleep(args.sleep_seconds)
                 continue
@@ -629,7 +720,7 @@ def main() -> None:
                     row["subtitle_status"] = "partial" if subtitle_payloads else "failed"
 
             row["subtitle_languages"] = "|".join(sorted(subtitle_payloads))
-            row["subtitle_dir_path"] = str(subtitle_dir.relative_to(REPO_ROOT)) if subtitle_payloads else ""
+            row["subtitle_dir_path"] = repo_relative_or_absolute(subtitle_dir) if subtitle_payloads else ""
             subtitle_en, subtitle_en_source = select_english_subtitle(subtitle_payloads)
             row["subtitle_en_source"] = subtitle_en_source
             if "subtitle_texts_json" in row:
@@ -645,12 +736,12 @@ def main() -> None:
                 existing_video = find_video_file(args.raw_video_dir, video_id)
                 if args.skip_video_download:
                     row["download_status"] = "skipped"
-                    row["raw_video_path"] = str(existing_video.relative_to(REPO_ROOT)) if existing_video else ""
+                    row["raw_video_path"] = repo_relative_or_absolute(existing_video) if existing_video else ""
                 else:
                     if existing_video is None or args.force_download:
                         row["raw_video_path"], download_error = download_video(video_id, args.raw_video_dir, args)
                     else:
-                        row["raw_video_path"] = str(existing_video.relative_to(REPO_ROOT))
+                        row["raw_video_path"] = repo_relative_or_absolute(existing_video)
                     row["download_status"] = "ok" if row["raw_video_path"] else "failed"
             except Exception as exc:
                 download_error = str(exc)
@@ -672,6 +763,12 @@ def main() -> None:
             stats_record["metadata_status"] = row["metadata_status"]
             stats_record["subtitle_status"] = row["subtitle_status"]
             stats_record["download_status"] = row["download_status"]
+            if errors:
+                failure_count, should_skip = record_row_failure(row, stats_record, row["error"], args.max_failures_before_skip)
+            else:
+                reset_row_failures(row, stats_record)
+                failure_count, should_skip = 0, False
+            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)
@@ -681,6 +778,8 @@ def main() -> None:
                 print(f"  video download failed: {download_error}")
             if row["subtitle_status"] in {"failed", "partial"}:
                 print(f"  subtitle status: {row['subtitle_status']} {subtitle_error}")
+            if should_skip:
+                print(f"  skipping after {failure_count} failures")
 
             if args.sleep_seconds > 0:
                 time.sleep(args.sleep_seconds)

slurm/process_dwpose_array.slurm

@@ -0,0 +1,81 @@
+#!/usr/bin/env bash
+#SBATCH --job-name=dwpose
+#SBATCH --nodes=1
+#SBATCH --ntasks=1
+#SBATCH --cpus-per-task=8
+#SBATCH --gres=gpu:1
+#SBATCH --mem=32G
+#SBATCH --time=24:00:00
+#SBATCH --output=%x_%A_%a.out
+#SBATCH --error=%x_%A_%a.err
+
+set -euo pipefail
+
+ROOT_DIR="${ROOT_DIR:-$(cd "$(dirname "$0")/.." && pwd)}"
+CONDA_SH="${CONDA_SH:-/home/sf895/miniconda3/etc/profile.d/conda.sh}"
+CONDA_ENV="${CONDA_ENV:-dwpose}"
+RAW_VIDEO_DIR="${RAW_VIDEO_DIR:-$ROOT_DIR/raw_video}"
+DATASET_DIR="${DATASET_DIR:-$ROOT_DIR/dataset}"
+STATS_NPZ="${STATS_NPZ:-$ROOT_DIR/stats.npz}"
+PIPELINE02="${PIPELINE02:-$ROOT_DIR/scripts/pipeline02_extract_dwpose_from_video.py}"
+FPS="${FPS:-24}"
+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:-$ROOT_DIR/slurm/state/claims}"
+
+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
+
+CLAIM_PATH="$CLAIM_DIR/${VIDEO_ID}.claim"
+cleanup_claim() {
+  rm -f "$CLAIM_PATH"
+}
+trap cleanup_claim EXIT
+
+export OMP_NUM_THREADS="${SLURM_CPUS_PER_TASK:-1}"
+export MKL_NUM_THREADS="${SLURM_CPUS_PER_TASK:-1}"
+
+echo "[$(date '+%F %T')] job=${SLURM_JOB_ID:-na} task=${SLURM_ARRAY_TASK_ID} host=$(hostname) gpu=${CUDA_VISIBLE_DEVICES:-unset} video_id=$VIDEO_ID"
+
+# shellcheck disable=SC1090
+source "$CONDA_SH"
+
+cmd=(python "$PIPELINE02"
+  --raw-video-dir "$RAW_VIDEO_DIR"
+  --dataset-dir "$DATASET_DIR"
+  --stats-npz "$STATS_NPZ"
+  --fps "$FPS"
+  --workers 1
+  --tmp-root "$TMP_ROOT"
+  --video-ids="$VIDEO_ID"
+)
+if [[ "$FORCE_PROCESS" == "1" ]]; then
+  cmd+=(--force)
+fi
+if [[ "$DELETE_SOURCE_ON_SUCCESS" == "1" ]]; then
+  cmd+=(--delete-source-on-success)
+fi
+
+CONDA_NO_PLUGINS=true conda run -n "$CONDA_ENV" "${cmd[@]}"

slurm/run_reproduce_independently_slurm.slurm

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+#SBATCH --job-name=sign-dwpose-orch
+#SBATCH --nodes=1
+#SBATCH --ntasks=1
+#SBATCH --cpus-per-task=2
+#SBATCH --mem=8G
+#SBATCH --time=24:00:00
+#SBATCH --output=%x_%A.out
+#SBATCH --error=%x_%A.err
+
+set -euo pipefail
+
+ROOT_DIR="${ROOT_DIR:-$(cd "$(dirname "$0")/.." && pwd)}"
+SCRIPT="$ROOT_DIR/reproduce_independently_slurm.sh"
+
+if [[ ! -x "$SCRIPT" ]]; then
+  echo "Missing script: $SCRIPT" >&2
+  exit 1
+fi
+
+echo "[$(date '+%F %T')] host=$(hostname) running orchestration stage=${STAGE:-all}"
+exec bash "$SCRIPT" --run-local

slurm/submit_dwpose_slurm.sh

@@ -0,0 +1,282 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+CONDA_SH="/home/sf895/miniconda3/etc/profile.d/conda.sh"
+CONDA_ENV="signx2"
+RAW_VIDEO_DIR="$ROOT_DIR/raw_video"
+DATASET_DIR="$ROOT_DIR/dataset"
+STATS_NPZ="$ROOT_DIR/stats.npz"
+SLURM_SCRIPT="$ROOT_DIR/slurm/process_dwpose_array.slurm"
+MANIFEST_DIR="$ROOT_DIR/slurm/manifests"
+LOG_DIR="$ROOT_DIR/slurm/logs"
+STATE_DIR="$ROOT_DIR/slurm/state"
+CLAIM_DIR="$STATE_DIR/claims"
+LOCK_FILE="$STATE_DIR/submit.lock"
+PARTITIONS="gpu"
+ACCOUNT=""
+TIME_LIMIT="24:00:00"
+CPUS_PER_TASK="8"
+MEMORY="32G"
+FPS="24"
+LIMIT=""
+ARRAY_PARALLEL=""
+MAX_BACKLOG_VIDEOS="340"
+FORCE_PROCESS=0
+DELETE_SOURCE_ON_SUCCESS=0
+
+usage() {
+  cat <<USAGE
+Usage:
+  bash slurm/submit_dwpose_slurm.sh [options]
+
+Options:
+  --partitions P1[,P2,...]   Comma-separated partitions. Default: gpu
+  --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
+  --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
+      ;;
+    --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
+      ;;
+  esac
+done
+
+mkdir -p "$MANIFEST_DIR" "$LOG_DIR" "$CLAIM_DIR"
+exec 9>"$LOCK_FILE"
+if ! flock -n 9; then
+  echo "Another submit_dwpose_slurm.sh instance is running; skip this cycle."
+  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"
+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'
+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])
+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)
+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_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 = ""
+    for line in lines:
+        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:
+        active_claims.add(video_id)
+    else:
+        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():
+    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":
+            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")
+print(len(selected))
+PY
+})"
+rm -f "$ACTIVE_JOBS_FILE"
+
+if [[ "$PENDING_COUNT" == "0" ]]; then
+  echo "No pending raw videos to process, or max backlog $MAX_BACKLOG_VIDEOS already reached."
+  rm -f "$BASE_MANIFEST"
+  exit 0
+fi
+
+echo "Created manifest: $BASE_MANIFEST"
+echo "Pending videos selected this cycle: $PENDING_COUNT"
+
+write_claims() {
+  local manifest="$1"
+  local job_id="$2"
+  while IFS= read -r video_id; do
+    [[ -z "$video_id" ]] && continue
+    cat > "$CLAIM_DIR/${video_id}.claim" <<CLAIM
+job_id=$job_id
+video_id=$video_id
+submitted_at=$(date '+%F %T')
+CLAIM
+  done < "$manifest"
+}
+
+submit_partition() {
+  local partition="$1"
+  local manifest="$2"
+  local count="$3"
+  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"
+    --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"
+    --export "ALL,ROOT_DIR=$ROOT_DIR,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"
+  job_output="$("${cmd[@]}")"
+  echo "$job_output"
+  job_id="$(awk '/Submitted batch job/ {print $4}' <<< "$job_output" | tail -n 1)"
+  if [[ -z "$job_id" ]]; then
+    echo "Failed to parse sbatch job id from output: $job_output" >&2
+    return 1
+  fi
+  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:]')"
+  if [[ "$shard_count" == "0" ]]; then
+    rm -f "$shard_manifest"
+    continue
+  fi
+  submit_partition "${PARTITION_LIST[$idx]}" "$shard_manifest" "$shard_count"
+done
+
+echo "SUBMITTED_VIDEO_COUNT=$PENDING_COUNT"

slurm/watch_submit_dwpose.slurm

@@ -0,0 +1,58 @@
+#!/usr/bin/env bash
+#SBATCH --job-name=dwpose-submit
+#SBATCH --nodes=1
+#SBATCH --ntasks=1
+#SBATCH --cpus-per-task=1
+#SBATCH --mem=2G
+#SBATCH --time=24:00:00
+#SBATCH --output=%x_%A.out
+#SBATCH --error=%x_%A.err
+
+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_ACCOUNT="${GPU_ACCOUNT:-}"
+SCAN_INTERVAL_SECONDS="${SCAN_INTERVAL_SECONDS:-60}"
+SUBMIT_LIMIT="${SUBMIT_LIMIT:-200}"
+ARRAY_PARALLEL="${ARRAY_PARALLEL:-}"
+MAX_BACKLOG_VIDEOS="${MAX_BACKLOG_VIDEOS:-340}"
+FPS="${FPS:-24}"
+MAX_ITERATIONS="${MAX_ITERATIONS:-0}"
+FORCE_PROCESS="${FORCE_PROCESS:-0}"
+DELETE_SOURCE_ON_SUCCESS="${DELETE_SOURCE_ON_SUCCESS:-0}"
+
+iteration=0
+while true; do
+  iteration=$((iteration + 1))
+  echo "[$(date '+%F %T')] submitter iteration=$iteration"
+
+  cmd=(bash "$SUBMIT_SCRIPT"
+    --partitions "$GPU_PARTITIONS"
+    --limit "$SUBMIT_LIMIT"
+    --max-backlog-videos "$MAX_BACKLOG_VIDEOS"
+    --fps "$FPS"
+  )
+  if [[ -n "$GPU_ACCOUNT" ]]; then
+    cmd+=(--account "$GPU_ACCOUNT")
+  fi
+  if [[ -n "$ARRAY_PARALLEL" ]]; then
+    cmd+=(--array-parallel "$ARRAY_PARALLEL")
+  fi
+  if [[ "$FORCE_PROCESS" == "1" ]]; then
+    cmd+=(--force-process)
+  fi
+  if [[ "$DELETE_SOURCE_ON_SUCCESS" == "1" ]]; then
+    cmd+=(--delete-source-on-success)
+  fi
+
+  "${cmd[@]}"
+
+  if [[ "$MAX_ITERATIONS" -gt 0 && "$iteration" -ge "$MAX_ITERATIONS" ]]; then
+    echo "Reached max iterations: $MAX_ITERATIONS"
+    exit 0
+  fi
+
+  sleep "$SCAN_INTERVAL_SECONDS"
+done