Add unified pretrained metric scorers

benchmarks/edit/run_traditional_metrics.py

@@ -1,5 +1,10 @@
 #!/usr/bin/env python3
-"""Run no-model and optional CLIP traditional metrics on six-method manifests."""
+"""Run traditional/pretrained metrics on six-method manifests.
+
+Default metrics are no-model image/video statistics. Optional scorers are enabled
+only when their CLI args are passed, so the script remains usable in lightweight
+environments.
+"""
 
 from __future__ import annotations
 
@@ -31,6 +36,13 @@ CSV_FIELDS = [
     "clip_t",
     "clip_frame_consistency",
     "clip_source_edit_similarity",
+    "dino_frame_consistency",
+    "laion_aesthetic",
+    "pyiqa_musiq",
+    "pyiqa_niqe",
+    "pyiqa_qalign_quality",
+    "pyiqa_qalign_aesthetic",
+    "lpips_source_edit",
     "error",
 ]
 
@@ -183,6 +195,158 @@ class ClipMetrics:
         }
 
 
+class DinoMetrics:
+    def __init__(self, model_dir: Path, device: str, batch_size: int) -> None:
+        import torch
+        from transformers import AutoImageProcessor, AutoModel
+
+        self.torch = torch
+        self.device = device
+        self.batch_size = batch_size
+        self.processor = AutoImageProcessor.from_pretrained(str(model_dir))
+        self.model = AutoModel.from_pretrained(str(model_dir)).to(device)
+        self.model.eval()
+
+    def image_features(self, frames: list[Image.Image]):
+        chunks = []
+        with self.torch.inference_mode():
+            for start in range(0, len(frames), self.batch_size):
+                batch = frames[start : start + self.batch_size]
+                inputs = self.processor(images=batch, return_tensors="pt").to(self.device)
+                outputs = self.model(**inputs)
+                if getattr(outputs, "pooler_output", None) is not None:
+                    feats = outputs.pooler_output
+                else:
+                    feats = outputs.last_hidden_state[:, 0]
+                feats = feats / feats.norm(dim=-1, keepdim=True).clamp_min(1e-12)
+                chunks.append(feats)
+        return self.torch.cat(chunks, dim=0)
+
+    def compute(self, edited_frames: list[Image.Image]) -> dict[str, float | None]:
+        feats = self.image_features(edited_frames)
+        score = None
+        if feats.shape[0] >= 2:
+            score = float((feats[:-1] * feats[1:]).sum(dim=-1).mean().item() * 100.0)
+        return {"dino_frame_consistency": score}
+
+
+class LaionAestheticMetrics:
+    def __init__(self, clip_model_dir: Path, predictor_path: Path, device: str, batch_size: int) -> None:
+        import torch
+        from transformers import CLIPModel, CLIPProcessor
+
+        self.torch = torch
+        self.device = device
+        self.batch_size = batch_size
+        self.processor = CLIPProcessor.from_pretrained(str(clip_model_dir))
+        self.clip = CLIPModel.from_pretrained(str(clip_model_dir)).to(device)
+        self.clip.eval()
+
+        state = torch.load(str(predictor_path), map_location="cpu")
+        if isinstance(state, dict) and "state_dict" in state:
+            state = state["state_dict"]
+        if isinstance(state, dict) and "model" in state:
+            state = state["model"]
+        weight = None
+        bias = None
+        if isinstance(state, dict):
+            for key, value in state.items():
+                if key.endswith("weight") and getattr(value, "ndim", 0) == 2:
+                    weight = value
+                if key.endswith("bias") and getattr(value, "ndim", 0) == 1:
+                    bias = value
+            if "weight" in state:
+                weight = state["weight"]
+            if "bias" in state:
+                bias = state["bias"]
+        if weight is None:
+            raise RuntimeError(f"cannot find linear weight in {predictor_path}")
+        self.linear = torch.nn.Linear(int(weight.shape[1]), int(weight.shape[0]))
+        self.linear.weight.data.copy_(weight.float())
+        if bias is not None:
+            self.linear.bias.data.copy_(bias.float())
+        self.linear = self.linear.to(device)
+        self.linear.eval()
+
+    def compute(self, edited_frames: list[Image.Image]) -> dict[str, float]:
+        scores = []
+        with self.torch.inference_mode():
+            for start in range(0, len(edited_frames), self.batch_size):
+                batch = edited_frames[start : start + self.batch_size]
+                inputs = self.processor(images=batch, return_tensors="pt").to(self.device)
+                feats = self.clip.get_image_features(**inputs)
+                feats = feats / feats.norm(dim=-1, keepdim=True).clamp_min(1e-12)
+                if feats.shape[-1] != self.linear.in_features:
+                    raise RuntimeError(
+                        f"aesthetic predictor expects {self.linear.in_features} features, "
+                        f"but CLIP produced {feats.shape[-1]}"
+                    )
+                values = self.linear(feats).reshape(-1)
+                scores.extend(values.detach().float().cpu().tolist())
+        return {"laion_aesthetic": float(np.mean(scores))}
+
+
+class PyiqaMetrics:
+    def __init__(self, metric_names: list[str], device: str) -> None:
+        import pyiqa
+        import torch
+
+        self.torch = torch
+        self.metrics = {name: pyiqa.create_metric(name, device=device) for name in metric_names}
+
+    def frames_tensor(self, frames: list[Image.Image]):
+        arrays = [np.asarray(frame, dtype=np.float32) / 255.0 for frame in frames]
+        tensor = self.torch.from_numpy(np.stack(arrays, axis=0)).permute(0, 3, 1, 2).contiguous()
+        return tensor
+
+    def _score_plain(self, metric, frames):
+        tensor = self.frames_tensor(frames)
+        with self.torch.inference_mode():
+            value = metric(tensor)
+        return float(value.detach().float().mean().cpu().item())
+
+    def _score_qalign(self, metric, frames, task: str):
+        tensor = self.frames_tensor(frames)
+        with self.torch.inference_mode():
+            value = metric(tensor, task_=task)
+        return float(value.detach().float().mean().cpu().item())
+
+    def compute(self, edited_frames: list[Image.Image]) -> dict[str, float]:
+        result = {}
+        for name, metric in self.metrics.items():
+            if name == "qalign_quality":
+                result["pyiqa_qalign_quality"] = self._score_qalign(metric, edited_frames, "quality")
+            elif name == "qalign_aesthetic":
+                result["pyiqa_qalign_aesthetic"] = self._score_qalign(metric, edited_frames, "aesthetic")
+            else:
+                result[f"pyiqa_{name}"] = self._score_plain(metric, edited_frames)
+        return result
+
+
+class LpipsMetrics:
+    def __init__(self, device: str, net: str) -> None:
+        import lpips
+        import torch
+
+        self.torch = torch
+        self.device = device
+        self.model = lpips.LPIPS(net=net).to(device)
+        self.model.eval()
+
+    def frames_tensor(self, frames: list[Image.Image]):
+        arrays = [np.asarray(frame, dtype=np.float32) / 127.5 - 1.0 for frame in frames]
+        tensor = self.torch.from_numpy(np.stack(arrays, axis=0)).permute(0, 3, 1, 2).contiguous()
+        return tensor.to(self.device)
+
+    def compute(self, source_frames: list[Image.Image], edited_frames: list[Image.Image]) -> dict[str, float]:
+        n = min(len(source_frames), len(edited_frames))
+        source = self.frames_tensor(source_frames[:n])
+        edited = self.frames_tensor(edited_frames[:n])
+        with self.torch.inference_mode():
+            values = self.model(source, edited).reshape(-1)
+        return {"lpips_source_edit": float(values.detach().float().mean().cpu().item())}
+
+
 def empty_result(row: dict[str, Any]) -> dict[str, Any]:
     result = {field: "" for field in CSV_FIELDS}
     for key in ("split", "sample_id", "method", "instruction", "source_video", "edited_video"):
