Upload 12 files

app.py

@@ -0,0 +1,180 @@
+import gradio as gr
+import pandas as pd
+from PIL import Image
+from model_registry import (
+    ALL_CATEGORIES, DEFAULT_THRESHOLD, REGISTRY, get_model, NUDENET_ONLY
+)
+from video_utils import (
+    has_ffmpeg, probe_duration, extract_frames_ffmpeg, runs_from_indices,
+    merge_seconds_union, redact_with_ffmpeg
+)
+
+APP_TITLE = "Content Moderation Demo (Image & Video)"
+APP_DESC = """
+Minimal prototype: image/video analysis, model & category selection, and threshold control.
+"""
+
+MODEL_NAMES = list(REGISTRY.keys())
+
+# ---------- Shared ----------
+def on_model_change(model_name):
+    if model_name in NUDENET_ONLY:
+        cats_state = gr.CheckboxGroup(choices=["sexual"], value=["sexual"], interactive=False, label="Categories")
+    else:
+        cats_state = gr.CheckboxGroup(choices=ALL_CATEGORIES, value=ALL_CATEGORIES, interactive=True, label="Categories")
+    th = DEFAULT_THRESHOLD
+    return cats_state, gr.Slider(minimum=0.0, maximum=1.0, value=th, step=0.01, label="Threshold")
+
+# ---------- Image ----------
+def analyze_image(model_name, image, selected_categories, threshold):
+    if image is None:
+        return "No image.", None, gr.update(visible=False)
+    pil = Image.fromarray(image) if not isinstance(image, Image.Image) else image
+    model = get_model(model_name)
+    allowed = set(getattr(model, "categories", ALL_CATEGORIES))
+    req = [c for c in selected_categories if c in allowed]
+    if not req:
+        return "No categories selected.", None, gr.update(visible=False)
+    scores = model.predict_image(pil, req)
+    verdict = "RISKY" if any(v >= threshold for v in scores.values()) else "SAFE"
+    df = pd.DataFrame([{"category": k, "score": f"{(float(v)*100):.1f}%"} for k, v in sorted(scores.items())])
+    if getattr(model, "supports_selected_tags", False):
+        extra = model.extra_selected_tags(pil, top_k=15)
+        txt = "\n".join(f"- {t}: {s:.3f}" for t, s in extra)
+        return verdict, df, gr.update(visible=True, value=txt)
+    else:
+        return verdict, df, gr.update(visible=False)
+
+# ---------- Video ----------
+def analyze_video(model_name, video_file, selected_categories, threshold, sampling_fps, redact):
+    import tempfile, os, shutil
+
+    if video_file is None:
+        return pd.DataFrame([{"segment":"Error: No video."}]), gr.update(value=None)
+
+    dur = probe_duration(video_file)
+    if dur is not None and dur > 60.0:
+        return pd.DataFrame([{"segment":"Error: Video too long (limit: 60s)."}]), gr.update(value=None)
+
+    model = get_model(model_name)
+    allowed = set(getattr(model, "categories", ALL_CATEGORIES))
+    req = [c for c in selected_categories if c in allowed]
+    if not req:
+        return pd.DataFrame([{"segment":"Error: No categories selected."}]), gr.update(value=None)
+
+    with tempfile.TemporaryDirectory() as td:
+        try:
+            frames = extract_frames_ffmpeg(video_file, sampling_fps, os.path.join(td, "frames"))
+        except Exception:
+            return pd.DataFrame([{"segment":"Error: FFmpeg not available or failed to extract frames."}]), gr.update(value=None)
+
+        all_hit_idx: list[int] = []
+        frame_stats: dict[int, dict] = {}
+
+        for fp, idx in frames:
+            with Image.open(fp) as im:
+                pil = im.convert("RGB")
+                scores = model.predict_image(pil, req)
+            over = {c: float(scores.get(c, 0.0)) for c in req if float(scores.get(c, 0.0)) >= threshold}
+            if over:
+                all_hit_idx.append(idx)
+                peak_cat, peak_p = max(over.items(), key=lambda kv: kv[1])
+                frame_stats[idx] = {"hits": over, "peak_cat": peak_cat, "peak_p": peak_p}
+
+        if not all_hit_idx:
+            return pd.DataFrame([{"segment":"(no hits)"}]), gr.update(value=None)
+
+        union_runs = runs_from_indices(sorted(set(all_hit_idx)))
+
+        rows = []
+        for seg_id, (a, b) in enumerate(union_runs, start=1):
+            for i in range(a, b + 1):
+                st = frame_stats.get(i)
+                if not st:
+                    continue
+
+            cat_counts = {c: 0 for c in req}
+            cat_maxp   = {c: 0.0 for c in req}
+            for i in range(a, b + 1):
+                st = frame_stats.get(i)
+                if not st:
+                    continue
+                for c, p in st["hits"].items():
+                    cat_counts[c] += 1
+                    if p > cat_maxp[c]:
+                        cat_maxp[c] = p
+
+            present = [c for c in req if cat_counts[c] > 0]
+            present.sort(key=lambda c: (-cat_counts[c], -cat_maxp[c], c))
+
+            for c in present:
+                rows.append({
+                    "seg": seg_id,
+                    "start": round(a / sampling_fps, 3),
+                    "end": round((b + 1) / sampling_fps, 3),
+                    "category": c,
+                    "max_p": round(cat_maxp[c], 3),
+                })
+
+        df = pd.DataFrame(rows).sort_values(["seg", "max_p"], ascending=[True, False]).reset_index(drop=True)
+
+        out_video = gr.update(value=None)
+        if redact and has_ffmpeg():
+            intervals = merge_seconds_union(all_hit_idx, sampling_fps, pad=0.25)
+            try:
+                out_path = os.path.join(td, "redacted.mp4")
+                redact_with_ffmpeg(video_file, intervals, out_path)
+                final_out = os.path.join(os.getcwd(), "redacted_output.mp4")
+                shutil.copyfile(out_path, final_out)
+                out_video = gr.update(value=final_out)
+            except Exception:
+                out_video = gr.update(value=None)
+
+        return df, out_video
+
+
+# ---------- UI ----------
+with gr.Blocks(title=APP_TITLE, css=".wrap-row { gap: 16px; }") as demo:
+    gr.Markdown(f"# {APP_TITLE}")
+    gr.Markdown(APP_DESC)
+
+    with gr.Tabs():
+        with gr.Tab("Image"):
+            with gr.Row(elem_classes=["wrap-row"]):
+                with gr.Column(scale=1, min_width=360):
+                    model_dd = gr.Dropdown(label="Model", choices=MODEL_NAMES, value=MODEL_NAMES[0])
+                    threshold = gr.Slider(0.0, 1.0, value=DEFAULT_THRESHOLD, step=0.01, label="Threshold")
+                    categories = gr.CheckboxGroup(label="Categories", choices=ALL_CATEGORIES, value=ALL_CATEGORIES)
+                    inp_img = gr.Image(type="pil", label="Upload Image")
+                    btn = gr.Button("Analyze", variant="primary")
+                with gr.Column(scale=1, min_width=360):
+                    verdict = gr.Label(label="Verdict")
+                    scores_df = gr.Dataframe(headers=["category", "score"], datatype="str",
+                                             label="Scores", interactive=False)
+                    extra_tags = gr.Textbox(label="Selected tags", visible=False, lines=12)
+
+            model_dd.change(on_model_change, inputs=model_dd, outputs=[categories, threshold])
+            btn.click(analyze_image, inputs=[model_dd, inp_img, categories, threshold],
+                      outputs=[verdict, scores_df, extra_tags])
+
+        with gr.Tab("Video"):
+            with gr.Row(elem_classes=["wrap-row"]):
+                with gr.Column(scale=1, min_width=360):
+                    v_model = gr.Dropdown(label="Model", choices=MODEL_NAMES, value=MODEL_NAMES[0])
+                    v_threshold = gr.Slider(0.0, 1.0, value=DEFAULT_THRESHOLD,
+                                            step=0.01, label="Threshold")
+                    v_fps = gr.Slider(0.25, 5.0, value=1.0, step=0.25, label="Sampling FPS")
+                    v_redact = gr.Checkbox(label="Redact scenes (requires FFmpeg)", value=False)
+                    v_categories = gr.CheckboxGroup(label="Categories", choices=ALL_CATEGORIES, value=ALL_CATEGORIES)
+                    v_input = gr.Video(label="Upload short video (≤ 60s)")
+                    v_btn = gr.Button("Analyze Video", variant="primary")
+                with gr.Column(scale=1, min_width=360):
+                    v_segments = gr.Dataframe(label="Segments", interactive=False)
+                    v_out = gr.Video(label="Redacted Video")
+
+            v_model.change(on_model_change, inputs=v_model, outputs=[v_categories, v_threshold])
+            v_btn.click(analyze_video, inputs=[v_model, v_input, v_categories, v_threshold, v_fps, v_redact],
+                        outputs=[v_segments, v_out])
+
+if __name__ == "__main__":
+    demo.launch()

