Add reproducible Sign-DWPose-2M pipeline and visualization tools

.gitignore

@@ -0,0 +1 @@
+*.txt

reproduce_independently.sh

@@ -0,0 +1,573 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+CONDA_SH="/research/cbim/vast/sf895/miniforge3/etc/profile.d/conda.sh"
+CONDA_ENV="dwpose"
+
+SOURCE_METADATA_CSV="$ROOT_DIR/Sign-DWPose-2M-metadata_ori.csv"
+OUTPUT_METADATA_CSV="$ROOT_DIR/Sign-DWPose-2M-metadata_processed.csv"
+RAW_VIDEO_DIR="$ROOT_DIR/raw_video"
+RAW_CAPTION_DIR="$ROOT_DIR/raw_caption"
+RAW_METADATA_DIR="$ROOT_DIR/raw_metadata"
+DATASET_DIR="$ROOT_DIR/dataset"
+ARCHIVE_DIR="$ROOT_DIR/archives"
+STATS_NPZ="$ROOT_DIR/stats.npz"
+PROGRESS_JSON="$ROOT_DIR/archive_upload_progress.json"
+
+PIPELINE01="$ROOT_DIR/scripts/pipeline01_download_video_fix_caption.py"
+PIPELINE02="$ROOT_DIR/scripts/pipeline02_extract_dwpose_from_video.py"
+PIPELINE03="$ROOT_DIR/scripts/pipeline03_upload_to_huggingface.py"
+
+STAGE="all"
+LIMIT=""
+VIDEO_IDS=()
+FPS="24"
+WORKERS=""
+TARGET_BYTES="$((14 * 1024 * 1024 * 1024))"
+DOWNLOAD_BATCH_SIZE="1"
+PROCESS_BATCH_SIZE=""
+RAW_BACKLOG_LIMIT="340"
+MAX_RAW_VIDEO_BYTES="0"
+MAX_ITERATIONS="0"
+IDLE_SLEEP_SECONDS="5"
+REPO_ID="SignerX/Sign-DWPose-2M"
+COOKIES_FILE=""
+COOKIES_FROM_BROWSER=""
+EXTRACTOR_ARGS=""
+
+FORCE_METADATA=0
+FORCE_SUBTITLES=0
+FORCE_DOWNLOAD=0
+FORCE_PROCESS=0
+SKIP_VIDEO_DOWNLOAD=0
+SKIP_SUBTITLES=0
+DRY_RUN_UPLOAD=0
+
+print_usage() {
+  cat <<EOF
+Usage:
+  bash reproduce_independently.sh [options]
+
+Options:
+  --stage {all,download,process,upload}
+  --limit N
+  --video-id ID
+  --video-ids "ID1 ID2 ..."
+  --fps N
+  --workers N
+  --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.sh --stage download --limit 10 --skip-video-download
+  bash reproduce_independently.sh --stage process --video-id Bdj5MUf_3Hc --workers 1
+  bash reproduce_independently.sh --stage upload --target-bytes 500000000
+  bash reproduce_independently.sh --stage all --workers 8 --download-batch-size 1 --raw-backlog-limit 340
+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
+      ;;
+    --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
+
+mkdir -p "$RAW_VIDEO_DIR" "$RAW_CAPTION_DIR" "$RAW_METADATA_DIR" "$DATASET_DIR"
+
+run_in_dwpose() {
+  # shellcheck disable=SC1090
+  source "$CONDA_SH"
+  CONDA_NO_PLUGINS=true conda run -n "$CONDA_ENV" "$@"
+}
+
+append_video_ids() {
+  local -n target_ref=$1
+  if [[ ${#VIDEO_IDS[@]} -gt 0 ]]; then
+    target_ref+=(--video-ids "${VIDEO_IDS[@]}")
+  fi
+}
+
+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
+  append_video_ids cmd
+  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() {
+  local stage_limit="${1:-$LIMIT}"
+  local cmd=(python "$PIPELINE02"
+    --raw-video-dir "$RAW_VIDEO_DIR"
+    --dataset-dir "$DATASET_DIR"
+    --stats-npz "$STATS_NPZ"
+    --fps "$FPS"
+    --delete-source-on-success
+  )
+
+  if [[ -n "$stage_limit" ]]; then
+    cmd+=(--limit "$stage_limit")
+  fi
+  append_video_ids cmd
+  if [[ -n "$WORKERS" ]]; then
+    cmd+=(--workers "$WORKERS")
+  fi
+  if [[ $FORCE_PROCESS -eq 1 ]]; then
+    cmd+=(--force)
+  fi
+
+  run_in_dwpose "${cmd[@]}"
+}
+
+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_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
+  while true; do
+    iteration=$((iteration + 1))
+    local pruned
+    pruned="$(prune_processed_raw_videos)"
+    local pending_download pending_process
+    pending_download="$(count_pending_downloads)"
+    pending_process="$(count_pending_process)"
+    echo "[process] iteration=$iteration pending_download=$pending_download raw_backlog=$pending_process pruned_raw_videos=$pruned"
+
+    if [[ "$MAX_ITERATIONS" -gt 0 && "$iteration" -gt "$MAX_ITERATIONS" ]]; then
+      echo "[process] reached max iterations: $MAX_ITERATIONS"
+      break
+    fi
+    if [[ "$pending_process" -eq 0 ]]; then
+      if [[ "$pending_download" -eq 0 ]]; then
+        echo "[process] nothing left to process"
+        break
+      fi
+      sleep "$IDLE_SLEEP_SECONDS"
+      continue
+    fi
+
+    if ! run_process_stage "$PROCESS_BATCH_SIZE"; then
+      echo "[process] pipeline02 failed; retry after sleep"
+      sleep "$IDLE_SLEEP_SECONDS"
+    fi
+  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

@@ -0,0 +1,693 @@
+#!/usr/bin/env python3
+
+import argparse
+import csv
+import html
+import json
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+import time
+from pathlib import Path
+from typing import Dict, Iterable, List, Sequence, Tuple
+from urllib.parse import parse_qs, urlparse
+
+
+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
+
+
+DEFAULT_SOURCE_METADATA_CSV = REPO_ROOT / "Sign-DWPose-2M-metadata_ori.csv"
+DEFAULT_OUTPUT_METADATA_CSV = REPO_ROOT / "Sign-DWPose-2M-metadata_processed.csv"
+DEFAULT_RAW_VIDEO_DIR = REPO_ROOT / "raw_video"
+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"
+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})"
+)
+TAG_RE = re.compile(r"<[^>]+>")
+ZERO_WIDTH_RE = re.compile(r"[\u200b\u200c\u200d\ufeff]+")
+DEFAULT_COLUMNS = [
+    "video_id",
+    "sign_language",
+    "title",
+    "duration_sec",
+    "start_sec",
+    "end_sec",
+    "subtitle_languages",
+    "subtitle_dir_path",
+    "subtitle_en_source",
+    "raw_video_path",
+    "raw_metadata_path",
+    "metadata_status",
+    "subtitle_status",
+    "download_status",
+    "error",
+    "processed_at",
+]
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Download raw videos and enrich the Sign-DWPose-2M metadata CSV."
+    )
+    parser.add_argument("--source-metadata-csv", type=Path, default=DEFAULT_SOURCE_METADATA_CSV)
+    parser.add_argument("--output-metadata-csv", type=Path, default=DEFAULT_OUTPUT_METADATA_CSV)
+    parser.add_argument("--raw-video-dir", type=Path, default=DEFAULT_RAW_VIDEO_DIR)
+    parser.add_argument("--raw-caption-dir", type=Path, default=DEFAULT_RAW_CAPTION_DIR)
+    parser.add_argument("--raw-metadata-dir", type=Path, default=DEFAULT_RAW_METADATA_DIR)
+    parser.add_argument("--dataset-dir", type=Path, default=DEFAULT_DATASET_DIR)
+    parser.add_argument("--stats-npz", type=Path, default=DEFAULT_STATS_NPZ)
+    parser.add_argument("--limit", type=int, default=None)
+    parser.add_argument("--video-ids", nargs="*", default=None)
+    parser.add_argument("--force-metadata", action="store_true")
+    parser.add_argument("--force-subtitles", action="store_true")
+    parser.add_argument("--force-download", action="store_true")
+    parser.add_argument("--skip-video-download", action="store_true")
+    parser.add_argument("--skip-subtitles", action="store_true")
+    parser.add_argument("--local-only", action="store_true")
+    parser.add_argument("--sleep-seconds", type=float, default=0.0)
+    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)
+    return parser.parse_args()
+
+
+def read_manifest(csv_path: Path) -> Tuple[List[Dict[str, str]], List[str]]:
+    if not csv_path.exists():
+        raise FileNotFoundError(f"Metadata CSV not found: {csv_path}")
+
+    csv.field_size_limit(min(sys.maxsize, max(csv.field_size_limit(), 10 * 1024 * 1024)))
+
+    with csv_path.open("r", encoding="utf-8-sig", newline="") as handle:
+        rows = list(csv.reader(handle))
+
+    if not rows:
+        return [], DEFAULT_COLUMNS.copy()
+
+    first = rows[0]
+    if first and first[0] == "video_id":
+        with csv_path.open("r", encoding="utf-8-sig", newline="") as handle:
+            reader = csv.DictReader(handle)
+            manifest_rows = [dict(row) for row in reader]
+            fieldnames = list(reader.fieldnames or [])
+    else:
+        manifest_rows = []
+        for row in rows:
+            if not row:
+                continue
+            manifest_rows.append(
+                {
+                    "video_id": row[0].strip(),
+                    "sign_language": row[1].strip() if len(row) > 1 else "",
+                }
+            )
+        fieldnames = []
+
+    ordered_fieldnames = []
+    for column in DEFAULT_COLUMNS + fieldnames:
+        if column and column not in ordered_fieldnames:
+            ordered_fieldnames.append(column)
+
+    for row in manifest_rows:
+        for column in ordered_fieldnames:
+            row.setdefault(column, "")
+
+    return manifest_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:
+        writer = csv.DictWriter(handle, fieldnames=fieldnames)
+        writer.writeheader()
+        for row in rows:
+            writer.writerow({column: row.get(column, "") for column in fieldnames})
+    tmp_path.replace(csv_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}"])
+    if getattr(args, "_effective_cookies", None):
+        command.extend(["--cookies", str(args._effective_cookies)])
+    if args.cookies_from_browser:
+        command.extend(["--cookies-from-browser", args.cookies_from_browser])
+    if args.extractor_args:
+        command.extend(["--extractor-args", args.extractor_args])
+    return command
+
+
+def resolve_node_binary() -> Path | None:
+    node_path = shutil.which("node")
+    if node_path:
+        return Path(node_path)
+
+    python_path = Path(sys.executable).resolve()
+    for parent in python_path.parents:
+        fallback = parent / "bin" / "node"
+        if fallback.exists():
+            return fallback
+    return None
+
+
+def sanitize_cookie_file(cookie_path: Path) -> Path:
+    tmp_handle = tempfile.NamedTemporaryFile(
+        mode="w",
+        encoding="utf-8",
+        suffix=".txt",
+        prefix="sign_dwpose_cookies_",
+        delete=False,
+    )
+    with cookie_path.open("r", encoding="utf-8", errors="ignore") as src, tmp_handle as dst:
+        wrote_header = False
+        for raw_line in src:
+            line = raw_line.rstrip("\n")
+            if not line:
+                continue
+            if line.startswith("#"):
+                if not wrote_header:
+                    dst.write("# Netscape HTTP Cookie File\n")
+                    wrote_header = True
+                continue
+
+            parts = line.split("\t")
+            if len(parts) < 7:
+                continue
+            domain = parts[0].strip()
+            if not any(token in domain for token in COOKIE_DOMAINS):
+                continue
+            parts[1] = "TRUE" if domain.startswith(".") else "FALSE"
+            dst.write("\t".join(parts[:7]) + "\n")
+    return Path(tmp_handle.name)
+
+
+def run_command(command: Sequence[str]) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(command, capture_output=True, text=True)
+
+
+def youtube_url(video_id: str) -> str:
+    return f"https://www.youtube.com/watch?v={video_id}"
+
+
+def fetch_metadata(video_id: str, args: argparse.Namespace) -> Tuple[Dict[str, object], str]:
+    command = build_yt_dlp_base_command(args)
+    command.extend(["-J", "--skip-download", youtube_url(video_id)])
+    result = run_command(command)
+    if result.returncode != 0:
+        raise RuntimeError(result.stderr.strip() or result.stdout.strip() or "yt-dlp metadata failed")
+    return json.loads(result.stdout), ""
+
+
+def caption_entry_has_translation(entry: Dict[str, object]) -> bool:
+    url = str(entry.get("url") or "")
+    if not url:
+        return False
+    return "tlang" in parse_qs(urlparse(url).query)
+
+
+def filter_caption_languages(metadata: Dict[str, object]) -> Tuple[List[str], List[str], str]:
+    manual = sorted(
+        lang
+        for lang in (metadata.get("subtitles") or {}).keys()
+        if lang and lang != "live_chat"
+    )
+    native_automatic: List[str] = []
+    english_translations: List[str] = []
+    for lang, entries in sorted((metadata.get("automatic_captions") or {}).items()):
+        if not lang or lang == "live_chat" or lang in manual:
+            continue
+        entry_list = entries if isinstance(entries, list) else []
+        if any(isinstance(entry, dict) and caption_entry_has_translation(entry) for entry in entry_list):
+            if lang.startswith("en-"):
+                english_translations.append(lang)
+            continue
+        native_automatic.append(lang)
+
+    english_translation = ""
+    if english_translations:
+        preferred_sources = manual + native_automatic
+        for source_lang in preferred_sources:
+            candidate = f"en-{source_lang}"
+            if candidate in english_translations:
+                english_translation = candidate
+                break
+        if not english_translation:
+            english_translation = sorted(english_translations)[0]
+    elif manual or native_automatic:
+        english_translation = f"en-{(manual + native_automatic)[0]}"
+    return manual, native_automatic, english_translation
+
+
+def download_subtitles(
+    video_id: str,
+    subtitle_dir: Path,
+    manual_langs: Sequence[str],
+    native_automatic_langs: Sequence[str],
+    english_translation_lang: str,
+    args: argparse.Namespace,
+) -> str:
+    subtitle_dir.mkdir(parents=True, exist_ok=True)
+    automatic_langs = list(native_automatic_langs)
+    if english_translation_lang:
+        automatic_langs.append(english_translation_lang)
+    requested_langs = list(manual_langs) + automatic_langs
+    if not requested_langs:
+        return ""
+
+    command = build_yt_dlp_base_command(args)
+    command.extend(
+        [
+            "--skip-download",
+            "--sub-format",
+            "vtt",
+            "--convert-subs",
+            "vtt",
+            "--output",
+            str(subtitle_dir / "%(id)s.%(ext)s"),
+            "--sub-langs",
+            ",".join(requested_langs),
+        ]
+    )
+    if manual_langs:
+        command.append("--write-subs")
+    if automatic_langs:
+        command.append("--write-auto-subs")
+    command.append(youtube_url(video_id))
+
+    result = run_command(command)
+    if result.returncode != 0:
+        stderr = result.stderr.strip()
+        stdout = result.stdout.strip()
+        if any(subtitle_dir.glob(f"{video_id}.*.vtt")):
+            return stderr or stdout
+        raise RuntimeError(stderr or stdout or "subtitle download failed")
+    return ""
+
+
+def subtitle_dir_for_video(dataset_dir: Path, video_id: str) -> Path:
+    return dataset_dir / video_id / "captions"
+
+
+def find_video_file(raw_video_dir: Path, video_id: str) -> Path | None:
+    candidates = []
+    for path in raw_video_dir.glob(f"{video_id}.*"):
+        if path.suffix in {".mp4", ".mkv", ".webm", ".mov"}:
+            candidates.append(path)
+    return sorted(candidates)[0] if candidates else None
+
+
+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)
+    command = build_yt_dlp_base_command(args)
+    command.extend(
+        [
+            "--output",
+            str(raw_video_dir / "%(id)s.%(ext)s"),
+            "--merge-output-format",
+            "mp4",
+            youtube_url(video_id),
+        ]
+    )
+    result = run_command(command)
+    video_path = find_video_file(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 "", ""
+
+
+def subtitle_file_language(path: Path, video_id: str) -> str:
+    name = path.name
+    prefix = f"{video_id}."
+    if not name.startswith(prefix):
+        return ""
+    middle = name[len(prefix):]
+    if middle.endswith(".vtt"):
+        middle = middle[:-4]
+    return middle
+
+
+def clean_vtt_to_text(path: Path) -> str:
+    return normalize_subtitle_lines(extract_vtt_text_lines(path))
+
+
+def extract_vtt_text_lines(path: Path) -> List[str]:
+    lines: List[str] = []
+    with path.open("r", encoding="utf-8", errors="ignore") as handle:
+        for raw_line in handle:
+            line = raw_line.strip()
+            if not line:
+                continue
+            if line == "WEBVTT" or line.startswith("NOTE") or line.startswith("Kind:") or line.startswith("Language:"):
+                continue
+            if TIMESTAMP_LINE_RE.match(line) or "-->" in line:
+                continue
+            if line.isdigit():
+                continue
+            line = TAG_RE.sub("", line)
+            line = ZERO_WIDTH_RE.sub("", html.unescape(line)).strip()
+            if not line:
+                continue
+            lines.append(line)
+    return lines
+
+
+def normalize_subtitle_lines(lines: Sequence[str]) -> str:
+    normalized_lines: List[str] = []
+    for line in lines:
+        if not line:
+            continue
+        if normalized_lines and normalized_lines[-1] == line:
+            continue
+        if normalized_lines and line[:1] in {",", ".", "!", "?", ";", ":", "%", ")", "]", "}"}:
+            normalized_lines[-1] = normalized_lines[-1].rstrip() + line
+            continue
+        if normalized_lines and normalized_lines[-1].endswith(("-", "–", "—", "/")):
+            line = line.lstrip("-–—").lstrip()
+            normalized_lines[-1] = normalized_lines[-1].rstrip() + " " + line
+            continue
+        if normalized_lines and normalized_lines[-1].endswith("..."):
+            line = line.lstrip(".").lstrip()
+            normalized_lines[-1] = normalized_lines[-1].rstrip() + " " + line
+            continue
+        normalized_lines.append(line)
+
+    text = " ".join(normalized_lines)
+    text = re.sub(r"\s+", " ", text).strip()
+    text = re.sub(r"\s*-\s*-\s*", " - ", text)
+    text = re.sub(r"\.{4,}", "...", text)
+    text = re.sub(r"\s*\.\.\.\s*", " ... ", text)
+    text = re.sub(r"\s+", " ", text).strip()
+    text = re.sub(r"\s+([,.;:!?%])", r"\1", text)
+    text = re.sub(r"([(\[{])\s+", r"\1", text)
+    text = re.sub(r"\s+([)\]}])", r"\1", text)
+    return text
+
+
+def timestamp_to_seconds(value: str) -> float:
+    hours, minutes, seconds = value.split(":")
+    return int(hours) * 3600 + int(minutes) * 60 + float(seconds)
+
+
+def parse_vtt_segments(path: Path) -> List[Dict[str, object]]:
+    segments: List[Dict[str, object]] = []
+    current_start = ""
+    current_end = ""
+    current_lines: List[str] = []
+
+    def flush_segment() -> None:
+        nonlocal current_start, current_end, current_lines
+        if not current_start or not current_end:
+            current_lines = []
+            return
+        text = normalize_subtitle_lines(current_lines)
+        if text:
+            segments.append(
+                {
+                    "start_sec": round(timestamp_to_seconds(current_start), 3),
+                    "end_sec": round(timestamp_to_seconds(current_end), 3),
+                    "text": text,
+                }
+            )
+        current_start = ""
+        current_end = ""
+        current_lines = []
+
+    with path.open("r", encoding="utf-8", errors="ignore") as handle:
+        for raw_line in handle:
+            line = raw_line.strip()
+            if not line:
+                flush_segment()
+                continue
+            if line == "WEBVTT" or line.startswith("NOTE") or line.startswith("Kind:") or line.startswith("Language:"):
+                continue
+            match = TIMESTAMP_LINE_RE.match(line)
+            if match:
+                flush_segment()
+                current_start = match.group("start")
+                current_end = match.group("end")
+                continue
+            if line.isdigit():
+                continue
+            line = TAG_RE.sub("", line)
+            line = ZERO_WIDTH_RE.sub("", html.unescape(line)).strip()
+            if not line:
+                continue
+            current_lines.append(line)
+    flush_segment()
+    return segments
+
+
+def load_subtitle_payloads(subtitle_dir: Path, video_id: str) -> Dict[str, Dict[str, object]]:
+    subtitle_payloads: Dict[str, Dict[str, object]] = {}
+    for path in sorted(subtitle_dir.glob(f"{video_id}.*.vtt")):
+        lang = subtitle_file_language(path, video_id)
+        if not lang:
+            continue
+        segments = parse_vtt_segments(path)
+        text = normalize_subtitle_lines(segment["text"] for segment in segments)
+        if text:
+            subtitle_payloads[lang] = {
+                "text": text,
+                "segments": segments,
+                "vtt_path": path.name,
+            }
+    return subtitle_payloads
+
+
+def select_english_subtitle(subtitle_payloads: Dict[str, Dict[str, object]]) -> Tuple[str, str]:
+    if "en" in subtitle_payloads:
+        return str(subtitle_payloads["en"]["text"]), "manual_or_auto_en"
+    english_variants = sorted(
+        lang for lang in subtitle_payloads if lang.startswith("en-") or lang.lower().startswith("en_")
+    )
+    if english_variants:
+        lang = english_variants[0]
+        source_lang = lang[3:]
+        return str(subtitle_payloads[lang]["text"]), f"translated_from_{source_lang}"
+    translated_candidates = sorted(lang for lang in subtitle_payloads if lang.endswith("-en"))
+    if translated_candidates:
+        lang = translated_candidates[0]
+        return str(subtitle_payloads[lang]["text"]), f"translated_from_{lang[:-3]}"
+    return "", ""
+
+
+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"
+    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))
+
+
+def iter_target_rows(
+    rows: Sequence[Dict[str, str]],
+    video_ids: Iterable[str] | None,
+    limit: int | None,
+    local_video_ids: set[str] | None = None,
+    args: argparse.Namespace | None = None,
+) -> List[Dict[str, str]]:
+    video_id_filter = set(video_ids or [])
+    selected = []
+    for row in rows:
+        video_id = row["video_id"]
+        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 args is not None and not row_needs_processing(row, args):
+            continue
+        selected.append(row)
+        if limit is not None and len(selected) >= limit:
+            break
+    return selected
+
+
+def collect_local_video_ids(args: argparse.Namespace) -> set[str]:
+    local_video_ids: set[str] = set()
+    if args.dataset_dir.exists():
+        for path in args.dataset_dir.iterdir():
+            if not path.is_dir():
+                continue
+            if (path / "captions").exists():
+                local_video_ids.add(path.name)
+    if args.raw_metadata_dir.exists():
+        local_video_ids.update(path.stem for path in args.raw_metadata_dir.glob("*.json"))
+    return local_video_ids
+
+
+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
+    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"
+    needs_download = (not args.skip_video_download) and download_status != "ok"
+    return needs_metadata or needs_subtitles or needs_download
+
+
+def main() -> None:
+    args = parse_args()
+    temp_cookie_path: Path | None = None
+    if args.cookies:
+        temp_cookie_path = sanitize_cookie_file(args.cookies)
+        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)
+
+    try:
+        args.raw_video_dir.mkdir(parents=True, exist_ok=True)
+        args.raw_metadata_dir.mkdir(parents=True, exist_ok=True)
+        args.dataset_dir.mkdir(parents=True, exist_ok=True)
+
+        for index, row in enumerate(selected_rows, start=1):
+            video_id = row["video_id"].strip()
+            if not video_id:
+                continue
+            stats_record = ensure_record(stats, video_id)
+
+            print(f"[{index}/{len(selected_rows)}] Processing {video_id}")
+            metadata_error = ""
+            subtitle_error = ""
+            download_error = ""
+            metadata: Dict[str, object] | None = None
+
+            try:
+                metadata_path = args.raw_metadata_dir / f"{video_id}.json"
+                if metadata_path.exists() and not args.force_metadata:
+                    with metadata_path.open("r", encoding="utf-8") as handle:
+                        metadata = json.load(handle)
+                else:
+                    metadata, metadata_error = fetch_metadata(video_id, args)
+                    row["raw_metadata_path"] = persist_raw_metadata(args.raw_metadata_dir, video_id, metadata)
+                row["metadata_status"] = "ok"
+            except Exception as exc:
+                metadata_error = str(exc)
+                row["metadata_status"] = "failed"
+                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"]
+                write_manifest(args.output_metadata_csv, rows, fieldnames)
+                save_stats(args.stats_npz, stats)
+                print(f"  metadata failed: {metadata_error}")
+                if args.sleep_seconds > 0:
+                    time.sleep(args.sleep_seconds)
+                continue
+
+            assert metadata is not None
+            row["raw_metadata_path"] = row.get("raw_metadata_path") or persist_raw_metadata(args.raw_metadata_dir, video_id, metadata)
+            row["title"] = str(metadata.get("title") or "")
+            duration = metadata.get("duration")
+            row["duration_sec"] = str(duration or "")
+            row["start_sec"] = "0"
+            row["end_sec"] = str(duration or "")
+
+            manual_langs, native_automatic_langs, english_translation_lang = filter_caption_languages(metadata)
+            subtitle_dir = subtitle_dir_for_video(args.dataset_dir, video_id)
+            subtitle_payloads: Dict[str, Dict[str, object]] = {}
+
+            if args.skip_subtitles:
+                row["subtitle_status"] = "skipped"
+            else:
+                try:
+                    need_subtitles = args.force_subtitles or not any(subtitle_dir.glob(f"{video_id}.*.vtt"))
+                    if need_subtitles:
+                        subtitle_error = download_subtitles(
+                            video_id,
+                            subtitle_dir,
+                            manual_langs,
+                            native_automatic_langs,
+                            english_translation_lang,
+                            args,
+                        )
+                    subtitle_payloads = load_subtitle_payloads(subtitle_dir, video_id)
+                    row["subtitle_status"] = "ok" if subtitle_payloads else "missing"
+                except Exception as exc:
+                    subtitle_error = str(exc)
+                    subtitle_payloads = load_subtitle_payloads(subtitle_dir, video_id)
+                    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 ""
+            subtitle_en, subtitle_en_source = select_english_subtitle(subtitle_payloads)
+            row["subtitle_en_source"] = subtitle_en_source
+            if "subtitle_texts_json" in row:
+                row["subtitle_texts_json"] = ""
+            if "subtitle_en" in row:
+                row["subtitle_en"] = ""
+            if "subtitle_json_path" in row:
+                row["subtitle_json_path"] = ""
+            if "raw_caption_dir" in row:
+                row["raw_caption_dir"] = ""
+
+            try:
+                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 ""
+                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["download_status"] = "ok" if row["raw_video_path"] else "failed"
+            except Exception as exc:
+                download_error = str(exc)
+                row["download_status"] = "failed"
+
+            errors = [value for value in [metadata_error, subtitle_error, download_error] if value]
+            row["error"] = " | ".join(errors)
+            row["processed_at"] = time.strftime("%Y-%m-%d %H:%M:%S")
+            stats_record["sign_language"] = row.get("sign_language", "")
+            stats_record["title"] = row["title"]
+            stats_record["duration_sec"] = row["duration_sec"]
+            stats_record["start_sec"] = row["start_sec"]
+            stats_record["end_sec"] = row["end_sec"]
+            stats_record["subtitle_languages"] = row["subtitle_languages"]
+            stats_record["subtitle_dir_path"] = row["subtitle_dir_path"]
+            stats_record["subtitle_en_source"] = row["subtitle_en_source"]
+            stats_record["raw_video_path"] = row["raw_video_path"]
+            stats_record["raw_metadata_path"] = row["raw_metadata_path"]
+            stats_record["metadata_status"] = row["metadata_status"]
+            stats_record["subtitle_status"] = row["subtitle_status"]
+            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)
+
+            if row["download_status"] == "failed":
+                print(f"  video download failed: {download_error}")
+            if row["subtitle_status"] in {"failed", "partial"}:
+                print(f"  subtitle status: {row['subtitle_status']} {subtitle_error}")
+
+            if args.sleep_seconds > 0:
+                time.sleep(args.sleep_seconds)
+    finally:
+        if temp_cookie_path is not None:
+            temp_cookie_path.unlink(missing_ok=True)
+
+
+if __name__ == "__main__":
+    main()