@@ -197,8 +361,20 @@ def main() -> None:
     parser.add_argument("--frames-per-video", type=int, default=16)
     parser.add_argument("--resize", type=int, default=256, help="Resize sampled frames to square size before metrics; 0 disables.")
     parser.add_argument("--clip-model-dir", type=Path, default=None)
+    parser.add_argument("--dino-model-dir", type=Path, default=None)
+    parser.add_argument("--aesthetic-clip-model-dir", type=Path, default=None)
+    parser.add_argument("--aesthetic-predictor", type=Path, default=None)
+    parser.add_argument(
+        "--pyiqa-metrics",
+        default="",
+        help="Comma-separated pyiqa metrics: musiq,niqe,qalign_quality,qalign_aesthetic.",
+    )
+    parser.add_argument("--lpips", action="store_true", help="Compute LPIPS between source and edited frames.")
+    parser.add_argument("--lpips-net", default="alex", choices=("alex", "vgg", "squeeze"))
     parser.add_argument("--device", default="cpu")
     parser.add_argument("--clip-batch-size", type=int, default=8)
+    parser.add_argument("--dino-batch-size", type=int, default=8)
+    parser.add_argument("--aesthetic-batch-size", type=int, default=8)
     args = parser.parse_args()
 
     rows = read_jsonl(args.manifest)