model_registry.py

@@ -0,0 +1,102 @@
+from typing import Dict, List, Tuple
+from PIL import Image
+
+ALL_CATEGORIES = [
+    "alcohol","drugs","weapons","gambling",
+    "nudity","sexy","smoking","violence"
+]
+DEFAULT_THRESHOLD = 0.5
+NUDENET_ONLY = {"clip-nudenet-lp", "siglip-nudenet-lp"}
+
+class BaseModel:
+    name = "base"
+    supports_selected_tags = False
+    categories = ALL_CATEGORIES
+    def load(self): raise NotImplementedError
+    def predict_image(self, pil_image: Image.Image, requested_categories: List[str]) -> Dict[str, float]:
+        raise NotImplementedError
+    def extra_selected_tags(self, pil_image: Image.Image, top_k: int = 10) -> List[Tuple[str, float]]:
+        return []
+
+class Clip_MultiLabel(BaseModel):
+    name = "clip-multilabel"
+    categories = ALL_CATEGORIES
+    def __init__(self, head_path="weights/clip_multilabel.pt"):
+        self._cfg = dict(head_path=head_path, categories=self.categories)
+        self._m = None
+    def load(self):
+        from src.models import CLIPMultiLabel
+        if self._m is None:
+            self._m = CLIPMultiLabel(**self._cfg)
+    def predict_image(self, pil_image, requested_categories: List[str]) -> Dict[str, float]:
+        p = self._m.prob([pil_image])[0].tolist()
+        return {c: float(p[i]) for i, c in enumerate(self.categories) if c in requested_categories}
+
+class _EVABaseAdapter(BaseModel):
+    supports_selected_tags = True
+    REPO_ID = ""
+    TAG_CSV = ""
+    def __init__(self, head_path: str):
+        self._cfg = dict(head_path=head_path, categories=self.categories)
+        self._m = None
+    def load(self):
+        from src.models.eva_headpreserving import EVAHeadPreserving
+        if self._m is None:
+            self._m = EVAHeadPreserving(repo_id=self.REPO_ID,
+                                        head_path=self._cfg["head_path"],
+                                        categories=self.categories,
+                                        tag_csv=self.TAG_CSV)
+    def predict_image(self, pil_image, requested_categories: List[str]) -> Dict[str, float]:
+        p = self._m.prob([pil_image])[0].tolist()
+        return {c: float(p[i]) for i, c in enumerate(self.categories) if c in requested_categories}
+    def extra_selected_tags(self, pil_image: Image.Image, top_k: int = 50) -> List[Tuple[str, float]]:
+        return self._m.top_tags(pil_image, top_k=top_k)
+
+class WDEva02_Multitask(_EVABaseAdapter):
+    name = "wdeva02-multitask"
+    REPO_ID = "SmilingWolf/wd-eva02-large-tagger-v3"
+    TAG_CSV = "wdeva02_tags.csv"
+    def __init__(self, head_path="weights/wdeva02.pt"): super().__init__(head_path=head_path)
+
+class Animetimm_Multitask(_EVABaseAdapter):
+    name = "animetimm-multitask"
+    REPO_ID = "animetimm/eva02_large_patch14_448.dbv4-full"
+    TAG_CSV = "animetimm_tags.csv"
+    def __init__(self, head_path="weights/animetimm.pt"): super().__init__(head_path=head_path)
+
+class Clip_NudeNet_LP(BaseModel):
+    name = "clip-nudenet-lp"; categories = ["sexual"]
+    def __init__(self, head_path: str = "weights/clip_nudenet_lp.npz"):
+        self._cfg = dict(head_path=head_path); self._lp = None
+    def load(self):
+        if self._lp is None:
+            from src.models import CLIPLinearProbe
+            self._lp = CLIPLinearProbe(**self._cfg)
+    def predict_image(self, pil_image: Image.Image, requested_categories: List[str]) -> Dict[str, float]:
+        return {"sexual": float(self._lp.prob([pil_image])[0])}
+
+class Siglip_NudeNet_LP(BaseModel):
+    name = "siglip-nudenet-lp"; categories = ["sexual"]
+    def __init__(self, head_path: str = "weights/siglip_nudenet_lp.npz"):
+        self._cfg = dict(head_path=head_path); self._lp = None
+    def load(self):
+        if self._lp is None:
+            from src.models import SigLIPLinearProbe
+            self._lp = SigLIPLinearProbe(**self._cfg)
+    def predict_image(self, pil_image: Image.Image, requested_categories: List[str]) -> Dict[str, float]:
+        return {"sexual": float(self._lp.prob([pil_image])[0])}
+
+REGISTRY = {
+    "clip-multilabel": Clip_MultiLabel(),
+    "wdeva02-multilabel": WDEva02_Multitask(),
+    "animetimm-multilabel": Animetimm_Multitask(),
+    "clip-nudenet-lp": Clip_NudeNet_LP(),
+    "siglip-nudenet-lp": Siglip_NudeNet_LP(),
+}
+
+def get_model(name: str) -> BaseModel:
+    m = REGISTRY[name]
+    if not hasattr(m, "_loaded"):
+        m.load()
+        m._loaded = True
+    return m