scripts/pipeline02_extract_dwpose_from_video.py

@@ -0,0 +1,247 @@
+#!/usr/bin/env python3
+
+import argparse
+import multiprocessing as mp
+import shutil
+import subprocess
+import sys
+import tempfile
+import time
+from pathlib import Path
+from typing import Dict, List, Sequence
+
+import numpy as np
+import torch
+from easy_dwpose import DWposeDetector
+from PIL import Image
+
+
+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 load_stats, update_video_stats
+
+
+DEFAULT_RAW_VIDEO_DIR = REPO_ROOT / "raw_video"
+DEFAULT_DATASET_DIR = REPO_ROOT / "dataset"
+DEFAULT_STATS_NPZ = REPO_ROOT / "stats.npz"
+VIDEO_EXTENSIONS = {".mp4", ".mkv", ".webm", ".mov"}
+COMPLETE_MARKER_NAME = ".complete"
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Extract DWpose NPZ files from raw videos."
+    )
+    parser.add_argument("--raw-video-dir", type=Path, default=DEFAULT_RAW_VIDEO_DIR)
+    parser.add_argument("--dataset-dir", type=Path, default=DEFAULT_DATASET_DIR)
+    parser.add_argument("--fps", type=int, default=24)
+    parser.add_argument("--limit", type=int, default=None)
+    parser.add_argument("--workers", type=int, default=None)
+    parser.add_argument("--video-ids", nargs="*", default=None)
+    parser.add_argument("--force", action="store_true")
+    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)
+    return parser.parse_args()
+
+
+def select_video_paths(args: argparse.Namespace) -> List[Path]:
+    args.raw_video_dir.mkdir(parents=True, exist_ok=True)
+    args.dataset_dir.mkdir(parents=True, exist_ok=True)
+    video_id_filter = set(args.video_ids or [])
+    stats = load_stats(args.stats_npz)
+
+    selected = []
+    for path in sorted(args.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_filter and video_id not in video_id_filter:
+            continue
+        npz_dir = args.dataset_dir / video_id / "npz"
+        complete_marker = npz_dir / COMPLETE_MARKER_NAME
+        if (
+            not args.force
+            and npz_dir.exists()
+            and complete_marker.exists()
+            and stats.get(video_id, {}).get("process_status") == "ok"
+        ):
+            continue
+        selected.append(path)
+        if args.limit is not None and len(selected) >= args.limit:
+            break
+    return selected
+
+
+def extract_frames(video_path: Path, frame_dir: Path, fps: int) -> None:
+    command = [
+        "ffmpeg",
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-y",
+        "-i",
+        str(video_path),
+        "-vf",
+        f"fps={fps}",
+        str(frame_dir / "%08d.jpg"),
+    ]
+    subprocess.run(command, check=True)
+
+
+def build_npz_payload(pose_data: Dict[str, np.ndarray], width: int, height: int) -> Dict[str, np.ndarray]:
+    num_persons = int(pose_data["faces"].shape[0]) if "faces" in pose_data else 0
+    payload: Dict[str, np.ndarray] = {
+        "num_persons": np.asarray(num_persons, dtype=np.int32),
+        "frame_width": np.asarray(width, dtype=np.int32),
+        "frame_height": np.asarray(height, dtype=np.int32),
+    }
+    if num_persons == 0:
+        return payload
+
+    bodies = pose_data["bodies"].reshape(num_persons, 18, 2).astype(np.float32)
+    body_scores = pose_data["body_scores"].astype(np.float32)
+    faces = pose_data["faces"].astype(np.float32)
+    face_scores = pose_data["faces_scores"].astype(np.float32)
+    hands = pose_data["hands"].astype(np.float32)
+    hand_scores = pose_data["hands_scores"].astype(np.float32)
+
+    for person_idx in range(num_persons):
+        prefix = f"person_{person_idx:03d}"
+        payload[f"{prefix}_body_keypoints"] = bodies[person_idx]
+        payload[f"{prefix}_body_scores"] = body_scores[person_idx]
+        payload[f"{prefix}_face_keypoints"] = faces[person_idx]
+        payload[f"{prefix}_face_scores"] = face_scores[person_idx]
+        left_hand_idx = person_idx * 2
+        right_hand_idx = left_hand_idx + 1
+        if left_hand_idx < len(hands):
+            payload[f"{prefix}_left_hand_keypoints"] = hands[left_hand_idx]
+            payload[f"{prefix}_left_hand_scores"] = hand_scores[left_hand_idx]
+        if right_hand_idx < len(hands):
+            payload[f"{prefix}_right_hand_keypoints"] = hands[right_hand_idx]
+            payload[f"{prefix}_right_hand_scores"] = hand_scores[right_hand_idx]
+    return payload
+
+
+def process_video(video_path: Path, dataset_dir: Path, fps: int, detector: DWposeDetector, tmp_root: Path, force: bool) -> None:
+    video_id = video_path.stem
+    output_npz_dir = dataset_dir / video_id / "npz"
+    complete_marker = output_npz_dir / COMPLETE_MARKER_NAME
+    if output_npz_dir.exists() and complete_marker.exists() and not force:
+        print(f"Skip {video_id}: NPZ files already exist")
+        return
+
+    if output_npz_dir.exists() and (force or not complete_marker.exists()):
+        shutil.rmtree(output_npz_dir)
+    output_npz_dir.mkdir(parents=True, exist_ok=True)
+
+    tmp_root.mkdir(parents=True, exist_ok=True)
+    frame_dir = Path(tempfile.mkdtemp(prefix=f"sign_dwpose_{video_id}_", dir=str(tmp_root)))
+
+    try:
+        extract_frames(video_path, frame_dir, fps)
+        frame_paths = sorted(frame_dir.glob("*.jpg"))
+        total_frames = len(frame_paths)
+        print(f"{video_id}: extracted {total_frames} frames at {fps} fps")
+
+        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 frame_index == 1 or frame_index % 100 == 0 or frame_index == total_frames:
+                print(f"{video_id}: processed {frame_index}/{total_frames} frames")
+        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",
+            encoding="utf-8",
+        )
+    finally:
+        shutil.rmtree(frame_dir, ignore_errors=True)
+
+
+def worker(rank: int, worker_count: int, video_paths: Sequence[Path], args: argparse.Namespace) -> None:
+    use_cuda = torch.cuda.is_available() and torch.cuda.device_count() > rank
+    device = f"cuda:{rank}" if use_cuda else "cpu"
+    detector = DWposeDetector(device=device)
+    print(f"Worker {rank}: device={device}")
+
+    for index, video_path in enumerate(video_paths):
+        if index % worker_count != rank:
+            continue
+        try:
+            update_video_stats(
+                args.stats_npz,
+                video_path.stem,
+                process_status="running",
+                last_error="",
+                updated_at=time.strftime("%Y-%m-%d %H:%M:%S"),
+            )
+            process_video(
+                video_path=video_path,
+                dataset_dir=args.dataset_dir,
+                fps=args.fps,
+                detector=detector,
+                tmp_root=args.tmp_root,
+                force=args.force,
+            )
+            update_video_stats(
+                args.stats_npz,
+                video_path.stem,
+                process_status="ok",
+                last_error="",
+                updated_at=time.strftime("%Y-%m-%d %H:%M:%S"),
+            )
+            if args.delete_source_on_success and video_path.exists():
+                video_path.unlink()
+                print(f"Worker {rank}: deleted source video {video_path.name}")
+        except Exception as exc:
+            update_video_stats(
+                args.stats_npz,
+                video_path.stem,
+                process_status="failed",
+                last_error=str(exc),
+                updated_at=time.strftime("%Y-%m-%d %H:%M:%S"),
+            )
+            print(f"Worker {rank}: failed on {video_path.name}: {exc}")
+
+
+def main() -> None:
+    args = parse_args()
+    video_paths = select_video_paths(args)
+    if not video_paths:
+        print("No videos need DWpose extraction.")
+        return
+
+    if args.workers is not None:
+        worker_count = max(1, args.workers)
+    else:
+        worker_count = torch.cuda.device_count() if torch.cuda.is_available() else 1
+        worker_count = max(1, worker_count)
+    worker_count = min(worker_count, len(video_paths))
+
+    if worker_count == 1:
+        worker(0, 1, video_paths, args)
+        return
+
+    mp.set_start_method("spawn", force=True)
+    processes = []
+    for rank in range(worker_count):
+        process = mp.Process(target=worker, args=(rank, worker_count, video_paths, args))
+        process.start()
+        processes.append(process)
+
+    failed = False
+    for process in processes:
+        process.join()
+        failed = failed or process.exitcode != 0
+    if failed:
+        raise SystemExit("One or more DWpose workers failed.")
+
+
+if __name__ == "__main__":
+    main()