@@ -207,6 +383,40 @@ def main() -> None:
     clip = None
     if args.clip_model_dir:
         clip = ClipMetrics(args.clip_model_dir, args.device, args.clip_batch_size)
+    dino = None
+    if args.dino_model_dir:
+        dino = DinoMetrics(args.dino_model_dir, args.device, args.dino_batch_size)
+    aesthetic = None
+    if args.aesthetic_clip_model_dir or args.aesthetic_predictor:
+        if not args.aesthetic_clip_model_dir or not args.aesthetic_predictor:
+            raise ValueError("--aesthetic-clip-model-dir and --aesthetic-predictor must be passed together")
+        aesthetic = LaionAestheticMetrics(
+            args.aesthetic_clip_model_dir,
+            args.aesthetic_predictor,
+            args.device,
+            args.aesthetic_batch_size,
+        )
+    pyiqa_metrics = None
+    requested_pyiqa = [name.strip() for name in args.pyiqa_metrics.split(",") if name.strip()]
+    if requested_pyiqa:
+        metric_names = ["qalign" if name.startswith("qalign_") else name for name in requested_pyiqa]
+        deduped = []
+        for name in metric_names:
+            if name not in deduped:
+                deduped.append(name)
+        pyiqa_metrics = PyiqaMetrics(deduped, args.device)
+        # Keep the user's requested qalign task variants while sharing one metric instance.
+        pyiqa_metrics.metrics = {
+            ("qalign_quality" if name == "qalign" and "qalign_quality" in requested_pyiqa else name): metric
+            for name, metric in pyiqa_metrics.metrics.items()
+        }
+        if "qalign_aesthetic" in requested_pyiqa and "qalign_quality" in pyiqa_metrics.metrics:
+            pyiqa_metrics.metrics["qalign_aesthetic"] = pyiqa_metrics.metrics["qalign_quality"]
+        elif "qalign_aesthetic" in requested_pyiqa and "qalign" in pyiqa_metrics.metrics:
+            pyiqa_metrics.metrics["qalign_aesthetic"] = pyiqa_metrics.metrics.pop("qalign")
+    lpips_metric = None
+    if args.lpips:
+        lpips_metric = LpipsMetrics(args.device, args.lpips_net)
 
     with args.output.open("w", encoding="utf-8", newline="") as handle:
         writer = csv.DictWriter(handle, fieldnames=CSV_FIELDS)
@@ -221,6 +431,14 @@ def main() -> None:
                 result.update(no_model_metrics(source_frames, edited_frames))
                 if clip is not None:
                     result.update(clip.compute(source_frames, edited_frames, str(row["instruction"])))
+                if dino is not None:
+                    result.update(dino.compute(edited_frames))
+                if aesthetic is not None:
+                    result.update(aesthetic.compute(edited_frames))
+                if pyiqa_metrics is not None:
+                    result.update(pyiqa_metrics.compute(edited_frames))
+                if lpips_metric is not None:
+                    result.update(lpips_metric.compute(source_frames, edited_frames))
             except Exception as exc:
                 result["error"] = repr(exc)
             writer.writerow(result)

benchmarks/edit/traditional_eval_notes.md

@@ -423,38 +423,188 @@ PY
 
 本地 reference 没有完整 VEditBench official eval code。需要另配 Q-Align/OneAlign scorer 后，再接入统一 manifest。
 
-## Scripts Added Here
+## Run Unified Metrics on val20 / val100
 
 - `build_six_method_manifest.py`: 为 val20/val100 构建统一 manifest。
-- `run_traditional_metrics.py`: 默认跑 no-model metrics；如果传入 `--clip-model-dir models/openai_clip-vit-large-patch14`，额外跑 CLIP 指标。
+- `run_traditional_metrics.py`: 默认跑 no-model metrics；按参数额外启用 CLIP、DINO、LAION aesthetic、pyiqa、LPIPS。
 