requirements.txt

@@ -0,0 +1,11 @@
+torch
+open_clip_torch
+transformers
+huggingface_hub
+Pillow
+numpy
+pandas
+gradio>=4.44.0
+opencv-python-headless
+ffmpeg-python
+timm

src/models/__init__.py

@@ -0,0 +1,4 @@
+from .clip_lp import CLIPLinearProbe
+from .siglip_lp import SigLIPLinearProbe
+from .clip_multilabel import CLIPMultiLabel
+from .eva_headpreserving import EVAHeadPreserving

src/models/clip_lp.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+import numpy as np
+import torch
+import open_clip
+from contextlib import nullcontext
+
+from src.models.utils import l2norm_rows
+
+class CLIPLinearProbe:
+    def __init__(self, head_path):
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.torch_dtype = torch.float16 if self.device == "cuda" else torch.float32
+        self.model, _, self.preprocess = open_clip.create_model_and_transforms(
+            "ViT-L-14", pretrained="openai", device=self.device
+        )
+        self.model.eval().requires_grad_(False)
+        npz = np.load(head_path)
+        self.w = torch.from_numpy(npz["w"]).to(self.device).float()
+        self.b = torch.from_numpy(npz["b"]).to(self.device).float()
+
+        if self.device == "cuda":
+            torch.backends.cuda.matmul.allow_tf32 = True
+            torch.backends.cudnn.benchmark = True
+            self.use_amp = True
+
+    @torch.inference_mode()
+    def encode(self, pil_list) -> torch.Tensor:
+        x = torch.stack([self.preprocess(im.convert("RGB")) for im in pil_list], 0)
+        x = x.to(self.device, non_blocking=True, memory_format=torch.channels_last)
+        ctx = torch.amp.autocast("cuda", dtype=self.torch_dtype) if self.use_amp else nullcontext()
+        with ctx:
+            f = self.model.encode_image(x)
+        f = f.float()
+        return l2norm_rows(f)
+
+    @torch.inference_mode()
+    def logits(self, pil_list) -> torch.Tensor:
+        f = self.encode(pil_list)
+        return (f @ self.w + self.b).squeeze(1)
+
+    @torch.inference_mode()
+    def prob(self, pil_list) -> torch.Tensor:
+        z = torch.clamp(self.logits(pil_list), -50, 50)
+        return torch.sigmoid(z)