scripts/pipeline03_upload_to_huggingface.py

@@ -0,0 +1,266 @@
+#!/usr/bin/env python3
+
+import argparse
+import json
+import os
+import shutil
+import sys
+import tarfile
+import time
+from pathlib import Path
+from typing import Dict, List, Sequence, Tuple
+
+from huggingface_hub import HfApi
+
+
+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
+
+
+DEFAULT_DATASET_DIR = REPO_ROOT / "dataset"
+DEFAULT_RAW_VIDEO_DIR = REPO_ROOT / "raw_video"
+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_STATS_NPZ = REPO_ROOT / "stats.npz"
+DEFAULT_TARGET_BYTES = 14 * 1024 * 1024 * 1024
+COMPLETE_MARKER_NAME = ".complete"
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Archive NPZ folders into 14GB tar files and upload them to Hugging Face."
+    )
+    parser.add_argument("--dataset-dir", type=Path, default=DEFAULT_DATASET_DIR)
+    parser.add_argument("--raw-video-dir", type=Path, default=DEFAULT_RAW_VIDEO_DIR)
+    parser.add_argument("--raw-caption-dir", type=Path, default=DEFAULT_RAW_CAPTION_DIR)
+    parser.add_argument("--raw-metadata-dir", type=Path, default=DEFAULT_RAW_METADATA_DIR)
+    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("--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("--require-target-bytes", action="store_true")
+    parser.add_argument("--dry-run", action="store_true")
+    parser.add_argument("--token", default=os.environ.get("HF_TOKEN") or os.environ.get("HUGGINGFACE_HUB_TOKEN"))
+    return parser.parse_args()
+
+
+def load_progress(progress_path: Path) -> Dict[str, object]:
+    if progress_path.exists():
+        with progress_path.open("r", encoding="utf-8") as handle:
+            return json.load(handle)
+    return {"archives": {}, "uploaded_folders": {}}
+
+
+def save_progress(progress_path: Path, progress: Dict[str, object]) -> None:
+    progress_path.parent.mkdir(parents=True, exist_ok=True)
+    with progress_path.open("w", encoding="utf-8") as handle:
+        json.dump(progress, handle, ensure_ascii=False, indent=2)
+
+
+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
+    return total
+
+
+def list_unuploaded_folders(dataset_dir: Path, progress: Dict[str, object]) -> List[Tuple[str, Path, int]]:
+    uploaded_folders = progress.get("uploaded_folders", {})
+    folders = []
+    for folder_path in sorted(dataset_dir.iterdir()):
+        if not folder_path.is_dir():
+            continue
+        folder_name = folder_path.name
+        if folder_name in uploaded_folders:
+            continue
+        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)))
+    return folders
+
+
+def build_batch(folders: Sequence[Tuple[str, Path, int]], target_bytes: int) -> List[Tuple[str, Path, int]]:
+    batch = []
+    total_bytes = 0
+    for folder_info in folders:
+        _, _, folder_bytes = folder_info
+        if batch and total_bytes + folder_bytes > target_bytes:
+            break
+        batch.append(folder_info)
+        total_bytes += folder_bytes
+        if total_bytes >= target_bytes:
+            break
+    return batch
+
+
+def total_batchable_bytes(folders: Sequence[Tuple[str, Path, int]]) -> int:
+    return sum(folder_bytes for _, _, folder_bytes in folders)
+
+
+def next_archive_index(progress: Dict[str, object], repo_files: Sequence[str]) -> int:
+    indices = []
+    for archive_name in progress.get("archives", {}):
+        if archive_name.startswith("Sign_DWPose_NPZ_") and archive_name.endswith(".tar"):
+            indices.append(int(archive_name[-10:-4]))
+    for repo_file in repo_files:
+        name = Path(repo_file).name
+        if name.startswith("Sign_DWPose_NPZ_") and name.endswith(".tar"):
+            indices.append(int(name[-10:-4]))
+    return (max(indices) + 1) if indices else 1
+
+
+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:
+        for folder_name in folder_names:
+            tar.add(dataset_dir / folder_name, arcname=folder_name, recursive=True)
+
+
+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,
+        repo_id=repo_id,
+        repo_type=repo_type,
+    )
+
+
+def cleanup_local_assets(
+    video_ids: Sequence[str],
+    dataset_dir: Path,
+    raw_video_dir: Path,
+    raw_caption_dir: Path,
+    raw_metadata_dir: Path,
+) -> None:
+    for video_id in video_ids:
+        dataset_video_dir = dataset_dir / video_id
+        if dataset_video_dir.exists():
+            shutil.rmtree(dataset_video_dir, ignore_errors=True)
+        for path in raw_video_dir.glob(f"{video_id}.*"):
+            if path.is_file():
+                path.unlink()
+        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()
+
+
+def format_size(num_bytes: int) -> str:
+    size = float(num_bytes)
+    for unit in ["B", "KB", "MB", "GB", "TB"]:
+        if size < 1024 or unit == "TB":
+            return f"{size:.2f} {unit}"
+        size /= 1024
+    return f"{size:.2f} TB"
+
+
+def main() -> None:
+    args = parse_args()
+    progress = load_progress(args.progress_path)
+    api = HfApi(token=args.token)
+    args.dataset_dir.mkdir(parents=True, exist_ok=True)
+
+    try:
+        repo_files = api.list_repo_files(repo_id=args.repo_id, repo_type=args.repo_type)
+    except Exception:
+        repo_files = []
+
+    while True:
+        remaining_folders = list_unuploaded_folders(args.dataset_dir, progress)
+        if not remaining_folders:
+            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)
+        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
+
+        print(f"Create archive {archive_name} with {len(batch_names)} folders ({format_size(batch_bytes)})")
+        for folder_name in batch_names:
+            print(f"  - {folder_name}")
+
+        if args.dry_run:
+            break
+
+        args.archive_dir.mkdir(parents=True, exist_ok=True)
+        update_many_video_stats(
+            args.stats_npz,
+            batch_names,
+            upload_status="uploading",
+            archive_name=archive_name,
+            local_cleanup_status="pending",
+            updated_at=time.strftime("%Y-%m-%d %H:%M:%S"),
+        )
+        try:
+            create_tar_archive(archive_path, args.dataset_dir, batch_names)
+            upload_archive(api, args.repo_id, args.repo_type, archive_path)
+        except Exception as exc:
+            update_many_video_stats(
+                args.stats_npz,
+                batch_names,
+                upload_status="failed",
+                local_cleanup_status="pending",
+                archive_name=archive_name,
+                last_error=str(exc),
+                updated_at=time.strftime("%Y-%m-%d %H:%M:%S"),
+            )
+            raise
+
+        progress["archives"][archive_name] = {
+            "folders": batch_names,
+            "size_bytes": batch_bytes,
+            "uploaded_at": time.strftime("%Y-%m-%d %H:%M:%S"),
+        }
+        for folder_name in batch_names:
+            progress["uploaded_folders"][folder_name] = archive_name
+        save_progress(args.progress_path, progress)
+
+        cleanup_error = ""
+        try:
+            cleanup_local_assets(
+                batch_names,
+                args.dataset_dir,
+                args.raw_video_dir,
+                args.raw_caption_dir,
+                args.raw_metadata_dir,
+            )
+            archive_path.unlink(missing_ok=True)
+        except Exception as exc:
+            cleanup_error = str(exc)
+        repo_files.append(archive_name)
+        update_many_video_stats(
+            args.stats_npz,
+            batch_names,
+            upload_status="uploaded",
+            local_cleanup_status="deleted" if not cleanup_error else "failed",
+            archive_name=archive_name,
+            last_error=cleanup_error,
+            updated_at=time.strftime("%Y-%m-%d %H:%M:%S"),
+        )
+        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()

