Upload folder using huggingface_hub

codes/Evaluation/evaluate.py

@@ -0,0 +1,233 @@
+import json
+import math
+import argparse
+from pathlib import Path
+from typing import Any, Dict, List, Tuple
+
+from scipy.optimize import linear_sum_assignment
+
+CLASSES = ["Contacting Food", "Food Approaching Mouth", "Food in Mouth"]
+
+# Map prediction keys (snake_case) to canonical class names
+PRED_LABEL_MAP = {
+    "contacting_food": "Contacting Food",
+    "food_approaching_mouth": "Food Approaching Mouth",
+    "food_in_mouth": "Food in Mouth",
+}
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Evaluate temporal action localization on EatBench-2.7K."
+    )
+    parser.add_argument("--annotation_json", type=str, required=True,
+                        help="Path to eatbench_annotation_full.json (ground truth).")
+    parser.add_argument("--pred_json", type=str, required=True,
+                        help="Path to model prediction JSON.")
+    parser.add_argument("--output_json", type=str, default=None,
+                        help="Optional path to save evaluation results.")
+    parser.add_argument("--thresholds", type=float, nargs="+", default=[0.1, 0.3, 0.5],
+                        help="tIoU thresholds to evaluate at (default: 0.1 0.3 0.5).")
+    return parser.parse_args()
+
+
+# ================== UTILS ==================
+
+def tiou(a: Tuple[float, float], b: Tuple[float, float]) -> float:
+    """Temporal Intersection over Union."""
+    inter = max(0.0, min(a[1], b[1]) - max(a[0], b[0]))
+    union = (a[1] - a[0]) + (b[1] - b[0]) - inter
+    return inter / union if union > 1e-9 else 0.0
+
+
+def safe_float(x, default=0.0) -> float:
+    try:
+        v = float(x)
+        return default if (math.isnan(v) or math.isinf(v)) else v
+    except Exception:
+        return default
+
+
+# ================== LOADERS ==================
+
+def load_gt(gt_path: str) -> Dict[str, Dict[str, List[Tuple[float, float]]]]:
+    """Load ground-truth annotations from eatbench_annotation_full.json."""
+    raw = json.loads(Path(gt_path).read_text())
+    out = {}
+    for entry in raw:
+        vid = entry.get("Video Name")
+        if not vid:
+            continue
+        per = {c: [] for c in CLASSES}
+        for act in entry.get("Actions", []):
+            cls = act.get("Label")
+            if cls not in CLASSES:
+                continue
+            s, e = safe_float(act.get("Start")), safe_float(act.get("End"))
+            if s > e:
+                s, e = e, s
+            if e - s > 1e-9:
+                per[cls].append((s, e))
+        out[vid] = per
+    return out
+
+
+def load_pred(pred_path: str) -> Dict[str, Dict[str, List[Tuple[float, float]]]]:
+    """
+    Load model predictions. Supports two formats:
+      - {vid: {snake_key: [[s, e], ...], ...}}
+      - {vid: {"prediction": {snake_key: [{"segment": [s, e]}, ...]}}}
+    Scores are ignored (score-free evaluation).
+    """
+    raw = json.loads(Path(pred_path).read_text())
+    out = {}
+    for vid, item in raw.items():
+        block = item.get("prediction", item)
+        per = {c: [] for c in CLASSES}
+        if not isinstance(block, dict):
+            out[vid] = per
+            continue
+        for pred_lbl, segs in block.items():
+            cls = PRED_LABEL_MAP.get(pred_lbl)
+            if cls is None or not isinstance(segs, list):
+                continue
+            for it in segs:
+                seg = it.get("segment") if isinstance(it, dict) else it
+                if not (isinstance(seg, (list, tuple)) and len(seg) == 2):
+                    continue
+                s, e = safe_float(seg[0]), safe_float(seg[1])
+                if s > e:
+                    s, e = e, s
+                if e - s > 1e-9:
+                    per[cls].append((s, e))
+        out[vid] = per
+    return out
+
+
+# ================== MATCHING ==================
+
+def hungarian_match(
+    pred: List[Tuple[float, float]],
+    gt: List[Tuple[float, float]],
+    thr: float,
+) -> List[Tuple[int, int, float]]:
+    """
+    One-to-one Hungarian matching maximizing total tIoU (Eq. 1 in paper).
+    Returns matched pairs (pred_i, gt_j, iou) with iou >= thr.
+    """
+    if not pred or not gt:
+        return []
+
+    BIG = 1e6
+    iou_mat = [[tiou(p, g) for g in gt] for p in pred]
+    cost = [[BIG if iou_mat[i][j] < thr else 1.0 - iou_mat[i][j]
+             for j in range(len(gt))]
+            for i in range(len(pred))]
+
+    row_ind, col_ind = linear_sum_assignment(cost)
+    return [
+        (i, j, iou_mat[i][j])
+        for i, j in zip(row_ind.tolist(), col_ind.tolist())
+        if iou_mat[i][j] >= thr and cost[i][j] < BIG
+    ]
+
+
+# ================== EVALUATION ==================
+
+def evaluate(
+    gt_path: str,
+    pred_path: str,
+    thresholds: Tuple[float, ...] = (0.1, 0.3, 0.5),
+) -> Dict[str, Any]:
+    """
+    Evaluate predictions against ground truth using Hungarian matching.
+    Reports per-class Precision, Recall, F1, matched mIoU, and Macro-F1
+    at each tIoU threshold (Section 3.6 in paper).
+    """
+    gt = load_gt(gt_path)
+    pred = load_pred(pred_path)
+    videos = sorted(set(gt.keys()) & set(pred.keys()))
+
+    results: Dict[str, Any] = {
+        "summary": {
+            "num_videos": len(videos),
+            "thresholds": list(thresholds),
+        },
+        "per_threshold": {},
+    }
+
+    for thr in thresholds:
+        per_class = {}
+        for cls in CLASSES:
+            TP = FP = FN = 0
+            iou_sum = 0.0
+            iou_cnt = 0
+            gt_total = pred_total = 0
+
+            for v in videos:
+                G = gt[v].get(cls, [])
+                P = pred[v].get(cls, [])
+                gt_total += len(G)
+                pred_total += len(P)
+
+                matches = hungarian_match(P, G, thr)
+                tp = len(matches)
+                TP += tp
+                FP += len(P) - tp
+                FN += len(G) - tp
+                for _, _, iou in matches:
+                    iou_sum += iou
+                    iou_cnt += 1
+
+            prec = TP / (TP + FP) if TP + FP > 0 else 0.0
+            rec  = TP / (TP + FN) if TP + FN > 0 else 0.0
+            f1   = 2 * prec * rec / (prec + rec) if prec + rec > 0 else 0.0
+            miou = iou_sum / iou_cnt if iou_cnt > 0 else 0.0
+
+            per_class[cls] = {
+                "Precision": round(prec, 4),
+                "Recall":    round(rec,  4),
+                "F1":        round(f1,   4),
+                "mIoU":      round(miou, 4),
+                "TP": TP, "FP": FP, "FN": FN,
+                "GT": gt_total, "Pred": pred_total,
+            }
+
+        macro_f1 = sum(per_class[c]["F1"] for c in CLASSES) / len(CLASSES)
+        results["per_threshold"][f"tIoU@{thr}"] = {
+            "per_class": per_class,
+            "Macro_F1": round(macro_f1, 4),
+        }
+
+    return results
+
+
+def print_results(results: Dict[str, Any]):
+    print(f"\nVideos evaluated: {results['summary']['num_videos']}")
+    for thr_key, data in results["per_threshold"].items():
+        print(f"\n{'='*50}")
+        print(f"  {thr_key}   Macro-F1: {data['Macro_F1']:.4f}")
+        print(f"{'='*50}")
+        print(f"  {'Class':<28} {'P':>6} {'R':>6} {'F1':>6} {'mIoU':>6}")
+        print(f"  {'-'*54}")
+        for cls, m in data["per_class"].items():
+            print(f"  {cls:<28} {m['Precision']:>6.4f} {m['Recall']:>6.4f} {m['F1']:>6.4f} {m['mIoU']:>6.4f}")
+
+
+# ================== MAIN ==================
+
+if __name__ == "__main__":
+    args = parse_args()
+
+    results = evaluate(
+        gt_path=args.annotation_json,
+        pred_path=args.pred_json,
+        thresholds=tuple(args.thresholds),
+    )
+
+    print_results(results)
+
+    if args.output_json:
+        Path(args.output_json).parent.mkdir(parents=True, exist_ok=True)
+        Path(args.output_json).write_text(json.dumps(results, indent=2))
+        print(f"\nResults saved to: {args.output_json}")