src/models/clip_multilabel.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+import torch
+import open_clip
+from contextlib import nullcontext
+
+from src.models.utils import l2norm_rows
+
+class CLIPMultiLabel:
+    def __init__(self, head_path, categories):
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.torch_dtype = torch.float16 if self.device == "cuda" else torch.float32
+        self.categories = list(categories)
+        self.model, _, self.preprocess = open_clip.create_model_and_transforms(
+            "ViT-L-14", pretrained="openai", device=self.device
+        )
+        self.model.eval().requires_grad_(False)
+
+        ckpt = torch.load(head_path, map_location=self.device, weights_only=True)
+        state = ckpt.get("model_state", ckpt)
+
+        w = state["head.weight"].to(self.device).float()
+        b = state["head.bias"].to(self.device).float()
+        w = w.t()
+
+        self.w, self.b = w, b
+
+        if self.device == "cuda":
+            torch.backends.cuda.matmul.allow_tf32 = True
+            torch.backends.cudnn.benchmark = True
+            self.use_amp = True
+
+    @torch.inference_mode()
+    def encode(self, pil_list) -> torch.Tensor:
+        x = torch.stack([self.preprocess(im.convert("RGB")) for im in pil_list], 0)
+        x = x.to(self.device, non_blocking=True, memory_format=torch.channels_last)
+        ctx = torch.amp.autocast("cuda", dtype=self.torch_dtype) if self.use_amp else nullcontext()
+        with ctx:
+            f = self.model.encode_image(x)
+        return l2norm_rows(f.float())
+
+    @torch.inference_mode()
+    def logits(self, pil_list) -> torch.Tensor:
+        f = self.encode(pil_list)
+        return f @ self.w + self.b
+
+    @torch.inference_mode()
+    def prob(self, pil_list) -> torch.Tensor:
+        z = torch.clamp(self.logits(pil_list), -50, 50)
+        return torch.sigmoid(z)