-示例：
+### 1. 生成 manifest
 
 ```bash
-cd /Users/ouzhang/Desktop/low-high/low-high-new
+cd /inspire/hdd/project/intelligentcreativedesign/dangshengqi-253114050252/z-anna/low-high-new
 
 python3 reference/benchmarks/edit/build_six_method_manifest.py \
   --repo-root . \
   --output-dir out/edit_model_face_stage1/traditional_eval_manifests
+```
+
+### 2. 主环境一次性跑 CLIP / DINO / LAION / MUSIQ / NIQE / LPIPS
+
+这些指标可以在主环境跑。如果 `pyiqa` 或 `lpips` 没装，先安装：
+
+```bash
+python3 -m pip install pyiqa lpips imageio imageio-ffmpeg
+```
+
+运行 `val20`：
+
+```bash
+cd /inspire/hdd/project/intelligentcreativedesign/dangshengqi-253114050252/z-anna/low-high-new
+
+mkdir -p out/edit_model_face_stage1/traditional_eval_metrics
+export TORCH_HOME="$PWD/models/torch_cache"
+export HF_HOME="$PWD/models/hf_cache"
+export XDG_CACHE_HOME="$PWD/models/cache"
 
 python3 reference/benchmarks/edit/run_traditional_metrics.py \
   --manifest out/edit_model_face_stage1/traditional_eval_manifests/val20.jsonl \
-  --output out/edit_model_face_stage1/traditional_eval_metrics/val20_metrics.csv \
-  --frames-per-video 16
+  --output out/edit_model_face_stage1/traditional_eval_metrics/val20_metrics_full.csv \
+  --frames-per-video 16 \
+  --resize 256 \
+  --device cuda:0 \
+  --clip-model-dir models/openai_clip-vit-large-patch14 \
+  --dino-model-dir models/facebook_dino-vitb16 \
+  --aesthetic-clip-model-dir models/openai_clip-vit-large-patch14 \
+  --aesthetic-predictor models/laion_aesthetic/sa_0_4_vit_l_14_linear.pth \
+  --pyiqa-metrics musiq,niqe \
+  --lpips \
+  --clip-batch-size 8 \
+  --dino-batch-size 8 \
+  --aesthetic-batch-size 8
+```
+
+运行 `val100`：
+
+```bash
+cd /inspire/hdd/project/intelligentcreativedesign/dangshengqi-253114050252/z-anna/low-high-new
+
+mkdir -p out/edit_model_face_stage1/traditional_eval_metrics
+export TORCH_HOME="$PWD/models/torch_cache"
+export HF_HOME="$PWD/models/hf_cache"
+export XDG_CACHE_HOME="$PWD/models/cache"
 
 python3 reference/benchmarks/edit/run_traditional_metrics.py \
   --manifest out/edit_model_face_stage1/traditional_eval_manifests/val100.jsonl \
-  --output out/edit_model_face_stage1/traditional_eval_metrics/val100_metrics.csv \
-  --frames-per-video 16
+  --output out/edit_model_face_stage1/traditional_eval_metrics/val100_metrics_full.csv \
+  --frames-per-video 16 \
+  --resize 256 \
+  --device cuda:0 \
+  --clip-model-dir models/openai_clip-vit-large-patch14 \
+  --dino-model-dir models/facebook_dino-vitb16 \
+  --aesthetic-clip-model-dir models/openai_clip-vit-large-patch14 \
+  --aesthetic-predictor models/laion_aesthetic/sa_0_4_vit_l_14_linear.pth \
+  --pyiqa-metrics musiq,niqe \
+  --lpips \
+  --clip-batch-size 8 \
+  --dino-batch-size 8 \
+  --aesthetic-batch-size 8
 ```
 