scripts/visualize_dwpose_npz.py

@@ -0,0 +1,527 @@
+#!/usr/bin/env python3
+
+import argparse
+import importlib.util
+import math
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Dict, Iterable, List
+
+import cv2
+import matplotlib
+import numpy as np
+from PIL import Image
+
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+
+import sys
+
+if str(REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(REPO_ROOT))
+
+from utils.draw_dw_lib import draw_pose
+
+
+VIDEO_EXTENSIONS = (".mp4", ".mkv", ".mov", ".webm")
+EPS = 0.01
+STABLE_SIGNER_OPENPOSE_PATH = Path(
+    "/research/cbim/vast/sf895/code/SignerX-inference-webui/plugins/StableSigner/easy_dwpose/draw/openpose.py"
+)
+_STABLE_SIGNER_OPENPOSE_DRAW = None
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Visualize Sign-DWPose NPZ outputs.")
+    parser.add_argument("--video-dir", type=Path, required=True, help="Dataset video directory, e.g. dataset/<video_id>")
+    parser.add_argument("--npz-dir", type=Path, default=None, help="Optional NPZ directory override")
+    parser.add_argument("--raw-video", type=Path, default=None, help="Optional raw video path for overlay rendering")
+    parser.add_argument("--fps", type=int, default=24, help="Visualization FPS")
+    parser.add_argument("--max-frames", type=int, default=None, help="Limit the number of frames to render")
+    parser.add_argument(
+        "--draw-style",
+        choices=("controlnext", "openpose", "dwpose"),
+        default="controlnext",
+        help="Rendering style. dwpose is kept as an alias of controlnext.",
+    )
+    parser.add_argument("--conf-threshold", type=float, default=0.6, help="Confidence threshold for openpose filtering")
+    parser.add_argument(
+        "--frame-indices",
+        default="1,2,3,4",
+        help="Comma-separated 1-based frame indices for standalone single-frame previews",
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=Path,
+        default=None,
+        help="Visualization output directory. Defaults to <video-dir>/visualization_dwpose",
+    )
+    parser.add_argument("--force", action="store_true", help="Overwrite existing visualization outputs")
+    return parser.parse_args()
+
+
+def parse_frame_indices(value: str) -> List[int]:
+    indices: List[int] = []
+    for item in value.split(","):
+        item = item.strip()
+        if not item:
+            continue
+        index = int(item)
+        if index > 0:
+            indices.append(index)
+    return sorted(set(indices))
+
+
+def normalize_draw_style(value: str) -> str:
+    return "controlnext" if value == "dwpose" else value
+
+
+def get_stablesigner_openpose_draw():
+    global _STABLE_SIGNER_OPENPOSE_DRAW  # noqa: PLW0603
+    if _STABLE_SIGNER_OPENPOSE_DRAW is not None:
+        return _STABLE_SIGNER_OPENPOSE_DRAW
+    if not STABLE_SIGNER_OPENPOSE_PATH.exists():
+        return None
+    spec = importlib.util.spec_from_file_location("stablesigner_openpose_draw", STABLE_SIGNER_OPENPOSE_PATH)
+    if spec is None or spec.loader is None:
+        return None
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    _STABLE_SIGNER_OPENPOSE_DRAW = getattr(module, "draw_pose", None)
+    return _STABLE_SIGNER_OPENPOSE_DRAW
+
+
+def load_npz_frame(npz_path: Path) -> 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"])
+
+    for person_idx in range(frame["num_persons"]):
+        source_prefix = f"person_{person_idx:03d}"
+        target_prefix = f"person_{person_idx}"
+        person_data: Dict[str, np.ndarray] = {}
+        for suffix in (
+            "body_keypoints",
+            "body_scores",
+            "face_keypoints",
+            "face_scores",
+            "left_hand_keypoints",
+            "left_hand_scores",
+            "right_hand_keypoints",
+            "right_hand_scores",
+        ):
+            key = f"{source_prefix}_{suffix}"
+            if key in payload.files:
+                person_data[suffix] = payload[key]
+        if person_data:
+            frame[target_prefix] = person_data
+    return frame
+
+
+def to_openpose_frame(frame: Dict[str, object]) -> Dict[str, np.ndarray]:
+    num_persons = int(frame["num_persons"])
+    bodies: List[np.ndarray] = []
+    body_scores: List[np.ndarray] = []
+    hands: List[np.ndarray] = []
+    hand_scores: List[np.ndarray] = []
+    faces: List[np.ndarray] = []
+    face_scores: List[np.ndarray] = []
+
+    for person_idx in range(num_persons):
+        person = frame.get(f"person_{person_idx}")
+        if not isinstance(person, dict):
+            continue
+        bodies.append(np.asarray(person["body_keypoints"], dtype=np.float32))
+        body_scores.append(np.asarray(person["body_scores"], dtype=np.float32))
+        hands.extend(
+            [
+                np.asarray(person["left_hand_keypoints"], dtype=np.float32),
+                np.asarray(person["right_hand_keypoints"], dtype=np.float32),
+            ]
+        )
+        hand_scores.extend(
+            [
+                np.asarray(person["left_hand_scores"], dtype=np.float32),
+                np.asarray(person["right_hand_scores"], dtype=np.float32),
+            ]
+        )
+        faces.append(np.asarray(person["face_keypoints"], dtype=np.float32))
+        face_scores.append(np.asarray(person["face_scores"], dtype=np.float32))
+
+    if bodies:
+        stacked_bodies = np.vstack(bodies)
+        stacked_subset = np.vstack(body_scores)
+    else:
+        stacked_bodies = np.zeros((0, 2), dtype=np.float32)
+        stacked_subset = np.zeros((0, 18), dtype=np.float32)
+
+    return {
+        "bodies": stacked_bodies,
+        "body_scores": stacked_subset,
+        "hands": np.asarray(hands, dtype=np.float32) if hands else np.zeros((0, 21, 2), dtype=np.float32),
+        "hands_scores": np.asarray(hand_scores, dtype=np.float32) if hand_scores else np.zeros((0, 21), dtype=np.float32),
+        "faces": np.asarray(faces, dtype=np.float32) if faces else np.zeros((0, 68, 2), dtype=np.float32),
+        "faces_scores": np.asarray(face_scores, dtype=np.float32) if face_scores else np.zeros((0, 68), dtype=np.float32),
+    }
+
+
+def filter_pose_for_openpose(frame: Dict[str, np.ndarray], conf_threshold: float, update_subset: bool) -> Dict[str, np.ndarray]:
+    filtered = {key: np.array(value, copy=True) for key, value in frame.items()}
+
+    bodies = filtered.get("bodies", None)
+    body_scores = filtered.get("body_scores", None)
+    if bodies is not None:
+        bodies = bodies.copy()
+        min_valid = 1e-6
+        coord_mask = (bodies[:, 0] > min_valid) & (bodies[:, 1] > min_valid)
+
+        conf_mask = None
+        if body_scores is not None:
+            scores = np.array(body_scores, copy=False)
+            score_vec = scores.reshape(-1) if scores.ndim == 2 else scores
+            score_vec = score_vec.astype(float)
+            conf_mask = score_vec < conf_threshold
+            if conf_mask.shape[0] < bodies.shape[0]:
+                conf_mask = np.pad(conf_mask, (0, bodies.shape[0] - conf_mask.shape[0]), constant_values=False)
+            elif conf_mask.shape[0] > bodies.shape[0]:
+                conf_mask = conf_mask[: bodies.shape[0]]
+        valid_mask = coord_mask if conf_mask is None else (coord_mask & (~conf_mask))
+        bodies[~valid_mask, :] = 0
+        filtered["bodies"] = bodies
+
+        if update_subset:
+            if body_scores is not None:
+                subset = np.array(body_scores, copy=True)
+                if subset.ndim == 1:
+                    subset = subset.reshape(1, -1)
+            else:
+                subset = np.arange(bodies.shape[0], dtype=float).reshape(1, -1)
+            if subset.shape[1] < bodies.shape[0]:
+                subset = np.pad(subset, ((0, 0), (0, bodies.shape[0] - subset.shape[1])), constant_values=-1)
+            elif subset.shape[1] > bodies.shape[0]:
+                subset = subset[:, : bodies.shape[0]]
+            subset[:, ~valid_mask] = -1
+            filtered["body_scores"] = subset
+
+    hands = filtered.get("hands", None)
+    hand_scores = filtered.get("hands_scores", None)
+    if hands is not None and hand_scores is not None:
+        scores = np.array(hand_scores)
+        hands = hands.copy()
+        if hands.ndim == 3 and scores.ndim == 2:
+            for hand_index in range(hands.shape[0]):
+                mask = (scores[hand_index] < conf_threshold) | (scores[hand_index] <= 0)
+                hands[hand_index][mask, :] = 0
+        filtered["hands"] = hands
+
+    faces = filtered.get("faces", None)
+    face_scores = filtered.get("faces_scores", None)
+    if faces is not None and face_scores is not None:
+        scores = np.array(face_scores)
+        faces = faces.copy()
+        if faces.ndim == 3 and scores.ndim == 2:
+            for face_index in range(faces.shape[0]):
+                mask = (scores[face_index] < conf_threshold) | (scores[face_index] <= 0)
+                faces[face_index][mask, :] = 0
+        filtered["faces"] = faces
+
+    return filtered
+
+
+def draw_openpose_body(canvas: np.ndarray, candidate: np.ndarray, subset: np.ndarray, score: np.ndarray, conf_threshold: float) -> np.ndarray:
+    height, width, _ = canvas.shape
+    limb_seq = [
+        [2, 3], [2, 6], [3, 4], [4, 5], [6, 7], [7, 8], [2, 9], [9, 10], [10, 11],
+        [2, 12], [12, 13], [13, 14], [2, 1], [1, 15], [15, 17], [1, 16], [16, 18], [3, 17], [6, 18],
+    ]
+    colors = [
+        [255, 0, 0], [255, 85, 0], [255, 170, 0], [255, 255, 0], [170, 255, 0], [85, 255, 0], [0, 255, 0],
+        [0, 255, 85], [0, 255, 170], [0, 255, 255], [0, 170, 255], [0, 85, 255], [0, 0, 255], [85, 0, 255],
+        [170, 0, 255], [255, 0, 255], [255, 0, 170], [255, 0, 85],
+    ]
+
+    for limb_index in range(17):
+        for person_index in range(len(subset)):
+            index = subset[person_index][np.array(limb_seq[limb_index]) - 1]
+            if -1 in index:
+                continue
+            confidence = score[person_index][np.array(limb_seq[limb_index]) - 1]
+            if confidence[0] < conf_threshold or confidence[1] < conf_threshold:
+                continue
+            coords = candidate[index.astype(int)]
+            if np.any(coords <= EPS):
+                continue
+            y_coords = coords[:, 0] * float(width)
+            x_coords = coords[:, 1] * float(height)
+            mean_x = np.mean(x_coords)
+            mean_y = np.mean(y_coords)
+            length = ((x_coords[0] - x_coords[1]) ** 2 + (y_coords[0] - y_coords[1]) ** 2) ** 0.5
+            angle = math.degrees(math.atan2(x_coords[0] - x_coords[1], y_coords[0] - y_coords[1]))
+            polygon = cv2.ellipse2Poly((int(mean_y), int(mean_x)), (int(length / 2), 4), int(angle), 0, 360, 1)
+            cv2.fillConvexPoly(canvas, polygon, colors[limb_index])
+
+    canvas = (canvas * 0.6).astype(np.uint8)
+    for keypoint_index in range(18):
+        for person_index in range(len(subset)):
+            index = int(subset[person_index][keypoint_index])
+            if index == -1 or score[person_index][keypoint_index] < conf_threshold:
+                continue
+            x_value, y_value = candidate[index][0:2]
+            cv2.circle(canvas, (int(x_value * width), int(y_value * height)), 4, colors[keypoint_index], thickness=-1)
+    return canvas
+
+
+def draw_openpose_hands(canvas: np.ndarray, hand_peaks: np.ndarray, hand_scores: np.ndarray, conf_threshold: float) -> np.ndarray:
+    height, width, _ = canvas.shape
+    edges = [
+        [0, 1], [1, 2], [2, 3], [3, 4], [0, 5], [5, 6], [6, 7], [7, 8], [0, 9], [9, 10],
+        [10, 11], [11, 12], [0, 13], [13, 14], [14, 15], [15, 16], [0, 17], [17, 18], [18, 19], [19, 20],
+    ]
+    for hand_index, peaks in enumerate(hand_peaks):
+        scores = hand_scores[hand_index] if len(hand_scores) > hand_index else None
+        for edge_index, edge in enumerate(edges):
+            x1, y1 = peaks[edge[0]]
+            x2, y2 = peaks[edge[1]]
+            if scores is not None and (scores[edge[0]] < conf_threshold or scores[edge[1]] < conf_threshold):
+                continue
+            x1 = int(x1 * width)
+            y1 = int(y1 * height)
+            x2 = int(x2 * width)
+            y2 = int(y2 * height)
+            if x1 > EPS and y1 > EPS and x2 > EPS and y2 > EPS:
+                cv2.line(
+                    canvas,
+                    (x1, y1),
+                    (x2, y2),
+                    matplotlib.colors.hsv_to_rgb([edge_index / float(len(edges)), 1.0, 1.0]) * 255,
+                    thickness=2,
+                )
+        for point_index, point in enumerate(peaks):
+            if scores is not None and scores[point_index] < conf_threshold:
+                continue
+            x_value = int(point[0] * width)
+            y_value = int(point[1] * height)
+            if x_value > EPS and y_value > EPS:
+                cv2.circle(canvas, (x_value, y_value), 4, (0, 0, 255), thickness=-1)
+    return canvas
+
+
+def draw_openpose_faces(canvas: np.ndarray, face_points: np.ndarray, face_scores: np.ndarray, conf_threshold: float) -> np.ndarray:
+    height, width, _ = canvas.shape
+    for face_index, points in enumerate(face_points):
+        scores = face_scores[face_index] if len(face_scores) > face_index else None
+        for point_index, point in enumerate(points):
+            if scores is not None and scores[point_index] < conf_threshold:
+                continue
+            x_value = int(point[0] * width)
+            y_value = int(point[1] * height)
+            if x_value > EPS and y_value > EPS:
+                cv2.circle(canvas, (x_value, y_value), 3, (255, 255, 255), thickness=-1)
+    return canvas
+
+
+def draw_openpose_frame(frame: Dict[str, np.ndarray], width: int, height: int, conf_threshold: float) -> Image.Image:
+    draw_func = get_stablesigner_openpose_draw()
+    if draw_func is not None:
+        canvas = draw_func(
+            pose=frame,
+            height=height,
+            width=width,
+            include_face=True,
+            include_hands=True,
+            conf_threshold=conf_threshold,
+        )
+        return Image.fromarray(canvas, "RGB")
+
+    canvas = np.zeros((height, width, 3), dtype=np.uint8)
+    bodies = frame["bodies"]
+    subset = frame.get("body_scores", np.zeros((1, 18), dtype=np.float32))
+    if subset.ndim == 1:
+        subset = subset.reshape(1, -1)
+    canvas = draw_openpose_body(canvas, bodies, subset, subset, conf_threshold)
+    if len(frame.get("faces", [])) > 0:
+        canvas = draw_openpose_faces(canvas, frame["faces"], frame.get("faces_scores", np.zeros((0, 68))), conf_threshold)
+    if len(frame.get("hands", [])) > 0:
+        canvas = draw_openpose_hands(canvas, frame["hands"], frame.get("hands_scores", np.zeros((0, 21))), conf_threshold)
+    return Image.fromarray(canvas, "RGB")
+
+
+def render_pose_image(frame: Dict[str, object], draw_style: str, transparent: bool, conf_threshold: float) -> Image.Image:
+    width = int(frame["frame_width"])
+    height = int(frame["frame_height"])
+    if draw_style == "openpose":
+        openpose_frame = filter_pose_for_openpose(
+            to_openpose_frame(frame),
+            conf_threshold=conf_threshold,
+            update_subset=True,
+        )
+        image = draw_openpose_frame(openpose_frame, width, height, conf_threshold)
+        if not transparent:
+            return image
+        rgba = image.convert("RGBA")
+        alpha = np.where(np.array(image).sum(axis=2) > 0, 255, 0).astype(np.uint8)
+        rgba.putalpha(Image.fromarray(alpha, "L"))
+        return rgba
+
+    rendered = draw_pose(
+        frame,
+        H=height,
+        W=width,
+        include_body=True,
+        include_hand=True,
+        include_face=True,
+        transparent=transparent,
+    )
+    rendered = np.transpose(rendered, (1, 2, 0))
+    if rendered.dtype != np.uint8:
+        rendered = np.clip(rendered * 255.0, 0, 255).astype(np.uint8)
+    return Image.fromarray(rendered, "RGBA" if transparent else "RGB")
+
+
+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)
+        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")
+
+
+def render_pose_frames(npz_paths: List[Path], pose_frame_dir: Path, draw_style: str, conf_threshold: float) -> None:
+    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)
+        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:
+            print(f"Rendered pose frame {index}/{total}: {npz_path.name}")
+
+
+def create_video_from_frames(frame_dir: Path, output_path: Path, fps: int) -> None:
+    if not any(frame_dir.glob("*.png")):
+        return
+    command = [
+        "ffmpeg",
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-y",
+        "-framerate",
+        str(fps),
+        "-i",
+        str(frame_dir / "%08d.png"),
+        "-c:v",
+        "libx264",
+        "-pix_fmt",
+        "yuv420p",
+        str(output_path),
+    ]
+    subprocess.run(command, check=True)
+
+
+def resolve_raw_video(video_dir: Path, raw_video: Path | None) -> Path | None:
+    if raw_video is not None and raw_video.exists():
+        return raw_video
+    video_id = video_dir.name
+    raw_root = REPO_ROOT / "raw_video"
+    for extension in VIDEO_EXTENSIONS:
+        candidate = raw_root / f"{video_id}{extension}"
+        if candidate.exists():
+            return candidate
+    return None
+
+
+def extract_video_frames(raw_video: Path, fps: int, temp_dir: Path) -> List[Path]:
+    temp_dir.mkdir(parents=True, exist_ok=True)
+    command = [
+        "ffmpeg",
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-y",
+        "-i",
+        str(raw_video),
+        "-vf",
+        f"fps={fps}",
+        str(temp_dir / "%08d.png"),
+    ]
+    subprocess.run(command, check=True)
+    return sorted(temp_dir.glob("*.png"))
+
+
+def render_overlay_frames(
+    npz_paths: List[Path],
+    raw_frame_paths: List[Path],
+    overlay_dir: Path,
+    draw_style: str,
+    conf_threshold: float,
+) -> None:
+    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)
+        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")
+        overlay = Image.alpha_composite(base, pose_rgba)
+        overlay.save(overlay_dir / f"{npz_path.stem}.png")
+        if index == 1 or index % 100 == 0 or index == frame_count:
+            print(f"Rendered overlay frame {index}/{frame_count}: {npz_path.name}")
+
+
+def main() -> None:
+    args = parse_args()
+    args.draw_style = normalize_draw_style(args.draw_style)
+    video_dir = args.video_dir.resolve()
+    npz_dir = (args.npz_dir or (video_dir / "npz")).resolve()
+    output_dir = (args.output_dir or (video_dir / f"visualization_{args.draw_style}")).resolve()
+    pose_frame_dir = output_dir / "pose_frames"
+    single_frame_dir = output_dir / "single_frames"
+    overlay_frame_dir = output_dir / "overlay_frames"
+    pose_video_path = output_dir / f"visualization_{args.draw_style}.mp4"
+    overlay_video_path = output_dir / f"visualization_{args.draw_style}_overlay.mp4"
+
+    if not npz_dir.exists():
+        raise FileNotFoundError(f"NPZ directory not found: {npz_dir}")
+
+    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:
+        raise FileNotFoundError(f"No NPZ files found in {npz_dir}")
+
+    if output_dir.exists() and args.force:
+        shutil.rmtree(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    preview_indices = parse_frame_indices(args.frame_indices)
+    preview_paths = [
+        npz_paths[index - 1]
+        for index in preview_indices
+        if 0 < index <= len(npz_paths)
+    ]
+    save_frame_previews(preview_paths, single_frame_dir, args.draw_style, args.conf_threshold)
+
+    render_pose_frames(npz_paths, pose_frame_dir, args.draw_style, args.conf_threshold)
+    create_video_from_frames(pose_frame_dir, pose_video_path, args.fps)
+
+    raw_video = resolve_raw_video(video_dir, args.raw_video)
+    if raw_video is None:
+        print("No raw video found for overlay rendering. Pose-only outputs were created.")
+        return
+
+    temp_root = Path(tempfile.mkdtemp(prefix="sign_dwpose_overlay_"))
+    try:
+        raw_frame_paths = extract_video_frames(raw_video, args.fps, temp_root)
+        render_overlay_frames(npz_paths, raw_frame_paths, overlay_frame_dir, args.draw_style, args.conf_threshold)
+        create_video_from_frames(overlay_frame_dir, overlay_video_path, args.fps)
+    finally:
+        shutil.rmtree(temp_root, ignore_errors=True)
+
+
+if __name__ == "__main__":
+    main()

utils/draw_dw_lib.py

@@ -0,0 +1,294 @@
+import math
+import numpy as np
+import matplotlib
+import cv2
+import sys
+import os
+import _pickle as cPickle
+import gzip
+import subprocess
+import torch
+import colorsys
+from typing import List, Dict, Any, Optional, Tuple
+
+
+eps = 0.01
+
+def alpha_blend_color(color, alpha):
+    """blend color according to point conf
+    """
+    return [int(c * alpha) for c in color]
+
+def draw_bodypose(canvas, candidate, subset, score, transparent=False):
+    """Draw body pose on canvas
+    Args:
+        canvas: numpy array canvas to draw on
+        candidate: pose candidate
+        subset: pose subset
+        score: confidence scores
+        transparent: whether to use transparent background
+    Returns:
+        canvas: drawn canvas
+    """
+    H, W, C = canvas.shape
+    candidate = np.array(candidate)
+    subset = np.array(subset)
+
+    stickwidth = 4
+
+    limbSeq = [[2, 3], [2, 6], [3, 4], [4, 5], [6, 7], [7, 8], [2, 9], [9, 10],
+               [10, 11], [2, 12], [12, 13], [13, 14], [2, 1], [1, 15], [15, 17],
+               [1, 16], [16, 18], [3, 17], [6, 18]]
+
+    colors = [[255, 0, 0], [255, 85, 0], [255, 170, 0], [255, 255, 0], [170, 255, 0], [85, 255, 0], [0, 255, 0],
+              [0, 255, 85], [0, 255, 170], [0, 255, 255], [0, 170, 255], [0, 85, 255], [0, 0, 255], [85, 0, 255],
+              [170, 0, 255], [255, 0, 255], [255, 0, 170], [255, 0, 85]]
+
+    # Add alpha channel if transparent
+    if transparent:
+        colors = [color + [255] for color in colors]
+
+    for i in range(17):
+        for n in range(len(subset)):
+            index = subset[n][np.array(limbSeq[i]) - 1]
+            conf = score[n][np.array(limbSeq[i]) - 1]
+            if conf[0] < 0.3 or conf[1] < 0.3:
+                continue
+            Y = candidate[index.astype(int), 0] * float(W)
+            X = candidate[index.astype(int), 1] * float(H)
+            mX = np.mean(X)
+            mY = np.mean(Y)
+            length = ((X[0] - X[1]) ** 2 + (Y[0] - Y[1]) ** 2) ** 0.5
+            angle = math.degrees(math.atan2(X[0] - X[1], Y[0] - Y[1]))
+            polygon = cv2.ellipse2Poly((int(mY), int(mX)), (int(length / 2), stickwidth), int(angle), 0, 360, 1)
+            if transparent:
+                color = colors[i][:-1] + [int(255 * conf[0] * conf[1])]  # Adjust alpha based on confidence
+            else:
+                color = colors[i]
+            cv2.fillConvexPoly(canvas, polygon, color)
+
+    canvas = (canvas * 0.6).astype(np.uint8)
+
+    for i in range(18):
+        for n in range(len(subset)):
+            index = int(subset[n][i])
+            if index == -1:
+                continue
+            x, y = candidate[index][0:2]
+            conf = score[n][i]
+            x = int(x * W)
+            y = int(y * H)
+            if transparent:
+                color = colors[i][:-1] + [int(255 * conf)]  # Adjust alpha based on confidence
+            else:
+                color = colors[i]
+            cv2.circle(canvas, (int(x), int(y)), 4, color, thickness=-1)
+
+    return canvas
+
+def draw_handpose(canvas, all_hand_peaks, all_hand_scores, transparent=False):
+    """Draw hand pose on canvas"""
+    H, W, C = canvas.shape
+
+    edges = [[0, 1], [1, 2], [2, 3], [3, 4], [0, 5], [5, 6], [6, 7], [7, 8], [0, 9], [9, 10],
+             [10, 11], [11, 12], [0, 13], [13, 14], [14, 15], [15, 16], [0, 17], [17, 18], [18, 19], [19, 20]]
+
+    for peaks, scores in zip(all_hand_peaks, all_hand_scores):
+        for ie, e in enumerate(edges):
+            x1, y1 = peaks[e[0]]
+            x2, y2 = peaks[e[1]]
+            x1 = int(x1 * W)
+            y1 = int(y1 * H)
+            x2 = int(x2 * W)
+            y2 = int(y2 * H)
+            score = scores[e[0]] * scores[e[1]]
+            if x1 > eps and y1 > eps and x2 > eps and y2 > eps:
+                color = matplotlib.colors.hsv_to_rgb([ie / float(len(edges)), 1.0, 1.0])
+                if transparent:
+                    color = np.append(color, score)  # Add alpha channel
+                else:
+                    color = color * score
+                cv2.line(canvas, (x1, y1), (x2, y2), color * 255, thickness=2)
+
+        for i, keypoint in enumerate(peaks):
+            x, y = keypoint
+            x = int(x * W)
+            y = int(y * H)
+            if x > eps and y > eps:
+                if transparent:
+                    color = (0, 0, 0, scores[i])  # Black with alpha
+                else:
+                    color = (0, 0, int(scores[i] * 255))  # Original color
+                cv2.circle(canvas, (x, y), 4, color, thickness=-1)
+    return canvas
+
+def draw_facepose(canvas, all_lmks, all_scores, transparent=False):
+    """Draw face pose on canvas"""
+    H, W, C = canvas.shape
+    for lmks, scores in zip(all_lmks, all_scores):
+        for lmk, score in zip(lmks, scores):
+            x, y = lmk
+            x = int(x * W)
+            y = int(y * H)
+            if x > eps and y > eps:
+                if transparent:
+                    color = (255, 255, 255, int(score * 255))  # White with alpha
+                else:
+                    conf = int(score * 255)
+                    color = (conf, conf, conf)  # Original grayscale
+                cv2.circle(canvas, (x, y), 3, color, thickness=-1)
+    return canvas
+
+def draw_pose(pose, H, W, include_body=True, include_hand=True, include_face=True, ref_w=2160, transparent=False):
+    """vis dwpose outputs with optional transparent background
+
+    Args:
+        pose (Dict): DWposeDetector outputs - 支持新的person_id格式和旧格式
+        H (int): height
+        W (int): width
+        include_body (bool): whether to draw body keypoints
+        include_hand (bool): whether to draw hand keypoints
+        include_face (bool): whether to draw face keypoints
+        ref_w (int, optional): reference width. Defaults to 2160.
+        transparent (bool, optional): whether to use transparent background. Defaults to False.
+
+    Returns:
+        np.ndarray: image pixel value in RGBA mode if transparent=True, otherwise RGB mode
+    """
+    sz = min(H, W)
+    sr = (ref_w / sz) if sz != ref_w else 1
+
+    # Create canvas - now with alpha channel if transparent
+    if transparent:
+        canvas = np.zeros(shape=(int(H*sr), int(W*sr), 4), dtype=np.uint8)
+    else:
+        canvas = np.zeros(shape=(int(H*sr), int(W*sr), 3), dtype=np.uint8)
+
+    # 检查是否是新的person_id数据格式
+    if 'num_persons' in pose and pose['num_persons'] > 0:
+        # 使用新的多人数据结构
+        processed_data = process_pose_data(pose, H, W)
+        bodies = processed_data['bodies']
+        faces = processed_data['faces']
+        hands = processed_data['hands']
+        candidate = bodies['candidate']
+        subset = bodies['subset']
+        
+        if include_body:
+            canvas = draw_bodypose(canvas, candidate, subset, score=bodies['score'], transparent=transparent)
+
+        if include_hand:
+            canvas = draw_handpose(canvas, hands, processed_data['hands_score'], transparent=transparent)
+
+        if include_face:
+            canvas = draw_facepose(canvas, faces, processed_data['faces_score'], transparent=transparent)
+    
+    else:
+        # 兼容旧的数据格式 - 作为备选方案
+        try:
+            bodies = pose['bodies']
+            faces = pose['faces']
+            hands = pose['hands']
+            candidate = bodies['candidate']
+            subset = bodies['subset']
+
+            if include_body:
+                canvas = draw_bodypose(canvas, candidate, subset, score=bodies['score'], transparent=transparent)
+
+            if include_hand:
+                canvas = draw_handpose(canvas, hands, pose['hands_score'], transparent=transparent)
+
+            if include_face:
+                canvas = draw_facepose(canvas, faces, pose['faces_score'], transparent=transparent)
+        except Exception as e:
+            print(f"绘制旧格式数据失败: {str(e)}")
+            # 返回空画布
+            pass
+
+    if transparent:
+        return cv2.cvtColor(cv2.resize(canvas, (W, H)), cv2.COLOR_BGRA2RGBA).transpose(2, 0, 1)
+    else:
+        return cv2.cvtColor(cv2.resize(canvas, (W, H)), cv2.COLOR_BGR2RGB).transpose(2, 0, 1)
+
+def process_pose_data(pose_data: Dict[str, Any], height: int, width: int) -> Dict[str, Any]:
+    """
+    处理姿势数据，完全支持新的person_id数据结构
+    """
+    processed_data = {}
+    
+    # 确保使用新的数据结构
+    if 'num_persons' in pose_data and pose_data['num_persons'] > 0:
+        num_persons = pose_data['num_persons']
+        
+        # 收集所有人的关键点数据
+        all_bodies = []
+        all_body_scores = []
+        all_hands = []
+        all_hand_scores = []
+        all_faces = []
+        all_face_scores = []
+        
+        for person_id in range(num_persons):
+            person_key = f'person_{person_id}'
+            if person_key in pose_data:
+                person_data = pose_data[person_key]
+                all_bodies.append(person_data['body_keypoints'])
+                all_body_scores.append(person_data['body_scores'])
+                all_hands.extend([person_data['left_hand_keypoints'], person_data['right_hand_keypoints']])
+                all_hand_scores.extend([person_data['left_hand_scores'], person_data['right_hand_scores']])
+                all_faces.append(person_data['face_keypoints'])
+                all_face_scores.append(person_data['face_scores'])
+        
+        # 合并所有人的数据
+        if all_bodies:
+            bodies = np.vstack(all_bodies)
+            body_scores = np.array(all_body_scores)
+            
+            # 创建subset - 为每个人创建独立的subset行
+            subset = []
+            for person_id in range(num_persons):
+                person_subset = list(range(person_id * 18, (person_id + 1) * 18))
+                subset.append(person_subset)
+            subset = np.array(subset)
+            
+            # 创建scores - 基于body_scores中的有效性
+            scores = np.ones_like(body_scores)
+            for i in range(num_persons):
+                for j in range(18):
+                    if body_scores[i, j] < 0:  # 如果body_scores为负数，认为无效
+                        scores[i, j] = 0.0
+                    else:
+                        scores[i, j] = 1.0
+        else:
+            bodies = np.array([])
+            subset = np.array([[]])
+            scores = np.array([[]])
+        
+        hands = np.array(all_hands) if all_hands else np.array([])
+        hand_scores = np.array(all_hand_scores) if all_hand_scores else np.array([])
+        faces = np.array(all_faces) if all_faces else np.array([])
+        face_scores = np.array(all_face_scores) if all_face_scores else np.array([])
+        
+    else:
+        # 兼容性处理 - 如果不是新格式，返回空数据
+        bodies = np.array([])
+        subset = np.array([[]])
+        scores = np.array([[]])
+        hands = np.array([])
+        hand_scores = np.array([])
+        faces = np.array([])
+        face_scores = np.array([])
+    
+    processed_data['bodies'] = {
+        'candidate': bodies,
+        'subset': subset,
+        'score': scores
+    }
+    
+    processed_data['hands'] = hands
+    processed_data['hands_score'] = hand_scores
+    
+    processed_data['faces'] = faces
+    processed_data['faces_score'] = face_scores
+    
+    return processed_data

utils/preprocess_video.py

@@ -0,0 +1,259 @@
+import os
+import shutil
+import subprocess
+import av
+import torch
+import torch.distributed as dist
+import torch.multiprocessing as mp
+from torch.nn.parallel import DistributedDataParallel
+from utils.util import get_fps, read_frames, save_videos_from_pil
+from utils.preprocess_video import *
+from PIL import Image
+import numpy as np
+import json
+
+def ensure_dir(directory):
+    if os.path.exists(directory):
+        print(f"Directory already exists: {directory}")
+    else:
+        os.makedirs(directory)
+        print(f"Created directory: {directory}")
+    return directory
+
+# [previous helper functions remain the same]
+def get_video_dimensions(video_path):
+    cmd = [
+        'ffprobe',
+        '-v', 'error',
+        '-select_streams', 'v:0',
+        '-show_entries', 'stream=width,height',
+        '-of', 'csv=p=0',
+        video_path
+    ]
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    width, height = map(int, result.stdout.strip().split(','))
+    return width, height
+
+def compile_frames_to_video(frame_dir, output_path, fps=30):
+    """Compile frames into a video using H.264 codec."""
+    cmd = [
+        'ffmpeg', '-y',
+        '-f', 'image2',
+        '-r', str(fps),
+        '-i', f'{frame_dir}/%08d.jpg',
+        '-c:v', 'libx264',
+        '-preset', 'medium',
+        '-crf', '18',
+        '-pix_fmt', 'yuv420p',
+        output_path
+    ]
+    subprocess.run(cmd, check=True)
+    print(f"Successfully compiled video: {output_path}")
+
+def preprocess_videos(video_dir, dataset_name, square_crop=False, fps=24, quality_preset="medium", target_resolution=None):
+    """
+    Preprocess all videos with optional square cropping, customizable FPS, quality, and resolution.
+    
+    Args:
+        video_dir (str): Directory containing input videos
+        dataset_name (str): Name of the dataset
+        square_crop (bool): Whether to crop videos to 1:1 aspect ratio (default: True)
+        fps (int): Target frames per second (default: 30)
+        quality_preset (str): Quality preset - "high", "medium", "low", "ultra_low" (default: "medium")
+        target_resolution (int): Target resolution for the shorter side (e.g., 512, 256). None for original
+    """
+    result_dir = ensure_dir(f"../output/{dataset_name}_results")
+
+    # 质量设置
+    quality_settings = {
+        "high": {"qscale": "2", "crf": "18"},      # 高质量
+        "medium": {"qscale": "5", "crf": "23"},    # 中等质量
+        "low": {"qscale": "10", "crf": "28"},      # 低质量
+        "ultra_low": {"qscale": "15", "crf": "35"} # 超低质量
+    }
+    
+    current_quality = quality_settings.get(quality_preset, quality_settings["medium"])
+
+    for video_file in os.listdir(video_dir):
+        if not video_file.endswith(".mp4"):
+            continue
+
+        video_name = os.path.splitext(video_file)[0]
+        video_full_path = os.path.join(video_dir, video_file)
+        folder_path = f"{result_dir}/{video_name}"
+        
+        frame_path = f"{folder_path}/crop_frame"
+        output_video_path = f"{folder_path}/crop_original_video.mp4"
+
+        # Skip if already processed
+        if os.path.exists(frame_path) and os.listdir(frame_path) and os.path.exists(output_video_path):
+            crop_status = "cropped" if square_crop else "original"
+            print(f"{crop_status.capitalize()} frames and video already exist for {video_name}. Skipping preprocessing.")
+            continue
+
+        try:
+            # Create output directory
+            os.makedirs(frame_path, exist_ok=True)
+
+            # Get video dimensions
+            width, height = get_video_dimensions(video_full_path)
+            
+            # 构建视频滤镜
+            filters = []
+            
+            if square_crop:
+                # Calculate crop dimensions
+                if width < height:
+                    crop_size = width
+                    x_offset = 0
+                    y_offset = (height - width) // 2
+                else:
+                    crop_size = height
+                    x_offset = (width - height) // 2
+                    y_offset = 0
+                filters.append(f'crop={crop_size}:{crop_size}:{x_offset}:{y_offset}')
+            
+            # 添加分辨率缩放
+            if target_resolution:
+                if square_crop:
+                    # 方形裁剪后直接缩放到目标分辨率
+                    filters.append(f'scale={target_resolution}:{target_resolution}')
+                else:
+                    # 保持宽高比缩放
+                    filters.append(f'scale=-2:{target_resolution}:force_original_aspect_ratio=decrease')
+            
+            # 添加帧率
+            filters.append(f'fps={fps}/1')
+            
+            # 组合所有滤镜
+            filter_complex = ','.join(filters)
+
+            # 提取帧的命令
+            cmd = [
+                'ffmpeg', '-i', video_full_path,
+                '-vf', filter_complex,
+                '-f', 'image2',
+                '-qscale', current_quality["qscale"],  # 使用可调节的质量
+                f'{frame_path}/%08d.jpg'
+            ]
+            
+            resolution_info = f" (Resolution: {target_resolution})" if target_resolution else ""
+            crop_info = "with square cropping" if square_crop else "without cropping"
+            print(f"Processing {video_file} {crop_info} (FPS: {fps}, Quality: {quality_preset}{resolution_info})")
+
+            subprocess.run(cmd, check=True)
+            print(f"Successfully extracted frames for {video_file}")
+
+            # Compile frames back into a video with optimized settings
+            compile_frames_to_video_optimized(frame_path, output_video_path, fps, quality_preset)
+
+        except Exception as e:
+            print(f"Error preprocessing {video_file}: {str(e)}")
+            continue
+
+def compile_frames_to_video_optimized(frame_dir, output_path, fps=30, quality_preset="medium"):
+    """Compile frames into a video with optimized quality settings."""
+    
+    # 质量设置 - CRF值（越高质量越低，文件越小）
+    quality_crf = {
+        "high": "18",
+        "medium": "23", 
+        "low": "28",
+        "ultra_low": "35"
+    }
+    
+    crf_value = quality_crf.get(quality_preset, "23")
+    
+    cmd = [
+        'ffmpeg', '-y',
+        '-f', 'image2',
+        '-r', str(fps),
+        '-i', f'{frame_dir}/%08d.jpg',
+        '-c:v', 'libx264',
+        '-preset', 'medium',  # 可以改为 'fast' 加速编码
+        '-crf', crf_value,
+        '-pix_fmt', 'yuv420p',
+        output_path
+    ]
+    subprocess.run(cmd, check=True)
+    print(f"Successfully compiled optimized video: {output_path} (Quality: {quality_preset})")
+
+# 使用示例：
+
+# 1. 保持原分辨率，降低质量
+# preprocess_videos(video_dir, dataset_name, square_crop=True, fps=30, quality_preset="low")
+
+# 2. 降低分辨率到512x512（方形裁剪）
+# preprocess_videos(video_dir, dataset_name, square_crop=True, fps=30, quality_preset="medium", target_resolution=512)
+
+# 3. 极度压缩：低分辨率 + 超低质量
+# preprocess_videos(video_dir, dataset_name, square_crop=True, fps=30, quality_preset="ultra_low", target_resolution=256)
+
+# 4. 不裁剪，但缩放到较小尺寸
+# preprocess_videos(video_dir, dataset_name, square_crop=False, fps=30, quality_preset="low", target_resolution=480)
+
+def process_npz_files(input_folder_path, output_folder_path):
+    """
+    Process all NPZ files in the specified folder and generate the required output format.
+    
+    Args:
+        input_folder_path (str): Path to the folder containing NPZ files
+        output_folder_path (str): Path where output files will be saved
+    """
+    # Get all NPZ files in the folder
+    npz_files = sorted([f for f in os.listdir(input_folder_path) if f.endswith('.npz')])
+    total_frames = len(npz_files)
+    
+    output = []
+    
+    for idx, npz_file in enumerate(npz_files):
+        file_path = os.path.join(input_folder_path, npz_file)
+        data = np.load(file_path, allow_pickle=True)
+        
+        # Process bodies data
+        bodies = data['bodies']
+        body_scores = data['body_scores'][0]
+        
+        # Process hands data
+        hands = data['hands']
+        hands_scores = data['hands_scores']
+        
+        # Process faces data
+        faces = data['faces'][0]
+        faces_scores = data['faces_scores'][0]
+        
+        # Convert coordinates to strings with space separation
+        frame_data = []
+        
+        # Add body coordinates and scores
+        for i in range(bodies.shape[0]):
+            frame_data.extend([f"{bodies[i][0]:.8f}", f"{bodies[i][1]:.8f}"])
+        for score in body_scores:
+            frame_data.append(f"{score:.8f}")
+            
+        # Add hand coordinates and scores
+        for hand in hands:
+            for point in hand:
+                frame_data.extend([f"{point[0]:.8f}", f"{point[1]:.8f}"])
+        for hand_score in hands_scores:
+            frame_data.extend([f"{score:.8f}" for score in hand_score])
+            
+        # Add face coordinates and scores
+        for point in faces:
+            frame_data.extend([f"{point[0]:.8f}", f"{point[1]:.8f}"])
+        for score in faces_scores:
+            frame_data.append(f"{score:.8f}")
+            
+        # Add frame count
+        frame_count = idx / (total_frames - 1) if total_frames > 1 else 0
+        frame_data.append(f"{frame_count:.8f}")
+        
+        # 验证这一帧的数据点数是否为385
+        if len(frame_data) != 385:
+            print(f"Warning: Frame {idx} in {input_folder_path} has {len(frame_data)} values instead of 385")
+            continue  # 跳过这一帧
+
+        # Join all data with spaces
+        output.append(" ".join(frame_data))
+    
+    return " ".join(output) + "\n"

utils/preprocess_video_improve.py

@@ -0,0 +1,258 @@
+import os
+import shutil
+import subprocess
+import av
+import torch
+import torch.distributed as dist
+import torch.multiprocessing as mp
+from torch.nn.parallel import DistributedDataParallel
+from utils.util import get_fps, read_frames, save_videos_from_pil
+from PIL import Image
+import numpy as np
+import json
+
+def ensure_dir(directory):
+    if os.path.exists(directory):
+        print(f"Directory already exists: {directory}")
+    else:
+        os.makedirs(directory)
+        print(f"Created directory: {directory}")
+    return directory
+
+# [previous helper functions remain the same]
+def get_video_dimensions(video_path):
+    cmd = [
+        'ffprobe',
+        '-v', 'error',
+        '-select_streams', 'v:0',
+        '-show_entries', 'stream=width,height',
+        '-of', 'csv=p=0',
+        video_path
+    ]
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    width, height = map(int, result.stdout.strip().split(','))
+    return width, height
+
+def compile_frames_to_video(frame_dir, output_path, fps=30):
+    """Compile frames into a video using H.264 codec."""
+    cmd = [
+        'ffmpeg', '-y',
+        '-f', 'image2',
+        '-r', str(fps),
+        '-i', f'{frame_dir}/%08d.jpg',
+        '-c:v', 'libx264',
+        '-preset', 'medium',
+        '-crf', '18',
+        '-pix_fmt', 'yuv420p',
+        output_path
+    ]
+    subprocess.run(cmd, check=True)
+    print(f"Successfully compiled video: {output_path}")
+
+def preprocess_videos(video_dir, dataset_name, square_crop=False, fps=24, quality_preset="medium", target_resolution=None):
+    """
+    Preprocess all videos with optional square cropping, customizable FPS, quality, and resolution.
+    
+    Args:
+        video_dir (str): Directory containing input videos
+        dataset_name (str): Name of the dataset
+        square_crop (bool): Whether to crop videos to 1:1 aspect ratio (default: True)
+        fps (int): Target frames per second (default: 30)
+        quality_preset (str): Quality preset - "high", "medium", "low", "ultra_low" (default: "medium")
+        target_resolution (int): Target resolution for the shorter side (e.g., 512, 256). None for original
+    """
+    result_dir = ensure_dir(f"../output/{dataset_name}_results")
+
+    # 质量设置
+    quality_settings = {
+        "high": {"qscale": "2", "crf": "18"},      # 高质量
+        "medium": {"qscale": "5", "crf": "23"},    # 中等质量
+        "low": {"qscale": "10", "crf": "28"},      # 低质量
+        "ultra_low": {"qscale": "15", "crf": "35"} # 超低质量
+    }
+    
+    current_quality = quality_settings.get(quality_preset, quality_settings["medium"])
+
+    for video_file in os.listdir(video_dir):
+        if not video_file.endswith(".mp4"):
+            continue
+
+        video_name = os.path.splitext(video_file)[0]
+        video_full_path = os.path.join(video_dir, video_file)
+        folder_path = f"{result_dir}/{video_name}"
+        
+        frame_path = f"{folder_path}/crop_frame"
+        output_video_path = f"{folder_path}/crop_original_video.mp4"
+
+        # Skip if already processed
+        if os.path.exists(frame_path) and os.listdir(frame_path) and os.path.exists(output_video_path):
+            crop_status = "cropped" if square_crop else "original"
+            print(f"{crop_status.capitalize()} frames and video already exist for {video_name}. Skipping preprocessing.")
+            continue
+
+        try:
+            # Create output directory
+            os.makedirs(frame_path, exist_ok=True)
+
+            # Get video dimensions
+            width, height = get_video_dimensions(video_full_path)
+            
+            # 构建视频滤镜
+            filters = []
+            
+            if square_crop:
+                # Calculate crop dimensions
+                if width < height:
+                    crop_size = width
+                    x_offset = 0
+                    y_offset = (height - width) // 2
+                else:
+                    crop_size = height
+                    x_offset = (width - height) // 2
+                    y_offset = 0
+                filters.append(f'crop={crop_size}:{crop_size}:{x_offset}:{y_offset}')
+            
+            # 添加分辨率缩放
+            if target_resolution:
+                if square_crop:
+                    # 方形裁剪后直接缩放到目标分辨率
+                    filters.append(f'scale={target_resolution}:{target_resolution}')
+                else:
+                    # 保持宽高比缩放
+                    filters.append(f'scale=-2:{target_resolution}:force_original_aspect_ratio=decrease')
+            
+            # 添加帧率
+            filters.append(f'fps={fps}/1')
+            
+            # 组合所有滤镜
+            filter_complex = ','.join(filters)
+
+            # 提取帧的命令
+            cmd = [
+                'ffmpeg', '-i', video_full_path,
+                '-vf', filter_complex,
+                '-f', 'image2',
+                '-qscale', current_quality["qscale"],  # 使用可调节的质量
+                f'{frame_path}/%08d.jpg'
+            ]
+            
+            resolution_info = f" (Resolution: {target_resolution})" if target_resolution else ""
+            crop_info = "with square cropping" if square_crop else "without cropping"
+            print(f"Processing {video_file} {crop_info} (FPS: {fps}, Quality: {quality_preset}{resolution_info})")
+
+            subprocess.run(cmd, check=True)
+            print(f"Successfully extracted frames for {video_file}")
+
+            # Compile frames back into a video with optimized settings
+            compile_frames_to_video_optimized(frame_path, output_video_path, fps, quality_preset)
+
+        except Exception as e:
+            print(f"Error preprocessing {video_file}: {str(e)}")
+            continue
+
+def compile_frames_to_video_optimized(frame_dir, output_path, fps=30, quality_preset="medium"):
+    """Compile frames into a video with optimized quality settings."""
+    
+    # 质量设置 - CRF值（越高质量越低，文件越小）
+    quality_crf = {
+        "high": "18",
+        "medium": "23", 
+        "low": "28",
+        "ultra_low": "35"
+    }
+    
+    crf_value = quality_crf.get(quality_preset, "23")
+    
+    cmd = [
+        'ffmpeg', '-y',
+        '-f', 'image2',
+        '-r', str(fps),
+        '-i', f'{frame_dir}/%08d.jpg',
+        '-c:v', 'libx264',
+        '-preset', 'medium',  # 可以改为 'fast' 加速编码
+        '-crf', crf_value,
+        '-pix_fmt', 'yuv420p',
+        output_path
+    ]
+    subprocess.run(cmd, check=True)
+    print(f"Successfully compiled optimized video: {output_path} (Quality: {quality_preset})")
+
+# 使用示例：
+
+# 1. 保持原分辨率，降低质量
+# preprocess_videos(video_dir, dataset_name, square_crop=True, fps=30, quality_preset="low")
+
+# 2. 降低分辨率到512x512（方形裁剪）
+# preprocess_videos(video_dir, dataset_name, square_crop=True, fps=30, quality_preset="medium", target_resolution=512)
+
+# 3. 极度压缩：低分辨率 + 超低质量
+# preprocess_videos(video_dir, dataset_name, square_crop=True, fps=30, quality_preset="ultra_low", target_resolution=256)
+
+# 4. 不裁剪，但缩放到较小尺寸
+# preprocess_videos(video_dir, dataset_name, square_crop=False, fps=30, quality_preset="low", target_resolution=480)
+
+def process_npz_files(input_folder_path, output_folder_path):
+    """
+    Process all NPZ files in the specified folder and generate the required output format.
+    
+    Args:
+        input_folder_path (str): Path to the folder containing NPZ files
+        output_folder_path (str): Path where output files will be saved
+    """
+    # Get all NPZ files in the folder
+    npz_files = sorted([f for f in os.listdir(input_folder_path) if f.endswith('.npz')])
+    total_frames = len(npz_files)
+    
+    output = []
+    
+    for idx, npz_file in enumerate(npz_files):
+        file_path = os.path.join(input_folder_path, npz_file)
+        data = np.load(file_path, allow_pickle=True)
+        
+        # Process bodies data
+        bodies = data['bodies']
+        body_scores = data['body_scores'][0]
+        
+        # Process hands data
+        hands = data['hands']
+        hands_scores = data['hands_scores']
+        
+        # Process faces data
+        faces = data['faces'][0]
+        faces_scores = data['faces_scores'][0]
+        
+        # Convert coordinates to strings with space separation
+        frame_data = []
+        
+        # Add body coordinates and scores
+        for i in range(bodies.shape[0]):
+            frame_data.extend([f"{bodies[i][0]:.8f}", f"{bodies[i][1]:.8f}"])
+        for score in body_scores:
+            frame_data.append(f"{score:.8f}")
+            
+        # Add hand coordinates and scores
+        for hand in hands:
+            for point in hand:
+                frame_data.extend([f"{point[0]:.8f}", f"{point[1]:.8f}"])
+        for hand_score in hands_scores:
+            frame_data.extend([f"{score:.8f}" for score in hand_score])
+            
+        # Add face coordinates and scores
+        for point in faces:
+            frame_data.extend([f"{point[0]:.8f}", f"{point[1]:.8f}"])
+        for score in faces_scores:
+            frame_data.append(f"{score:.8f}")
+            
+        # Add frame count
+        frame_count = idx / (total_frames - 1) if total_frames > 1 else 0
+        frame_data.append(f"{frame_count:.8f}")
+        
+        # 验证这一帧的数据点数是否为385
+        if len(frame_data) != 385:
+            print(f"Warning: Frame {idx} in {input_folder_path} has {len(frame_data)} values instead of 385")
+            continue  # 跳过这一帧
+
+        # Join all data with spaces
+        output.append(" ".join(frame_data))
+    
+    return " ".join(output) + "\n"

utils/stats_npz.py

@@ -0,0 +1,95 @@
+import fcntl
+from pathlib import Path
+from typing import Dict, Iterable
+
+import numpy as np
+
+
+STATUS_FIELDS = [
+    "sign_language",
+    "title",
+    "duration_sec",
+    "start_sec",
+    "end_sec",
+    "subtitle_languages",
+    "subtitle_dir_path",
+    "subtitle_en_source",
+    "raw_video_path",
+    "raw_metadata_path",
+    "metadata_status",
+    "subtitle_status",
+    "download_status",
+    "process_status",
+    "upload_status",
+    "local_cleanup_status",
+    "archive_name",
+    "last_error",
+    "updated_at",
+]
+
+
+def load_stats(stats_path: Path) -> Dict[str, Dict[str, str]]:
+    if not stats_path.exists():
+        return {}
+
+    data = np.load(stats_path, allow_pickle=True)
+    video_ids = [str(item) for item in data.get("video_ids", np.asarray([], dtype=object)).tolist()]
+    stats: Dict[str, Dict[str, str]] = {}
+    for index, video_id in enumerate(video_ids):
+        record = {}
+        for field in STATUS_FIELDS:
+            values = data.get(field)
+            record[field] = str(values[index]) if values is not None and index < len(values) else ""
+        stats[video_id] = record
+    return stats
+
+
+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"
+    np.savez(tmp_path, **payload)
+    tmp_path.replace(stats_path)
+
+
+def ensure_record(stats: Dict[str, Dict[str, str]], video_id: str) -> Dict[str, str]:
+    if video_id not in stats:
+        stats[video_id] = {field: "" for field in STATUS_FIELDS}
+    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:
+        fcntl.flock(handle.fileno(), fcntl.LOCK_EX)
+        stats = load_stats(stats_path)
+        record = ensure_record(stats, video_id)
+        for key, value in updates.items():
+            if key in STATUS_FIELDS:
+                record[key] = "" if value is None else str(value)
+        save_stats(stats_path, stats)
+        fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+        return dict(record)
+
+
+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:
+        fcntl.flock(handle.fileno(), fcntl.LOCK_EX)
+        stats = load_stats(stats_path)
+        for video_id in video_ids:
+            record = ensure_record(stats, video_id)
+            for key, value in updates.items():
+                if key in STATUS_FIELDS:
+                    record[key] = "" if value is None else str(value)
+        save_stats(stats_path, stats)
+        fcntl.flock(handle.fileno(), fcntl.LOCK_UN)

utils/util.py

@@ -0,0 +1,128 @@
+import importlib
+import os
+import os.path as osp
+import shutil
+import sys
+from pathlib import Path
+
+import av
+import numpy as np
+import torch
+import torchvision
+from einops import rearrange
+from PIL import Image
+
+
+def seed_everything(seed):
+    import random
+
+    import numpy as np
+
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    np.random.seed(seed % (2**32))
+    random.seed(seed)
+
+
+def import_filename(filename):
+    spec = importlib.util.spec_from_file_location("mymodule", filename)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def delete_additional_ckpt(base_path, num_keep):
+    dirs = []
+    for d in os.listdir(base_path):
+        if d.startswith("checkpoint-"):
+            dirs.append(d)
+    num_tot = len(dirs)
+    if num_tot <= num_keep:
+        return
+    # ensure ckpt is sorted and delete the ealier!
+    del_dirs = sorted(dirs, key=lambda x: int(x.split("-")[-1]))[: num_tot - num_keep]
+    for d in del_dirs:
+        path_to_dir = osp.join(base_path, d)
+        if osp.exists(path_to_dir):
+            shutil.rmtree(path_to_dir)
+
+
+def save_videos_from_pil(pil_images, path, fps=8):
+    import av
+
+    save_fmt = Path(path).suffix
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    width, height = pil_images[0].size
+
+    if save_fmt == ".mp4":
+        codec = "libx264"
+        container = av.open(path, "w")
+        stream = container.add_stream(codec, rate=fps)
+
+        stream.width = width
+        stream.height = height
+
+        for pil_image in pil_images:
+            # pil_image = Image.fromarray(image_arr).convert("RGB")
+            av_frame = av.VideoFrame.from_image(pil_image)
+            container.mux(stream.encode(av_frame))
+        container.mux(stream.encode())
+        container.close()
+
+    elif save_fmt == ".gif":
+        pil_images[0].save(
+            fp=path,
+            format="GIF",
+            append_images=pil_images[1:],
+            save_all=True,
+            duration=(1 / fps * 1000),
+            loop=0,
+        )
+    else:
+        raise ValueError("Unsupported file type. Use .mp4 or .gif.")
+
+
+def save_videos_grid(videos: torch.Tensor, path: str, rescale=False, n_rows=6, fps=8):
+    videos = rearrange(videos, "b c t h w -> t b c h w")
+    height, width = videos.shape[-2:]
+    outputs = []
+
+    for x in videos:
+        x = torchvision.utils.make_grid(x, nrow=n_rows)  # (c h w)
+        x = x.transpose(0, 1).transpose(1, 2).squeeze(-1)  # (h w c)
+        if rescale:
+            x = (x + 1.0) / 2.0  # -1,1 -> 0,1
+        x = (x * 255).numpy().astype(np.uint8)
+        x = Image.fromarray(x)
+
+        outputs.append(x)
+
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+
+    save_videos_from_pil(outputs, path, fps)
+
+
+def read_frames(video_path):
+    container = av.open(video_path)
+
+    video_stream = next(s for s in container.streams if s.type == "video")
+    frames = []
+    for packet in container.demux(video_stream):
+        for frame in packet.decode():
+            image = Image.frombytes(
+                "RGB",
+                (frame.width, frame.height),
+                frame.to_rgb().to_ndarray(),
+            )
+            frames.append(image)
+
+    return frames
+
+
+def get_fps(video_path):
+    container = av.open(video_path)
+    video_stream = next(s for s in container.streams if s.type == "video")
+    fps = video_stream.average_rate
+    container.close()
+    return fps