src/models/eva_headpreserving.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+from typing import List, Tuple
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import timm
+from timm.data import resolve_model_data_config, create_transform
+from contextlib import nullcontext
+
+from .utils import load_tag_names
+
+class EVAHeadPreserving:
+    """
+    Head-preserving inference for EVA-02 backbones (Animetimm / WD-EVA02).
+    Interface: encode / logits / prob / tags_prob / top_tags
+    """
+    def __init__(self,
+                 repo_id: str,
+                 head_path: str,
+                 categories: List[str],
+                 tag_csv: str = "selected_tags.csv"):
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.torch_dtype = torch.float16 if self.device == "cuda" else torch.float32
+        self.use_amp = (self.device == "cuda")
+
+        self.categories = list(categories)
+        self.tag_csv = tag_csv
+
+        self.backbone = timm.create_model(f"hf-hub:{repo_id}", pretrained=True)
+        self.backbone = self.backbone.to(self.device).eval().requires_grad_(False)
+
+        cfg = resolve_model_data_config(self.backbone)
+        self.preprocess = create_transform(**cfg)
+
+        with torch.no_grad():
+            in_size = cfg.get("input_size", (3, 448, 448))
+            h, w = int(in_size[-2]), int(in_size[-1])
+            dummy = torch.zeros(1, 3, h, w, device=self.device)
+            fx = self.backbone.forward_features(dummy)
+            pre = self.backbone.forward_head(fx, pre_logits=True)
+            tags_log = self.backbone.forward_head(fx, pre_logits=False)
+            D, T = int(pre.shape[-1]), int(tags_log.shape[-1])
+
+        self.custom_head = nn.Linear(D, len(self.categories)).to(self.device).eval().requires_grad_(False)
+
+        ckpt = torch.load(head_path, map_location=self.device, weights_only=True)
+        state = ckpt.get("state_dict", ckpt)
+
+        w = state["head.weight"].to(self.device).float()
+        b = state["head.bias"].to(self.device).float()
+        if w.shape != self.custom_head.weight.shape and w.t().shape == self.custom_head.weight.shape:
+            w = w.t()
+
+        with torch.no_grad():
+            self.custom_head.weight.copy_(w)
+            self.custom_head.bias.copy_(b)
+
+        self.tag_names = load_tag_names(T, self.tag_csv)
+
+        if self.device == "cuda":
+            torch.backends.cuda.matmul.allow_tf32 = True
+            torch.backends.cudnn.allow_tf32 = True
+            torch.backends.cudnn.benchmark = True
+
+    @torch.inference_mode()
+    def encode(self, pil_list: List) -> Tuple[torch.Tensor, torch.Tensor]:
+        x = torch.stack([self.preprocess(im.convert("RGB")) for im in pil_list], 0)
+        x = x.to(self.device, non_blocking=True, memory_format=torch.channels_last)
+        ctx = torch.amp.autocast("cuda", dtype=self.torch_dtype) if self.use_amp else nullcontext()
+        with ctx:
+            fx = self.backbone.forward_features(x)
+            pre = self.backbone.forward_head(fx, pre_logits=True)
+            feat = F.normalize(pre, dim=1)
+            tags_log = self.backbone.forward_head(fx, pre_logits=False)
+        return feat.float(), tags_log.float()
+
+    @torch.inference_mode()
+    def logits(self, pil_list: List) -> torch.Tensor:
+        feat_norm, _ = self.encode(pil_list)
+        return self.custom_head(feat_norm)
+
+    @torch.inference_mode()
+    def prob(self, pil_list: List) -> torch.Tensor:
+        z = torch.clamp(self.logits(pil_list), -20, 20)
+        return torch.sigmoid(z)
+
+    @torch.inference_mode()
+    def tags_prob(self, pil_list: List) -> torch.Tensor:
+        _, tags_log = self.encode(pil_list)
+        z = torch.clamp(tags_log, -20, 20)
+        return torch.sigmoid(z)
+
+    @torch.inference_mode()
+    def top_tags(self, pil_image, top_k: int = 50):
+        p = self.tags_prob([pil_image])[0].tolist()
+        k = max(0, min(top_k, len(p)))
+        idx = sorted(range(len(p)), key=lambda i: -p[i])[:k]
+        names = self.tag_names
+        return [(names[i] if i < len(names) else f"tag_{i:04d}", float(p[i])) for i in idx]