codes/README.md

@@ -0,0 +1,178 @@
+# EatBench-2.7K: Evaluation Code
+
+This directory contains the evaluation code for EatBench-2.7K, including the SAFR frame selection strategy, the OneThinker inference pipeline, and the evaluation script.
+
+## Overview
+
+The full pipeline runs in three steps:
+
+1. **`run_SAFR.py`** — Extract frames from each video using uniform sampling or SAFR (Semantic-Anchored Frame Relocation). Saves frames to disk and produces a manifest JSON with frame paths and timestamps.
+2. **`run_OneThinker.py`** — Run OneThinker inference using the cached frames from the manifest, and save predicted action segments to a results JSON.
+3. **`Evaluation/evaluate.py`** — Evaluate predictions against ground truth using Hungarian matching and report per-class Precision, Recall, F1, mIoU, and Macro-F1.
+
+## Requirements
+
+```bash
+pip install torch transformers opencv-python numpy tqdm vllm qwen-vl-utils
+```
+
+CLIP model (`openai/clip-vit-base-patch32`) and OneThinker checkpoint (`OneThink/OneThinker-8B`) will be downloaded automatically from HuggingFace on first run.
+
+## Step 1: Frame Extraction
+
+### Uniform Sampling (baseline)
+
+```bash
+python run_SAFR.py \
+    --mode uniform \
+    --annotation_json /path/to/eatbench_annotation_full.json \
+    --video_dir /path/to/videos/ \
+    --output_dir /path/to/frames/
+```
+
+### SAFR (Semantic-Anchored Frame Relocation)
+
+```bash
+python run_SAFR.py \
+    --mode safr \
+    --smooth_w 3 \
+    --annotation_json /path/to/eatbench_annotation_full.json \
+    --video_dir /path/to/videos/ \
+    --output_dir /path/to/frames/
+```
+
+**Arguments:**
+
+| Argument | Default | Description |
+|---|---|---|
+| `--mode` | `safr` | Frame selection mode: `uniform` or `safr` |
+| `--smooth_w` | `3` | Temporal smoothing window size for CLIP similarity (SAFR only) |
+| `--annotation_json` | required | Path to `eatbench_annotation_full.json` |
+| `--video_dir` | required | Directory containing video `.mp4` files |
+| `--output_dir` | required | Root directory for cached frames and manifest |
+
+**Output:** A subdirectory is created under `--output_dir` containing:
+- Extracted frame images (`*.jpg`) organized per video
+- `manifest_with_time.json` — maps each video to its selected frame paths and timestamps
+
+## Step 2: OneThinker Inference
+
+```bash
+python run_OneThinker.py \
+    --annotation_json /path/to/eatbench_annotation_full.json \
+    --video_dir /path/to/videos/ \
+    --manifest_json /path/to/frames/safr_safr_fps2.0_max16_smooth3/manifest_with_time.json \
+    --output_json /path/to/results/onethinker_safr.json
+```
+
+**Arguments:**
+
+| Argument | Default | Description |
+|---|---|---|
+| `--checkpoint` | `OneThink/OneThinker-8B` | Model checkpoint path or HuggingFace model ID |
+| `--annotation_json` | required | Path to `eatbench_annotation_full.json` |
+| `--video_dir` | required | Directory containing video `.mp4` files |
+| `--manifest_json` | required | Path to `manifest_with_time.json` from Step 1 |
+| `--output_json` | required | Path to save prediction results |
+
+**Output:** A JSON file mapping each video name to predicted action segments:
+
+```json
+{
+  "video_name.mp4": {
+    "contacting_food": [[0.0, 1.2], [8.3, 9.1]],
+    "food_approaching_mouth": [[1.2, 2.0], [9.1, 9.8]],
+    "food_in_mouth": [[2.0, 5.5], [9.8, 12.3]]
+  },
+  ...
+}
+```
+
+## Full Pipeline Example
+
+```bash
+# Step 1: extract frames with SAFR
+python run_SAFR.py \
+    --mode safr \
+    --annotation_json eatbench_annotation_full.json \
+    --video_dir videos/ \
+    --output_dir frames/
+
+# Step 2: run OneThinker inference
+python run_OneThinker.py \
+    --annotation_json eatbench_annotation_full.json \
+    --video_dir videos/ \
+    --manifest_json frames/safr_safr_fps2.0_max16_smooth3/manifest_with_time.json \
+    --output_json results/onethinker_safr.json
+
+# Step 3: evaluate
+python Evaluation/evaluate.py \
+    --annotation_json eatbench_annotation_full.json \
+    --pred_json results/onethinker_safr.json \
+    --output_json results/onethinker_safr_metrics.json
+```
+
+## Step 3: Evaluation
+
+```bash
+python Evaluation/evaluate.py \
+    --annotation_json /path/to/eatbench_annotation_full.json \
+    --pred_json /path/to/results/onethinker_safr.json \
+    --output_json /path/to/results/onethinker_safr_metrics.json
+```
+
+**Arguments:**
+
+| Argument | Default | Description |
+|---|---|---|
+| `--annotation_json` | required | Path to `eatbench_annotation_full.json` (ground truth) |
+| `--pred_json` | required | Path to model prediction JSON from Step 2 |
+| `--output_json` | `None` | Optional path to save evaluation results as JSON |
+| `--thresholds` | `0.1 0.3 0.5` | tIoU thresholds to evaluate at |
+
+**Console output:**
+```
+Videos evaluated: 525
+
+==================================================
+  tIoU@0.1   Macro-F1: 0.3330
+==================================================
+  Class                           P        R       F1     mIoU
+  ------------------------------------------------------
+  Contacting Food            0.2880   0.3460   0.3150   0.1892
+  Food Approaching Mouth     0.3620   0.1830   0.2430   0.1421
+  Foodin Mouth               0.7330   0.3150   0.4410   0.2105
+```
+
+**Output JSON format:**
+```json
+{
+  "summary": {"num_videos": 525, "thresholds": [0.1, 0.3, 0.5]},
+  "per_threshold": {
+    "tIoU@0.1": {
+      "Macro_F1": 0.333,
+      "per_class": {
+        "Contacting Food":        {"Precision": 0.288, "Recall": 0.346, "F1": 0.315, "mIoU": 0.189, ...},
+        "Food Approaching Mouth": {"Precision": 0.362, "Recall": 0.183, "F1": 0.243, "mIoU": 0.142, ...},
+        "Food in Mouth":          {"Precision": 0.733, "Recall": 0.315, "F1": 0.441, "mIoU": 0.211, ...}
+      }
+    }
+  }
+}
+```
+
+The evaluator accepts predictions in two formats:
+- `{video_name: {snake_key: [[s, e], ...], ...}}` — output of `run_OneThinker.py`
+- `{video_name: {"prediction": {snake_key: [{"segment": [s, e], "score": ...}, ...]}}}` — score-based format (scores ignored)
+
+## SAFR Algorithm
+
+SAFR partitions the video timeline into K equal windows around uniform anchors and relocates each anchor to the frame with the highest semantic similarity to the eating-action prompts (Algorithm 1 in the paper).
+
+Given T video frames and frame budget K:
+1. Compute per-frame, per-action CLIP similarity scores s_a(t)
+2. Smooth each s_a(t) with a temporal window, then aggregate: S(t) = max_a s̃_a(t)
+3. Place uniform anchors at u_i = floor((T/K)(i − 0.5))
+4. For each window W_i around u_i, select y_i = argmax_{t ∈ W_i} S(t)
+
+SAFR adds O(T) overhead over uniform sampling and requires no training or model modification.