-带 CLIP：
+输出 CSV 包含：
+
+| Column | 指标来源 / 含义 | 方向 |
+|---|---|---|
+| `pixel_mse` | FiVE MSE / 全图像素差近似 | 低更好 |
+| `pixel_psnr` | FiVE PSNR 全图近似 | 高更好 |
+| `source_edit_l1` | 源/编辑视频全图 L1 差异 | 低更好 |
+| `global_ssim` | VEditBench / FiVE SSIM 全图近似 | 高更好 |
+| `edited_frame_diff_mae` | IVE temporal flickering 原始帧间差 | 低更好 |
+| `temporal_flicker_score` | `(255-frame_diff_mae)/255` | 高更好 |
+| `clip_t` | CLIP edited frame - instruction similarity | 高更好 |
+| `clip_frame_consistency` | CLIP edited frame cross-frame consistency | 高更好 |
+| `clip_source_edit_similarity` | CLIP source/edit semantic similarity | 高更好 |
+| `dino_frame_consistency` | DINO edited frame cross-frame consistency | 高更好 |
+| `laion_aesthetic` | LAION aesthetic predictor | 高更好 |
+| `pyiqa_musiq` | MUSIQ image quality, frame average | 高更好 |
+| `pyiqa_niqe` | NIQE no-reference quality, frame average | 低更好 |
+| `lpips_source_edit` | LPIPS source/edit perceptual distance | 低更好 |
+
+### 3. 单独环境跑 Q-Align / OneAlign 分数
+
+Q-Align/OneAlign 建议用 `lowhigh-qalign` 环境，避免和主训练环境的 `numpy>=2`、`bitsandbytes` 冲突。先确保环境已创建并能加载 `qalign`：
 
 ```bash
+cd /inspire/hdd/project/intelligentcreativedesign/dangshengqi-253114050252/z-anna/low-high-new
+
+conda activate lowhigh-qalign
+
+python3 -m pip install imageio imageio-ffmpeg pyiqa
+python3 -m pip uninstall -y bitsandbytes || true
+
+export TORCH_HOME="$PWD/models/torch_cache"
+export HF_HOME="$PWD/models/hf_cache"
+export XDG_CACHE_HOME="$PWD/models/cache"
+
+python3 reference/benchmarks/edit/run_traditional_metrics.py \
+  --manifest out/edit_model_face_stage1/traditional_eval_manifests/val20.jsonl \
+  --output out/edit_model_face_stage1/traditional_eval_metrics/val20_metrics_qalign.csv \
+  --frames-per-video 16 \
+  --resize 256 \
+  --device cuda:0 \
+  --pyiqa-metrics qalign_quality,qalign_aesthetic
+
 python3 reference/benchmarks/edit/run_traditional_metrics.py \
   --manifest out/edit_model_face_stage1/traditional_eval_manifests/val100.jsonl \
-  --output out/edit_model_face_stage1/traditional_eval_metrics/val100_metrics_clip.csv \
+  --output out/edit_model_face_stage1/traditional_eval_metrics/val100_metrics_qalign.csv \
   --frames-per-video 16 \
-  --clip-model-dir models/openai_clip-vit-large-patch14 \
-  --device cuda
+  --resize 256 \
+  --device cuda:0 \
+  --pyiqa-metrics qalign_quality,qalign_aesthetic
+```
+
+Q-Align 输出列：
+
+| Column | 含义 | 方向 |
+|---|---|---|
+| `pyiqa_qalign_quality` | Q-Align / OneAlign image quality scorer | 高更好 |
+| `pyiqa_qalign_aesthetic` | Q-Align / OneAlign aesthetic scorer | 高更好 |
+
+### 4. 汇总每个 method 的均值
+
+```bash
+cd /inspire/hdd/project/intelligentcreativedesign/dangshengqi-253114050252/z-anna/low-high-new
+
+python3 - <<'PY'
+import csv
+from collections import defaultdict
+from pathlib import Path
+
+paths = [
+    Path("out/edit_model_face_stage1/traditional_eval_metrics/val20_metrics_full.csv"),
+    Path("out/edit_model_face_stage1/traditional_eval_metrics/val100_metrics_full.csv"),
+    Path("out/edit_model_face_stage1/traditional_eval_metrics/val20_metrics_qalign.csv"),
+    Path("out/edit_model_face_stage1/traditional_eval_metrics/val100_metrics_qalign.csv"),
+]
+
+for path in paths:
+    if not path.exists():
+        continue
+    rows = list(csv.DictReader(path.open()))
+    by_method = defaultdict(list)
+    for row in rows:
+        by_method[row["method"]].append(row)
+
+    print("====", path)
+    print("rows", len(rows), "errors", sum(1 for row in rows if row.get("error")))
+    fields = [f for f in rows[0].keys() if f not in {"split", "sample_id", "method", "instruction", "source_video", "edited_video", "error"}]
+    for method in sorted(by_method):
+        print("--", method, "n", len(by_method[method]))
+        for field in fields:
+            values = []
+            for row in by_method[method]:
+                value = row.get(field, "")
+                if value and value not in {"None", "inf"}:
+                    try:
+                        values.append(float(value))
+                    except ValueError:
+                        pass
+            if values:
+                print(field, sum(values) / len(values))
+PY
 ```
+
+### 5. 为什么 CoTracker / GroundingDINO 不在统一脚本默认跑
+
+- `CoTracker3` 已下载，但 FiVE/IVE 的 motion fidelity 不是简单逐帧 cosine；需要轨迹采样、遮挡处理和 benchmark 自己的 matching/aggregation 逻辑。可以后续单独接一个 `run_cotracker_metrics.py`，不建议混进当前轻量 CSV 脚本。
+- `GroundingDINO` 的 Quantity Accuracy 需要每条样本的 `target_span` 和目标数量。当前 `val20/val100` manifest 只有 `instruction/source_video/edited_video`，没有结构化数量字段，所以不能可靠跑 IVE 的 QA。
+- `CLIPS.edit`、FiVE background preservation 的正式版本需要 edit mask。当前 manifest 没有 mask，只能跑全图近似 PSNR/LPIPS/MSE/SSIM。