src/models/siglip_lp.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+import numpy as np
+import torch
+from contextlib import nullcontext
+from transformers import AutoProcessor, SiglipModel
+
+from src.models.utils import l2norm_rows
+
+class SigLIPLinearProbe:
+    def __init__(self, head_path):
+        self.model_id = "google/siglip-so400m-patch14-384"
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.torch_dtype = torch.float16 if self.device == "cuda" else torch.float32
+        self.model = SiglipModel.from_pretrained(self.model_id, dtype=self.torch_dtype).to(self.device)
+        self.model.eval().requires_grad_(False)
+        self.processor = AutoProcessor.from_pretrained(self.model_id)
+
+        npz = np.load(head_path)
+        self.w = torch.from_numpy(npz["w"]).to(self.device).float()
+        self.b = torch.from_numpy(npz["b"]).to(self.device).float()
+
+        if self.device == "cuda":
+            torch.backends.cuda.matmul.allow_tf32 = True
+            torch.backends.cudnn.benchmark = True
+            self.use_amp = True
+
+    @torch.inference_mode()
+    def encode(self, pil_list) -> torch.Tensor:
+        imgs = [im.convert("RGB") for im in pil_list]
+        enc = self.processor(images=imgs, return_tensors="pt")
+        x = enc["pixel_values"].to(self.device, non_blocking=True, memory_format=torch.channels_last)
+        ctx = torch.amp.autocast("cuda", dtype=self.torch_dtype) if self.use_amp else nullcontext()
+        with ctx:
+            f = self.model.get_image_features(pixel_values=x)
+        f = f.float()
+        return l2norm_rows(f)
+
+    @torch.inference_mode()
+    def logits(self, pil_list) -> torch.Tensor:
+        f = self.encode(pil_list)
+        return (f @ self.w + self.b).squeeze(1)
+
+    @torch.inference_mode()
+    def prob(self, pil_list ) -> torch.Tensor:
+        z = torch.clamp(self.logits(pil_list), -50, 50)
+        return torch.sigmoid(z)