codes/requirements.txt

@@ -0,0 +1,20 @@
+# Core
+torch>=2.1.0
+torchvision>=0.16.0
+numpy>=1.24.0
+Pillow>=10.0.0
+
+# Video processing
+opencv-python>=4.8.0
+
+# CLIP (for SAFR frame selection)
+transformers>=4.45.0
+
+# OneThinker / Qwen2.5-VL inference
+vllm>=0.6.3
+qwen-vl-utils>=0.0.8
+accelerate>=0.26.0
+
+# Utilities
+tqdm>=4.65.0
+scipy>=1.11.0

codes/run_OneThinker.py

@@ -0,0 +1,204 @@
+import os
+import json
+import ast
+import re
+import argparse
+from pathlib import Path
+
+import cv2
+from tqdm import tqdm
+from transformers import AutoProcessor
+from vllm import LLM, SamplingParams
+from qwen_vl_utils import process_vision_info
+
+os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
+
+
+# ================== TASK DEFINITION ==================
+FINE_DEFS = (
+    "Identify fine-grained eating micro-actions in the video. "
+    "Categories:\n"
+    "1) contacting_food — direct contact with food using hand/utensil (pick/grab/cut/scoop/pour/stir/serve).\n"
+    "2) food_approaching_mouth — transporting/aligning food toward the lips/teeth/tongue.\n"
+    "3) food_in_mouth — from first contact with lips until food crosses the lip line."
+)
+
+FORMAT_INSTRUCTION = (
+    "Please provide only the action localization results as a JSON dictionary within the <answer>...</answer> tags. "
+    "Example:\n<answer>{{\"contacting_food\": [[0.0, 1.2]], \"food_approaching_mouth\": [[2.3, 3.1]], \"food_in_mouth\": [[3.2, 5.0]]}}</answer>"
+)
+
+QUESTION_TEMPLATE = (
+    "{Question}\n"
+    "Provide your thinking process between the <think> and </think> tags, and then give your final answer between the <answer> and </answer> tags.\n"
+    + FORMAT_INSTRUCTION
+)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Run OneThinker on EatBench-2.7K.")
+    parser.add_argument("--checkpoint", type=str, default="OneThink/OneThinker-8B",
+                        help="Model checkpoint path or HuggingFace model ID.")
+    parser.add_argument("--annotation_json", type=str, required=True,
+                        help="Path to EatBench annotation JSON.")
+    parser.add_argument("--video_dir", type=str, required=True,
+                        help="Directory containing video files.")
+    parser.add_argument("--manifest_json", type=str, required=True,
+                        help="Path to frame manifest produced by run_SAFR.py.")
+    parser.add_argument("--output_json", type=str, required=True,
+                        help="Path to save prediction results.")
+    return parser.parse_args()
+
+
+# ================== UTILS ==================
+
+def get_video_meta(path):
+    cap = cv2.VideoCapture(path)
+    if not cap.isOpened():
+        return 0.0, 0, 30.0
+    frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    fps = float(cap.get(cv2.CAP_PROP_FPS)) or 30.0
+    duration = frames / fps if fps > 0 else 0.0
+    cap.release()
+    return duration, frames, fps
+
+
+def try_parse_answer(text):
+    match = re.search(r'<answer>(.*?)</answer>', text, re.DOTALL)
+    if match:
+        content = match.group(1).strip()
+        try:
+            return ast.literal_eval(content)
+        except Exception:
+            clean = re.sub(r'```json|```', '', content).strip()
+            try:
+                return json.loads(clean)
+            except Exception:
+                pass
+    return {}
+
+
+def normalize(obj):
+    keys = ["contacting_food", "food_approaching_mouth", "food_in_mouth"]
+    out = {k: [] for k in keys}
+    if not isinstance(obj, dict):
+        return out
+    for k in keys:
+        for it in obj.get(k, []):
+            if isinstance(it, (list, tuple)) and len(it) == 2:
+                out[k].append([round(float(it[0]), 1), round(float(it[1]), 1)])
+    return out
+
+
+def build_timeline_header(frames_list):
+    """Build a compact frame timestamp header to prepend to the prompt."""
+    frames_list = sorted(frames_list, key=lambda x: int(x.get("idx", 0)))
+    lines = ["Selected frames (time in seconds):"]
+    for fr in frames_list:
+        lines.append(f"#{int(fr.get('k', 0))} t={float(fr.get('t', 0.0)):.2f}s")
+    return "\n".join(lines)
+
+
+def prepare_inputs_for_vllm(messages, processor):
+    text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+    image_inputs, video_inputs, video_kwargs = process_vision_info(
+        messages,
+        image_patch_size=processor.image_processor.patch_size,
+        return_video_kwargs=True,
+        return_video_metadata=True,
+    )
+    mm_data = {}
+    if image_inputs is not None:
+        mm_data["image"] = image_inputs
+    if video_inputs is not None:
+        mm_data["video"] = video_inputs
+        if video_kwargs is not None and "video_grid_thw" in video_kwargs:
+            mm_data["video_metadata"] = {"video_grid_thw": video_kwargs["video_grid_thw"]}
+    return {
+        "prompt": text,
+        "multi_modal_data": mm_data,
+        "mm_processor_kwargs": video_kwargs,
+    }
+
+
+# ================== MAIN ==================
+
+def main():
+    args = parse_args()
+
+    with open(args.manifest_json) as f:
+        manifest = json.load(f)
+
+    processor = AutoProcessor.from_pretrained(args.checkpoint)
+    llm = LLM(
+        model=args.checkpoint,
+        mm_encoder_tp_mode="data",
+        tensor_parallel_size=1,
+        max_model_len=24576,
+        gpu_memory_utilization=0.5,
+    )
+    sampling_params = SamplingParams(temperature=0.0, max_tokens=4096)
+
+    with open(args.annotation_json) as f:
+        test_list = json.load(f)
+
+    all_inputs = []
+    video_names = []
+
+    print("Pre-processing video inputs...")
+    for entry in tqdm(test_list):
+        videoname = entry.get("Video Name")
+        if not videoname:
+            continue
+        video_path = os.path.join(args.video_dir, videoname)
+        if not os.path.exists(video_path):
+            continue
+
+        info = manifest.get(videoname)
+        if info and isinstance(info.get("frames"), list) and info["frames"]:
+            frames_list = sorted(info["frames"], key=lambda x: int(x.get("idx", 0)))
+            frame_paths = [fr["path"] for fr in frames_list if os.path.exists(fr.get("path", ""))]
+            video_field = frame_paths if frame_paths else video_path
+        else:
+            frames_list = None
+            video_field = video_path
+
+        duration, _, _ = get_video_meta(video_path)
+
+        if frames_list and isinstance(video_field, list):
+            timeline = build_timeline_header(frames_list)
+            question_text = f"{timeline}\nThe video lasts {duration:.1f}s. {FINE_DEFS}"
+        else:
+            question_text = f"The video lasts {duration:.1f}s. {FINE_DEFS}"
+
+        full_text = QUESTION_TEMPLATE.format(Question=question_text)
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "video", "video": video_field, "max_pixels": 256 * 32 * 32},
+                    {"type": "text", "text": full_text},
+                ],
+            }
+        ]
+
+        all_inputs.append(prepare_inputs_for_vllm(messages, processor))
+        video_names.append(videoname)
+
+    print(f"Running inference on {len(all_inputs)} videos...")
+    outputs = llm.generate(all_inputs, sampling_params=sampling_params)
+
+    results = {}
+    for videoname, output in zip(video_names, outputs):
+        parsed = try_parse_answer(output.outputs[0].text)
+        results[videoname] = normalize(parsed)
+
+    os.makedirs(str(Path(args.output_json).parent), exist_ok=True)
+    with open(args.output_json, "w") as f:
+        json.dump(results, f, indent=2)
+
+    print(f"Results saved to {args.output_json}")
+
+
+if __name__ == "__main__":
+    main()