src/models/utils.py

@@ -0,0 +1,16 @@
+import os, csv, torch
+
+def l2norm_rows(x: torch.Tensor, eps: float = 1e-12) -> torch.Tensor:
+    return x / (x.norm(dim=1, keepdim=True) + eps)
+
+def load_tag_names(T: int, csv_name: str) -> list[str]:
+    p = os.path.join(os.path.dirname(__file__), csv_name)
+    names: list[str] = []
+    if os.path.isfile(p):
+        with open(p, "r", encoding="utf-8", newline="") as f:
+            for row in csv.reader(f):
+                if len(row) > 1 and row[1].strip():
+                    names.append(row[1].strip())
+    if len(names) >= T:
+        return names[:T]
+    return names + [f"tag_{i:04d}" for i in range(len(names), T)]

video_utils.py

@@ -0,0 +1,63 @@
+import os, shutil, subprocess
+
+def has_ffmpeg() -> bool:
+    return shutil.which("ffmpeg") is not None and shutil.which("ffprobe") is not None
+
+def probe_duration(video_path: str) -> float | None:
+    if not shutil.which("ffprobe"):
+        return None
+    try:
+        out = subprocess.check_output(
+            ["ffprobe","-v","error","-select_streams","v:0","-show_entries","stream=duration","-of","default=nw=1:nk=1",video_path],
+            stderr=subprocess.STDOUT, text=True
+        )
+        return float(out.strip())
+    except Exception:
+        return None
+
+def extract_frames_ffmpeg(video_path: str, fps: float, out_dir: str) -> list[tuple[str, int]]:
+    os.makedirs(out_dir, exist_ok=True)
+    tpl = os.path.join(out_dir, "frame_%06d.jpg")
+    subprocess.check_call(
+        ["ffmpeg","-y","-i",video_path,"-vf",f"fps={fps}","-qscale:v","2",tpl],
+        stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
+    )
+    frames = sorted([os.path.join(out_dir,f) for f in os.listdir(out_dir) if f.lower().endswith(".jpg")])
+    return [(p, i) for i, p in enumerate(frames)]
+
+def runs_from_indices(idxs: list[int]) -> list[tuple[int,int]]:
+    if not idxs: return []
+    idxs = sorted(idxs)
+    runs, s, prev = [], idxs[0], idxs[0]
+    for x in idxs[1:]:
+        if x == prev + 1:
+            prev = x
+        else:
+            runs.append((s, prev)); s = prev = x
+    runs.append((s, prev))
+    return runs
+
+def merge_seconds_union(all_indices: list[int], fps: float, pad: float = 0.25) -> list[tuple[float,float]]:
+    if not all_indices: return []
+    runs = runs_from_indices(sorted(all_indices))
+    intervals = []
+    for a, b in runs:
+        start = max(0.0, a / fps - pad)
+        end   = (b + 1) / fps + pad
+        intervals.append((start, end))
+    merged = []
+    for s, e in sorted(intervals):
+        if not merged or s > merged[-1][1]:
+            merged.append((s, e))
+        else:
+            merged[-1] = (merged[-1][0], max(merged[-1][1], e))
+    return merged
+
+def redact_with_ffmpeg(video_path: str, intervals: list[tuple[float,float]], out_path: str):
+    if not intervals:
+        shutil.copyfile(video_path, out_path); return
+    parts = [f"between(t\\,{s:.3f}\\,{e:.3f})" for s, e in intervals]
+    expr = f"not({' + '.join(parts)})"
+    vf = f"select='{expr}',setpts=N/FRAME_RATE/TB"
+    subprocess.check_call(["ffmpeg","-y","-i",video_path,"-vf",vf,"-an",out_path],
+                          stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)