codes/run_SAFR.py

@@ -0,0 +1,307 @@
+import os
+import json
+import argparse
+from pathlib import Path
+
+import cv2
+import numpy as np
+from tqdm import tqdm
+
+
+# ================== CONFIG ==================
+CLIP_MODEL_ID = "openai/clip-vit-base-patch32"
+BATCH_SIZE = 32
+ACTION_TEXTS = [
+    "contacting food with hand or utensil (pick/grab/cut/scoop/pour/stir/serve)",
+    "food approaching mouth (transporting food toward lips/teeth/tongue)",
+    "food in mouth (food crosses the lip line, chewing or inside mouth)",
+]
+FPS_SAMPLE = 2.0
+MAX_FRAMES = 16
+# ============================================
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Extract frames with uniform sampling or SAFR (Semantic-Anchored Frame Relocation)."
+    )
+    parser.add_argument("--mode", type=str, default="safr", choices=["uniform", "safr"],
+                        help="Frame selection mode: 'uniform' or 'safr'.")
+    parser.add_argument("--smooth_w", type=int, default=3,
+                        help="Temporal smoothing window size for CLIP similarity scores (paper default: 3).")
+    parser.add_argument("--annotation_json", type=str, required=True,
+                        help="Path to EatBench annotation JSON.")
+    parser.add_argument("--video_dir", type=str, required=True,
+                        help="Directory containing video files.")
+    parser.add_argument("--output_dir", type=str, required=True,
+                        help="Root output directory for cached frames and manifest.")
+    return parser.parse_args()
+
+
+# ================== VIDEO UTILS ==================
+
+def get_video_meta(path: str):
+    cap = cv2.VideoCapture(path)
+    if not cap.isOpened():
+        return 0.0, 0, 30.0
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    fps = float(cap.get(cv2.CAP_PROP_FPS)) or 30.0
+    duration = total_frames / fps if fps > 0 else 0.0
+    cap.release()
+    return duration, total_frames, fps
+
+
+def desired_num_frames(duration_s: float) -> int:
+    """Compute frame budget: duration * FPS_SAMPLE, capped at MAX_FRAMES."""
+    n = int(round(duration_s * FPS_SAMPLE))
+    return max(1, min(n, MAX_FRAMES))
+
+
+def uniform_sample_frames(total_frames: int, num_frames: int):
+    """Tick/center uniform sampling. Returns frame indices in [0, total_frames-1]."""
+    if num_frames <= 0 or total_frames <= 0:
+        return []
+    if num_frames >= total_frames:
+        return list(range(total_frames))
+    tick = total_frames / num_frames
+    idx = [int(tick / 2.0 + tick * x) for x in range(num_frames)]
+    idx = [min(max(i, 0), total_frames - 1) for i in idx]
+    out, last = [], None
+    for i in idx:
+        if last is None or i != last:
+            out.append(i)
+        last = i
+    return out
+
+
+def extract_frames_by_indices(video_path: str, out_dir: Path, indices, skip_if_exists=True):
+    """Extract frames at given indices and save as JPEG. Returns list of (k, idx, path)."""
+    out_dir.mkdir(parents=True, exist_ok=True)
+    expected = [out_dir / f"f_{k:03d}_idx{idx:06d}.jpg" for k, idx in enumerate(indices)]
+    if skip_if_exists and expected and all(p.exists() for p in expected):
+        return [(k, indices[k], str(expected[k])) for k in range(len(indices))]
+
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        return []
+    total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    saved = []
+    for k, idx in enumerate(indices):
+        idx = int(min(max(idx, 0), total - 1))
+        save_path = out_dir / f"f_{k:03d}_idx{idx:06d}.jpg"
+        if skip_if_exists and save_path.exists():
+            saved.append((k, idx, str(save_path)))
+            continue
+        cap.set(cv2.CAP_PROP_POS_FRAMES, idx)
+        ok, frame = cap.read()
+        if not ok:
+            continue
+        cv2.imwrite(str(save_path), frame)
+        saved.append((k, idx, str(save_path)))
+    cap.release()
+    return saved
+
+
+# ================== SAFR ==================
+
+def moving_average(x: np.ndarray, w: int) -> np.ndarray:
+    """Symmetric moving average with reflect padding."""
+    if w <= 1:
+        return x.astype(np.float64)
+    if w % 2 == 0:
+        w += 1
+    pad = w // 2
+    xp = np.pad(x.astype(np.float64), (pad, pad), mode="reflect")
+    kernel = np.ones(w, dtype=np.float64) / float(w)
+    return np.convolve(xp, kernel, mode="valid")
+
+
+def build_windows(total_frames: int, anchors: list):
+    """
+    Build K disjoint windows W_i = [L_i, R_i] around uniform anchors,
+    bounded by midpoints between adjacent anchors (Algorithm 1, SAFR).
+    """
+    n = len(anchors)
+    if n == 0:
+        return []
+    a = [int(x) for x in anchors]
+    bounds = [0]
+    for i in range(n - 1):
+        bounds.append((a[i] + a[i + 1]) // 2)
+    bounds.append(total_frames - 1)
+
+    segs = []
+    for i in range(n):
+        L = bounds[i]
+        R = bounds[i + 1]
+        if i > 0:
+            L = max(L, segs[-1][1] + 1)
+        segs.append((L, max(L, R)))
+    segs[-1] = (segs[-1][0], total_frames - 1)
+    return segs
+
+
+def select_indices_safr(s_mat: np.ndarray, anchors: list, smooth_w: int) -> list:
+    """
+    SAFR frame selection (Algorithm 1 in the paper).
+
+    Args:
+        s_mat:    (A, T) array of per-action CLIP similarity scores.
+        anchors:  K uniform anchor frame indices.
+        smooth_w: Temporal smoothing window size.
+
+    Returns:
+        List of K selected frame indices, one per window.
+    """
+    T = s_mat.shape[1]
+
+    # Smooth each action's similarity sequence independently, then aggregate (Eq. 4)
+    s_mat_sm = np.stack([moving_average(s_mat[a], smooth_w) for a in range(s_mat.shape[0])])
+    S = s_mat_sm.max(axis=0)  # S(t) = max_a s̃_a(t)
+
+    # Select argmax within each local window (Eq. 5)
+    windows = build_windows(T, anchors)
+    chosen = []
+    for (L, R) in windows:
+        sub = S[L:R + 1]
+        t = L if sub.size == 0 else int(L + np.argmax(sub))
+        chosen.append(t)
+
+    # Enforce strictly increasing indices
+    out, last = [], -1
+    for t in chosen:
+        if t <= last:
+            t = min(last + 1, T - 1)
+        out.append(t)
+        last = t
+    return out[:len(anchors)]
+
+
+# ================== CLIP SCORING ==================
+
+def clip_scores_all_frames(video_path: str, total_frames: int, model, processor, text_emb, device):
+    """
+    Compute per-action CLIP similarity for every frame in the video.
+    Returns s_mat of shape (A, total_frames).
+    """
+    from PIL import Image
+    import torch
+
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        return None
+
+    A = text_emb.shape[0]
+    s_mat = np.zeros((A, total_frames), dtype=np.float32)
+    imgs, idxs = [], []
+    t = 0
+
+    def flush(imgs, idxs):
+        with torch.no_grad():
+            inputs = processor(images=imgs, return_tensors="pt").to(device)
+            img_emb = model.get_image_features(**inputs)
+            img_emb = img_emb / img_emb.norm(dim=-1, keepdim=True)
+            sim = (text_emb @ img_emb.T).float().cpu().numpy()
+        for b, fr_idx in enumerate(idxs):
+            s_mat[:, fr_idx] = sim[:, b]
+
+    while True:
+        ok, frame = cap.read()
+        if not ok:
+            break
+        imgs.append(Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)))
+        idxs.append(t)
+        t += 1
+        if len(imgs) >= BATCH_SIZE:
+            flush(imgs, idxs)
+            imgs, idxs = [], []
+
+    if imgs:
+        flush(imgs, idxs)
+    cap.release()
+    return s_mat
+
+
+# ================== MAIN ==================
+
+def main():
+    args = parse_args()
+
+    output_dir = Path(args.output_dir) / f"safr_{args.mode}_fps{FPS_SAMPLE}_max{MAX_FRAMES}"
+    if args.mode == "safr":
+        output_dir = Path(str(output_dir) + f"_smooth{args.smooth_w}")
+    output_dir.mkdir(parents=True, exist_ok=True)
+    manifest_path = output_dir / "manifest_with_time.json"
+
+    with open(args.annotation_json, "r") as f:
+        test_list = json.load(f)
+
+    # Load CLIP only when needed
+    if args.mode == "safr":
+        import torch
+        from transformers import CLIPProcessor, CLIPModel
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        clip_model = CLIPModel.from_pretrained(CLIP_MODEL_ID).to(device).eval()
+        clip_proc = CLIPProcessor.from_pretrained(CLIP_MODEL_ID)
+        with torch.no_grad():
+            text_inputs = clip_proc(text=ACTION_TEXTS, return_tensors="pt", padding=True).to(device)
+            text_emb = clip_model.get_text_features(**text_inputs)
+            text_emb = text_emb / text_emb.norm(dim=-1, keepdim=True)
+    else:
+        clip_model = clip_proc = text_emb = device = None
+
+    manifest = {}
+    missing = 0
+
+    for entry in tqdm(test_list, desc=f"Frame extraction [{args.mode}]"):
+        videoname = entry.get("Video Name")
+        if not videoname:
+            continue
+        video_path = os.path.join(args.video_dir, videoname)
+        if not os.path.exists(video_path):
+            missing += 1
+            continue
+
+        duration, total_frames, fps = get_video_meta(video_path)
+        if total_frames <= 0 or fps <= 0:
+            continue
+
+        n = desired_num_frames(duration)
+        anchors = uniform_sample_frames(total_frames, n)
+
+        if args.mode == "uniform":
+            indices = anchors
+        else:
+            s_mat = clip_scores_all_frames(video_path, total_frames, clip_model, clip_proc, text_emb, device)
+            if s_mat is None:
+                continue
+            indices = select_indices_safr(s_mat, anchors, smooth_w=args.smooth_w)
+
+        saved = extract_frames_by_indices(video_path, output_dir / videoname, indices)
+        if not saved:
+            continue
+
+        frames = [{"k": k, "idx": idx, "t": round(idx / fps, 3), "path": p} for k, idx, p in saved]
+        manifest[videoname] = {
+            "video_path": video_path,
+            "duration": round(duration, 3),
+            "fps": round(fps, 6),
+            "total_frames": int(total_frames),
+            "nframes": len(frames),
+            "frames": frames,
+            "mode": args.mode,
+            "smooth_w": args.smooth_w if args.mode == "safr" else None,
+            "clip_model": CLIP_MODEL_ID if args.mode == "safr" else None,
+        }
+
+    with open(manifest_path, "w") as f:
+        json.dump(manifest, f, indent=2)
+
+    print(f"Processed: {len(manifest)} videos")
+    if missing:
+        print(f"Missing video files: {missing}")
+    print(f"Manifest saved to: {manifest_path}")
+
+
+if __name__ == "__main__":
+    main()