Update SynthScope Space from the GitHub repository

LEADERBOARD.md

@@ -34,3 +34,5 @@ Metrics are percentages. **mAP** = mean AP over generators. Each track is ranked
 | --- | --- | --- | --- | --- | --- | --- | --- | --- |
 | 1 | SPLIT | training-free | 99.41 | 99.79 | — | 99.97 | ✓ | Training-free X-CLIP patch roughness x motion incoherence; Acc at the real-only FPR-1% calibration |
 | 2 | D3 | training-free | 95.53 | 68.84 | — | 98.45 | ✓ | Training-free X-CLIP 2nd-order feature volatility (official preprocessing) |
+| 3 | STALL | training-free | 56.89 | 32.05 | — | 82.59 | ✓ | Training-free DINOv3 spatio-temporal likelihood under VATEX real-video statistics |
+| 4 | ReStraV | frozen-probe | 30.01 | 33.60 | — | 43.06 | ✓ | Frozen DINOv2 trajectory geometry + MLP trained on GenVidBench; does not transfer to GenVideo-Val (AUROC below 50) |

benchmark/README.md

@@ -19,7 +19,7 @@ from the submission files in [`submissions/`](submissions/) — see [LEADERBOARD
 | `genimage-sdv1.4` | image | GenImage SD-v1.4 real/fake | in-distribution diffusion | **AUROC** |
 | `genvideo-val` | video | GenVideo-Val: all 10,000 MSR-VTT reals against every fake, per generator | mixed | **AUROC** (AP with fake as positive is unstable here: as few as 56 fakes against 10,000 reals) |
 
-**These three tracks are only the start.** The repo supports 13 image and 8 video benchmark datasets (see the table in the
+**These three tracks are only the start.** The repo supports 20 image and 8 video benchmark datasets (see the table in the
 [README](../README.md#-benchmarks)), and the web page's Leaderboard tab already compares detectors on 30+ benchmark groups.
 A dataset becomes a standardized track once its protocol (test set, grouping, metric) is fixed, so results stay comparable;
 adding one means a schema entry, an `evaluate.py` track and verified submissions, described in

benchmark/bench_eval.py

@@ -144,8 +144,9 @@ def discover(benchmark: str, root: Path, shared_reals: Path | None, select: set[
 
 
 def native_res_transform(tf):
-    """Drop the up-scaling Resize/CenterCrop from a model's eval transform, keeping
-    ToTensor + Normalize, so images are scored at NATIVE resolution.
+    """Drop the up-scaling resize/center-crop steps from a model's eval transform, keeping
+    to_dtype + normalize, so images are scored at NATIVE resolution (ValueError for eval lists
+    whose own steps resize, see ``AIGITransformations.without_resize``).
 
     Some methods (e.g. NPR on GANGen-Detection/freqnet) detect up-sampling artifacts and
     MUST NOT be fed a bilinearly up-scaled image — resizing a 128x128 GAN crop to 256x256
@@ -153,11 +154,7 @@ def native_res_transform(tf):
     GANGen recipe runs with ``no_resize=True``; this reproduces it. Safe only when every
     image in a per-generator batch shares one resolution (true for freqnet's per-gen sets),
     since bench_eval stacks a batch into a single tensor."""
-    import torchvision.transforms as T
-    if not isinstance(tf, T.Compose):
-        return tf
-    kept = [t for t in tf.transforms if not isinstance(t, (T.Resize, T.CenterCrop))]
-    return T.Compose(kept)
+    return tf.without_resize()
 
 
 @torch.no_grad()

benchmark/submissions/restrav.json

@@ -3,20 +3,61 @@
   "track": "genvideo-val",
   "modality": "video",
   "model_type": "restrav",
-  "paper": "2025",
+  "paper": "Interno et al., 2025",
   "url": "https://github.com/SMSD75/SynthScope",
   "evaluation": "frozen-probe",
   "metrics": {
-    "acc": null,
-    "map": null,
-    "ap": 96.67,
-    "auroc": 97.06
+    "acc": 30.01,
+    "map": 33.6,
+    "ap": null,
+    "auroc": 43.06
+  },
+  "per_generator": {
+    "Crafter": {
+      "auroc": 89.15,
+      "ap": 68.75
+    },
+    "Gen2": {
+      "auroc": 2.76,
+      "ap": 6.37
+    },
+    "HotShot": {
+      "auroc": 0.1,
+      "ap": 3.35
+    },
+    "Lavie": {
+      "auroc": 34.51,
+      "ap": 25.86
+    },
+    "ModelScope": {
+      "auroc": 78.96,
+      "ap": 59.16
+    },
+    "MoonValley": {
+      "auroc": 2.07,
+      "ap": 3.02
+    },
+    "MorphStudio": {
+      "auroc": 92.58,
+      "ap": 74.66
+    },
+    "Show_1": {
+      "auroc": 91.56,
+      "ap": 66.49
+    },
+    "Sora": {
+      "auroc": 0.26,
+      "ap": 0.29
+    },
+    "WildScrape": {
+      "auroc": 38.7,
+      "ap": 28.08
+    }
   },
-  "per_generator": null,
   "submitted_by": "SynthScope",
-  "date": "2026-06-02",
+  "date": "2026-11-02",
   "verified": true,
-  "source": "SynthScope reproduction (logged Test Metrics); see repro/FINAL_RESULTS.md",
-  "protocol_notes": "Frozen DINOv2 trajectory geometry + MLP",
+  "source": "repro/bench_results/restrav_genvideo_full.json (benchmark/bench_eval_video.py --dataset genvideo, no --limit)",
+  "protocol_notes": "Frozen DINOv2 trajectory geometry + MLP trained on GenVidBench; does not transfer to GenVideo-Val (AUROC below 50)",
   "synthscope_version": "0.1.0"
 }

benchmark/submissions/stall.json

@@ -0,0 +1,63 @@
+{
+  "method": "STALL",
+  "track": "genvideo-val",
+  "modality": "video",
+  "model_type": "stall",
+  "paper": "Ben Hayun et al., CVPR'26",
+  "url": "https://github.com/SMSD75/SynthScope",
+  "evaluation": "training-free",
+  "metrics": {
+    "acc": 56.89,
+    "map": 32.05,
+    "ap": null,
+    "auroc": 82.59
+  },
+  "per_generator": {
+    "Crafter": {
+      "auroc": 87.91,
+      "ap": 53.66
+    },
+    "Gen2": {
+      "auroc": 90.0,
+      "ap": 58.91
+    },
+    "HotShot": {
+      "auroc": 76.97,
+      "ap": 21.25
+    },
+    "Lavie": {
+      "auroc": 86.42,
+      "ap": 53.53
+    },
+    "ModelScope": {
+      "auroc": 78.21,
+      "ap": 20.92
+    },
+    "MoonValley": {
+      "auroc": 82.67,
+      "ap": 22.83
+    },
+    "MorphStudio": {
+      "auroc": 83.22,
+      "ap": 28.34
+    },
+    "Show_1": {
+      "auroc": 82.29,
+      "ap": 30.09
+    },
+    "Sora": {
+      "auroc": 80.73,
+      "ap": 2.8
+    },
+    "WildScrape": {
+      "auroc": 77.48,
+      "ap": 28.22
+    }
+  },
+  "submitted_by": "SynthScope",
+  "date": "2026-11-02",
+  "verified": true,
+  "source": "repro/bench_results/stall_genvideo_full.json (benchmark/bench_eval_video.py --dataset genvideo, no --limit)",
+  "protocol_notes": "Training-free DINOv3 spatio-temporal likelihood under VATEX real-video statistics",
+  "synthscope_version": "0.1.0"
+}

conf/dataset/image/arforensics.yaml

@@ -3,7 +3,8 @@ name: arforensics
 # Open-MAGVIT2), 6000 fakes + 6000 ImageNet reals each. (HF Yanran21/ARForensics, corrected test release, 21 GB, MIT)
 root_dir: /hddstore/ssalehi/SynthScope/ARForensics
 hf_repo_id: Yanran21/ARForensics
-train_batch_size: 32       # D3QE's training data (train/val splits) is fetched only when a train_transform_list is set
+with_train_splits: false   # true: also build (and fetch) the train/val splits, D3QE's training data (39 GB)
+train_batch_size: 32
 val_batch_size: 64
 test_batch_size: 512
 num_workers: 8

conf/model/image/adapted_dino.yaml

@@ -0,0 +1,15 @@
+defaults:
+  - /model/default
+  - _self_
+
+# Adapter-tuned DINOv2: frozen DINOv2 ViT-L/14 with a trainable bottleneck adapter per block + a linear head.
+model_type: adapted_dino
+backbone_name: dinov2_vitl14
+use_adapter: true
+bottleneck_dim: 64
+freeze_backbone: true
+
+# Test-time preprocessing: inference, benchmarks and the end-of-training test.
+eval_transform_list: [resize_short_256, center_crop_224, to_dtype, normalize_imagenet]
+# Training augmentation.
+train_transform_list: [resize_short_256, gaussian_blur, jpeg_compression, random_crop_224, random_horizontal_flip, to_dtype, normalize_imagenet]

conf/model/image/aide.yaml

@@ -19,3 +19,14 @@ dct:
   stride: 16
   output_size: 256
   grade_N: 6
+
+# Test-time preprocessing (official): inference and benchmarks.
+eval_transform_list: [aide_five_view]
+# Training augmentation: the five native-resolution views, long side capped at 1024 (the recipe of the SynthScope_train
+# checkpoint, repro/retrain_aide_native_v2.sbatch).
+train_transform_list: [random_horizontal_flip, aide_five_view_train]
+# Validation during training (differs from the test-time preprocessing above).
+val_transform_list: [aide_five_view_train]
+# Caps the long side at 1024 to bound dataloader-worker memory during the end-of-training test; inference and
+# benchmarks use the uncapped eval list.
+test_transform_list: [aide_five_view_train]

conf/model/image/bfree.yaml

@@ -9,3 +9,8 @@ model_type: bfree
 timm_arch: vit_base_patch14_reg4_dinov2.lvd142m
 crop_size: 504
 pretrained_backbone: false
+
+# Test-time preprocessing (official): inference, benchmarks and the end-of-training test.
+eval_transform_list: [to_dtype, normalize_imagenet]
+# Native resolution (variable size): an end-of-training test through the training loaders needs
+# DatasetConfig.test_batch_size=1 (no training recipe exists).

conf/model/image/clip.yaml

@@ -0,0 +1,15 @@
+defaults:
+  - /model/default
+  - _self_
+
+# UnivFD (Ojha et al., CVPR'23): frozen CLIP ViT-L/14 image features + a linear real/fake head.
+model_type: clip
+backbone_name: CLIP:ViT-L/14
+use_adapter: false
+bottleneck_dim: 64
+freeze_backbone: true
+
+# Test-time preprocessing: inference, benchmarks and the end-of-training test.
+eval_transform_list: [resize_short_256, center_crop_224, to_dtype, normalize_clip]
+# Training augmentation.
+train_transform_list: [resize_short_256, gaussian_blur, jpeg_compression, random_crop_224, random_horizontal_flip, to_dtype, normalize_clip]

conf/model/image/cnn.yaml

@@ -0,0 +1,12 @@
+defaults:
+  - /model/default
+  - _self_
+
+# CNNDetection (Wang et al., CVPR'20): ImageNet ResNet-50 fine-tuned end to end as a real/fake classifier.
+model_type: cnn
+freeze_backbone: false
+
+# Test-time preprocessing: inference, benchmarks and the end-of-training test.
+eval_transform_list: [resize_short_256, center_crop_224, to_dtype, normalize_imagenet]
+# Training augmentation.
+train_transform_list: [resize_short_256, gaussian_blur, jpeg_compression, random_crop_224, random_horizontal_flip, to_dtype, normalize_imagenet]

conf/model/image/co_spy.yaml

@@ -19,3 +19,8 @@ feat_interp_alpha: 0.2
 
 num_classes: 2
 freeze_backbone: true
+
+# Test-time preprocessing (official): inference, benchmarks and the end-of-training test.
+eval_transform_list: [resize_short_384, center_crop_384, to_dtype]
+# Training augmentation.
+train_transform_list: [resize_short_384, gaussian_blur, jpeg_compression, random_crop_384, random_horizontal_flip, to_dtype]

conf/model/image/cure.yaml

@@ -13,3 +13,6 @@ base_filename: PE-Core-L14-336.pt
 base_checkpoint: null          # local PE-Core-L14-336.pt override (or env SYNTHSCOPE_PE_CORE_CKPT)
 load_base_backbone: true       # false = build the architecture only (smoke tests / key checks)
 label_smoothing: 0.0
+
+# Test-time preprocessing (official): inference, benchmarks and the end-of-training test.
+eval_transform_list: [cure_eval]

conf/model/image/d3qe.yaml

@@ -8,3 +8,10 @@ defaults:
 # vq_ds16_c2i.pt) are fetched from their own releases, as in the official code.
 model_type: d3qe
 vq_checkpoint: null    # local vq_ds16_c2i.pt; null -> $SYNTHSCOPE_LLAMAGEN_VQ, else download from the Hugging Face Hub
+
+# Test-time preprocessing (official): inference, benchmarks and the end-of-training test.
+eval_transform_list: [resize_short_256, center_crop_256, to_dtype]
+# Training augmentation.
+train_transform_list: [resize_short_256, blur_jpeg_cnndet, random_crop_256, random_horizontal_flip, to_dtype]
+# Validation during training (differs from the test-time preprocessing above).
+val_transform_list: [resize_short_256, blur_jpeg_cnndet_val, center_crop_256, to_dtype]

conf/model/image/dda.yaml

@@ -12,3 +12,7 @@ lora_rank: 8
 lora_alpha: 1.0
 lora_targets: [attn.qkv, attn.proj, mlp.fc1, mlp.fc2]
 freeze_backbone: true
+
+# Test-time preprocessing (official): inference, benchmarks and the end-of-training test.
+eval_transform_list: [center_crop_336, to_dtype, normalize_clip]
+# No training lists: DDA trains on dataset image/dda_train, which builds its own official paired transforms.

conf/model/image/dinov2.yaml

@@ -0,0 +1,15 @@
+defaults:
+  - /model/default
+  - _self_
+
+# DINOv2 probe: frozen DINOv2 ViT-L/14 + a linear real/fake head.
+model_type: dinov2
+backbone_name: dinov2_vitl14
+use_adapter: false
+bottleneck_dim: 64
+freeze_backbone: true
+
+# Test-time preprocessing: inference, benchmarks and the end-of-training test.
+eval_transform_list: [resize_short_256, center_crop_224, to_dtype, normalize_imagenet]
+# Training augmentation.
+train_transform_list: [resize_short_256, gaussian_blur, jpeg_compression, random_crop_224, random_horizontal_flip, to_dtype, normalize_imagenet]

conf/model/image/dinov3.yaml

@@ -0,0 +1,15 @@
+defaults:
+  - /model/default
+  - _self_
+
+# DINOv3 probe: frozen DINOv3 ViT-L/16 (gated weights) + a linear real/fake head.
+model_type: dinov3
+backbone_name: dinov3_vitl16
+use_adapter: false
+bottleneck_dim: 64
+freeze_backbone: true
+
+# Test-time preprocessing: inference, benchmarks and the end-of-training test.
+eval_transform_list: [resize_short_256, center_crop_256, to_dtype, normalize_dinov3]
+# Training augmentation.
+train_transform_list: [resize_short_256, gaussian_blur, jpeg_compression, random_crop_256, random_horizontal_flip, to_dtype, normalize_dinov3]

conf/model/image/effort.yaml

@@ -7,3 +7,6 @@ defaults:
 model_type: effort
 clip_name: openai/clip-vit-large-patch14
 svd_rank: 1023
+
+# Test-time preprocessing (official): inference, benchmarks and the end-of-training test.
+eval_transform_list: [effort_cv2_resize_224, to_dtype, normalize_clip]

conf/model/image/fat_former.yaml

@@ -11,3 +11,12 @@ num_classes: 2
 classnames: [real, fake]
 freeze_backbone: true
 force_fp32: true
+
+# Official FatFormer (utils/dataset.py) normalizes with ImageNet mean/std, not CLIP's, despite the CLIP backbone (the
+# official-weights eval reproduces 98.39 acc / 99.70 mAP with it).
+# Test-time preprocessing (official): inference, benchmarks and the end-of-training test.
+eval_transform_list: [resize_256, center_crop_224, to_dtype, normalize_imagenet]
+# Training augmentation.
+train_transform_list: [resize_short_256, gaussian_blur, jpeg_compression, random_crop_224, random_horizontal_flip, to_dtype, normalize_imagenet]
+# Validation during training (differs from the test-time preprocessing above).
+val_transform_list: [resize_short_256, center_crop_224, to_dtype, normalize_imagenet]

conf/model/image/moejepa.yaml

@@ -13,3 +13,6 @@ num_experts: 6
 top_k: 2
 router_temperature: 0.5
 out_classes: 3
+
+# Test-time preprocessing (official): inference, benchmarks and the end-of-training test.
+eval_transform_list: [vjepa2_processor]

conf/model/image/npr.yaml

@@ -5,3 +5,10 @@ defaults:
 model_type: npr
 num_classes: 2
 freeze_backbone: false
+
+# Test-time preprocessing (official): inference, benchmarks and the end-of-training test.
+eval_transform_list: [resize_256, to_dtype, normalize_imagenet]
+# Training augmentation.
+train_transform_list: [resize_256, random_crop_224, random_horizontal_flip, to_dtype, normalize_imagenet]
+# Validation during training (differs from the test-time preprocessing above).
+val_transform_list: [resize_256, center_crop_224, to_dtype, normalize_imagenet]

conf/model/image/omniaid.yaml

@@ -16,3 +16,6 @@ moe_lambda_gating_cls: 0.1
 dropout: 0.0
 gradient_checkpointing_enable: false
 is_hybrid: true
+
+# Test-time preprocessing (official): inference, benchmarks and the end-of-training test.
+eval_transform_list: [resize_336, to_dtype, normalize_clip]

conf/model/image/omniaid_genimage.yaml

@@ -16,3 +16,6 @@ moe_lambda_gating_cls: 0.1
 dropout: 0.0
 gradient_checkpointing_enable: false
 is_hybrid: true
+
+# Test-time preprocessing (official): inference, benchmarks and the end-of-training test.
+eval_transform_list: [resize_512, resize_336, to_dtype, normalize_clip]

conf/model/image/omniaid_v1.yaml

@@ -16,3 +16,6 @@ moe_lambda_gating_cls: 0.1
 dropout: 0.0
 gradient_checkpointing_enable: false
 is_hybrid: true
+
+# Test-time preprocessing (official): inference, benchmarks and the end-of-training test.
+eval_transform_list: [resize_512, resize_336, to_dtype, normalize_clip]

conf/model/image/pgc.yaml

@@ -19,3 +19,8 @@ label_smoothing: 0.1
 tau_rgb: 0.5
 tau_res: 0.5
 num_classes: 1
+
+# Test-time preprocessing (official): inference, benchmarks and the end-of-training test.
+eval_transform_list: [center_crop_224, to_dtype, normalize_imagenet]
+# Training augmentation.
+train_transform_list: [random_horizontal_flip, color_jitter_pgc, pad_random_crop_224, to_dtype, normalize_imagenet]

conf/model/image/safe.yaml

@@ -6,3 +6,8 @@ defaults:
 # it does NOT use backbone_name. model_type=safe is dispatched before the CLIP fallback.
 model_type: safe
 freeze_backbone: false
+
+# Test-time preprocessing (official): inference, benchmarks and the end-of-training test.
+eval_transform_list: [center_crop_256, to_dtype]
+# Training augmentation.
+train_transform_list: [random_crop_256_pad, random_horizontal_flip, random_rotation_180, color_jitter_safe, to_dtype, random_mask_safe]

conf/model/image/spai.yaml

@@ -15,4 +15,14 @@ use_sca: true
 patch_size: 224
 patch_stride: 224
 num_heads: 12
-attn_embed_dim: 1536
+attn_embed_dim: 1536
+
+# Test-time preprocessing (official): inference and benchmarks.
+eval_transform_list: [cap_long_side_1024, to_dtype]
+# Training augmentation. SPAI takes [0, 1] images; ImageNet normalization is applied inside the model.
+train_transform_list: [resize_short_256, gaussian_blur, jpeg_compression, random_crop_224, random_horizontal_flip, to_dtype]
+# Validation during training (differs from the test-time preprocessing above).
+val_transform_list: [resize_short_256, center_crop_224, to_dtype]
+# Batchable stand-in for the end-of-training test (the native-resolution eval list varies in size); inference and
+# benchmarks use the eval list.
+test_transform_list: [resize_short_256, center_crop_224, to_dtype]

conf/model/image/vib_net.yaml

@@ -13,3 +13,10 @@ vib_latent_dim: 256
 dropout: 0.5
 std_shift: 5.0
 freeze_backbone: true
+
+# Test-time preprocessing (official): inference, benchmarks and the end-of-training test.
+eval_transform_list: [center_crop_224, to_dtype, normalize_clip]
+# Training augmentation.
+train_transform_list: [blur_jpeg_cnndet, pad_random_crop_224, random_horizontal_flip, to_dtype, normalize_clip]
+# Validation during training (differs from the test-time preprocessing above).
+val_transform_list: [blur_jpeg_cnndet_val, center_crop_224, to_dtype, normalize_clip]

conf/model/image/vib_net_official.yaml

@@ -17,3 +17,10 @@ std_floor: 0.0
 clip_fp32: true
 # The paper's trade-off parameter is not reported; 1e-3 is the standard VIB value (Alemi et al.).
 vib_beta: 0.001
+
+# Test-time preprocessing (official): inference, benchmarks and the end-of-training test.
+eval_transform_list: [center_crop_224, to_dtype, normalize_clip]
+# Training augmentation.
+train_transform_list: [blur_jpeg_cnndet, pad_random_crop_224, random_horizontal_flip, to_dtype, normalize_clip]
+# Validation during training (differs from the test-time preprocessing above).
+val_transform_list: [blur_jpeg_cnndet_val, center_crop_224, to_dtype, normalize_clip]

dataset.py

@@ -1,6 +1,7 @@
 from torch.utils.data import Dataset
 from typing import Literal
 from pathlib import Path
+import functools
 import hashlib
 import json
 import os
@@ -22,6 +23,7 @@ import numpy as np
 import torch
 import torch.nn.functional as F
 from decord import VideoReader, cpu
+from omegaconf import OmegaConf
 from torch.utils.data import DataLoader
 from transformations import AIGITransformations
 from torchvision.io import decode_image, ImageReadMode
@@ -71,6 +73,75 @@ def _has_videos(directory: Path) -> bool:
     return directory.is_dir() and any(_iter_videos(directory))
 
 
+def _config_list(section, name):
+    """``section.<name>`` as a list, or None when the section or the key is absent or null."""
+    value = None if section is None else section.get(name, None)
+    return None if value is None else list(value)
+
+
+DATASET_CONF_DIR = Path(__file__).resolve().parent / "conf" / "dataset"
+
+
+@functools.lru_cache(maxsize=None)
+def _dataset_yaml_lists(name: str) -> tuple[dict[str, list | None], ...]:
+    """The ``train`` / ``val`` / ``eval`` transform lists shipped in the dataset yaml files of dataset ``name`` (matched
+    by file stem or ``name:``; several files may share a name), i.e. what DatasetConfig holds unless overridden."""
+    found = []
+    for path in sorted(DATASET_CONF_DIR.rglob("*.yaml")):
+        cfg = OmegaConf.load(path)
+        if name in (path.stem, cfg.get("name", None)):
+            found.append({key: _config_list(cfg, f"{key}_transform_list") for key in ("train", "val", "eval")})
+    return tuple(found)
+
+
+def _overridden(data, key: str, value: list) -> bool:
+    """Whether DatasetConfig's ``<key>_transform_list`` was overridden (differs from its dataset yaml). False when the
+    yaml file or the key cannot be found."""
+    shipped = [lists[key] for lists in _dataset_yaml_lists(str(data.get("name", ""))) if lists[key] is not None]
+    return bool(shipped) and value not in shipped
+
+
+def _first_list(*candidates):
+    """The first candidate list that is set (not None), else None. An explicit ``[]`` counts as set: an empty list in
+    the model config intentionally stops the fallback to the dataset config (that split gets no transform)."""
+    return next((c for c in candidates if c is not None), None)
+
+
+def resolve_transforms(config) -> tuple[AIGITransformations | None, AIGITransformations | None, AIGITransformations | None]:
+    """The ``(train, val, test)`` transforms of a run. Each comes from ``ModelConfig`` (the detector's own preprocessing)
+    and falls back to ``DatasetConfig`` for models whose config sets none. Precedence (first list set wins):
+
+    * train: model ``train_transform_list``, dataset ``train_transform_list``
+    * val:   model ``val_transform_list``, model ``eval_transform_list``, dataset ``val_transform_list``, dataset
+      ``eval_transform_list``
+    * test:  model ``test_transform_list`` (a batchable stand-in for native-resolution eval lists), model
+      ``eval_transform_list``, dataset ``eval_transform_list``
+
+    A DatasetConfig list that was overridden (differs from its dataset yaml, e.g. an old
+    ``DatasetConfig.eval_transform_list=`` override) but loses to a model list is reported.
+    An empty list gives None."""
+    model = getattr(config, "ModelConfig", None)
+    data = getattr(config, "DatasetConfig", None)
+    model_train = _config_list(model, "train_transform_list")
+    model_val = _first_list(_config_list(model, "val_transform_list"), _config_list(model, "eval_transform_list"))
+    model_test = _first_list(_config_list(model, "test_transform_list"), _config_list(model, "eval_transform_list"))
+    data_lists = {key: _config_list(data, f"{key}_transform_list") for key in ("train", "val", "eval")}
+    for key, model_list in (("train", model_train), ("val", model_val), ("eval", model_test)):
+        if (data_lists[key] is not None and model_list is not None and data_lists[key] != model_list
+                and _overridden(data, key, data_lists[key])):
+            print(f"[transforms] DatasetConfig.{key}_transform_list is ignored: the model config's list is used "
+                  f"({model_list})", flush=True)
+    train = _first_list(model_train, data_lists["train"])
+    val = _first_list(model_val, data_lists["val"], data_lists["eval"])
+    test = _first_list(model_test, data_lists["eval"])
+    # Val and test convert the decoded uint8 tensors to PIL first, so they run the exact inference code (benchmarks
+    # and the web UI feed PIL; tensor resizes differ by 1-2/255, and some eval steps take PIL only). Train stays on
+    # tensors for speed.
+    return (AIGITransformations(train) if train else None,
+            AIGITransformations(val, pil_input=True) if val else None,
+            AIGITransformations(test, pil_input=True) if test else None)
+
+
 class _PILFrames:
     """The part of decord's ``VideoReader`` API that ``sample_video_frames`` uses, for animated images decord cannot open
     (GIFs: decord fails with "broken metadata" on them). Every frame is composited to RGB at the canvas size, and the
@@ -1128,16 +1199,13 @@ class CNNDetectionDataset(Dataset):
 class CNNDetectionDatasetModule:
     def __init__(self, config):
         self.config = config
-        train_list = list(config.DatasetConfig.train_transform_list)
-        eval_list = list(config.DatasetConfig.eval_transform_list)
-        self.train_transform = AIGITransformations(train_list) if len(train_list) > 0 else None
-        self.eval_transform = AIGITransformations(eval_list) if len(eval_list) > 0 else None
+        self.train_transform, self.val_transform, self.test_transform = resolve_transforms(config)
         prefetch = getattr(config.DatasetConfig, "prefetch", False)
         classes = config.DatasetConfig.get("train_classes", None)   # ProGAN classes for train/val (None: all 20)
         classes = list(classes) if classes else None
         self.train_dataset = CNNDetectionDataset(config.DatasetConfig.root_dir, "train", self.train_transform, prefetch=prefetch, classes=classes)
-        self.val_dataset = CNNDetectionDataset(config.DatasetConfig.root_dir, "val", self.eval_transform, prefetch=prefetch, classes=classes)
-        self.test_dataset = CNNDetectionDataset(config.DatasetConfig.root_dir, "test", self.eval_transform, prefetch=prefetch)
+        self.val_dataset = CNNDetectionDataset(config.DatasetConfig.root_dir, "val", self.val_transform, prefetch=prefetch, classes=classes)
+        self.test_dataset = CNNDetectionDataset(config.DatasetConfig.root_dir, "test", self.test_transform, prefetch=prefetch)
 
     def train_dataloader(self):
         return DataLoader(self.train_dataset, batch_size=self.config.DatasetConfig.train_batch_size, shuffle=True, num_workers=self.config.DatasetConfig.num_workers, persistent_workers=self.config.DatasetConfig.persistent_workers, pin_memory=self.config.DatasetConfig.pin_memory)
@@ -1149,9 +1217,9 @@ class CNNDetectionDatasetModule:
         return DataLoader(self.test_dataset, batch_size=self.config.DatasetConfig.test_batch_size, shuffle=False, num_workers=self.config.DatasetConfig.num_workers, persistent_workers=self.config.DatasetConfig.persistent_workers, pin_memory=self.config.DatasetConfig.pin_memory)
 
 
-def _split_train_subset(dataset, per_class, val_per_class, eval_transform, seed=0):
+def _split_train_subset(dataset, per_class, val_per_class, val_transform, seed=0):
     """Keep a seeded ``per_class`` images per label of ``dataset`` for training and return a disjoint ``val_per_class``
-    per label as a validation copy with ``eval_transform``: for recipes trained on part of a train split, validated on
+    per label as a validation copy with ``val_transform``: for recipes trained on part of a train split, validated on
     held-out training images (GenImage's ``val`` alias is its test split, which must not select the model)."""
     rng = random.Random(seed)
     train_idx, val_idx = [], []
@@ -1167,30 +1235,27 @@ def _split_train_subset(dataset, per_class, val_per_class, eval_transform, seed=
         ds.images = [dataset.images[i] for i in keep]
         ds.labels = [dataset.labels[i] for i in keep]
         ds.folder_names = [dataset.folder_names[i] for i in keep]
-    val.transform = eval_transform
+    val.transform = val_transform
     return val
 
 
 class GenImageDatasetModule:
     def __init__(self, config):
         self.config = config
-        train_list = list(config.DatasetConfig.train_transform_list)
-        eval_list = list(config.DatasetConfig.eval_transform_list)
-        self.train_transform = AIGITransformations(train_list) if len(train_list) > 0 else None
-        self.eval_transform = AIGITransformations(eval_list) if len(eval_list) > 0 else None
+        self.train_transform, self.val_transform, self.test_transform = resolve_transforms(config)
         prefetch = getattr(config.DatasetConfig, "prefetch", False)
         source_url = config.DatasetConfig.get("source_url", GenImageDataset.google_drive_folder_url)
         GenImageDataset.google_drive_folder_url = source_url
         GenImageDataset.hf_repo_id = config.DatasetConfig.get("hf_repo_id", None)
         GenImageDataset.hf_subdir = config.DatasetConfig.get("hf_subdir", None)
         self.train_dataset = GenImageDataset(config.DatasetConfig.root_dir, "train", self.train_transform, prefetch=prefetch)
-        self.test_dataset = GenImageDataset(config.DatasetConfig.root_dir, "test", self.eval_transform, prefetch=prefetch)
+        self.test_dataset = GenImageDataset(config.DatasetConfig.root_dir, "test", self.test_transform, prefetch=prefetch)
         per_class = config.DatasetConfig.get("train_per_class", None)   # e.g. VIB-Net: 16k real + 16k SD v1.4
         if per_class:
             self.val_dataset = _split_train_subset(self.train_dataset, int(per_class),
-                                                   int(config.DatasetConfig.get("val_per_class", 1000)), self.eval_transform)
+                                                   int(config.DatasetConfig.get("val_per_class", 1000)), self.val_transform)
         else:
-            self.val_dataset = GenImageDataset(config.DatasetConfig.root_dir, "val", self.eval_transform, prefetch=prefetch)
+            self.val_dataset = GenImageDataset(config.DatasetConfig.root_dir, "val", self.val_transform, prefetch=prefetch)
 
     def train_dataloader(self):
         return DataLoader(self.train_dataset, batch_size=self.config.DatasetConfig.train_batch_size, shuffle=True, num_workers=self.config.DatasetConfig.num_workers, persistent_workers=self.config.DatasetConfig.persistent_workers, pin_memory=self.config.DatasetConfig.pin_memory)
@@ -1757,14 +1822,11 @@ class UniversialFakeDetectionDataset(Dataset):
 class AIGIBenchDatasetModule:
     def __init__(self, config):
         self.config = config
-        train_list = list(config.DatasetConfig.train_transform_list)
-        eval_list = list(config.DatasetConfig.eval_transform_list)
-        self.train_transform = AIGITransformations(train_list) if len(train_list) > 0 else None
-        self.eval_transform = AIGITransformations(eval_list) if len(eval_list) > 0 else None
+        self.train_transform, self.val_transform, self.test_transform = resolve_transforms(config)
         prefetch = getattr(config.DatasetConfig, "prefetch", False)
         self.train_dataset = AIGIBenchDataset(config.DatasetConfig.root_dir, "train", config.DatasetConfig.setting, self.train_transform, prefetch=prefetch)
-        self.val_dataset = AIGIBenchDataset(config.DatasetConfig.root_dir, "val", config.DatasetConfig.setting, self.eval_transform, prefetch=prefetch)
-        self.test_dataset = AIGIBenchDataset(config.DatasetConfig.root_dir, "test", config.DatasetConfig.setting, self.eval_transform, prefetch=prefetch)
+        self.val_dataset = AIGIBenchDataset(config.DatasetConfig.root_dir, "val", config.DatasetConfig.setting, self.val_transform, prefetch=prefetch)
+        self.test_dataset = AIGIBenchDataset(config.DatasetConfig.root_dir, "test", config.DatasetConfig.setting, self.test_transform, prefetch=prefetch)
 
     def train_dataloader(self):
         return DataLoader(self.train_dataset, batch_size=self.config.DatasetConfig.train_batch_size, shuffle=True, num_workers=self.config.DatasetConfig.num_workers, persistent_workers=self.config.DatasetConfig.persistent_workers, pin_memory=self.config.DatasetConfig.pin_memory)
@@ -1779,11 +1841,10 @@ class AIGIBenchDatasetModule:
 class DiTFakeDatasetModule:
     def __init__(self, config):
         self.config = config
-        eval_list = list(config.DatasetConfig.eval_transform_list)
-        self.eval_transform = AIGITransformations(eval_list) if len(eval_list) > 0 else None
+        self.test_transform = resolve_transforms(config)[2]
         prefetch = getattr(config.DatasetConfig, "prefetch", False)
         repo_id = config.DatasetConfig.get("repo_id", DiTFakeDataset.repo_id)
-        self.test_dataset = DiTFakeDataset(config.DatasetConfig.root_dir, "test", self.eval_transform, prefetch=prefetch, repo_id=repo_id)
+        self.test_dataset = DiTFakeDataset(config.DatasetConfig.root_dir, "test", self.test_transform, prefetch=prefetch, repo_id=repo_id)
 
     def test_dataloader(self):
         return DataLoader(self.test_dataset, batch_size=self.config.DatasetConfig.test_batch_size, shuffle=False, num_workers=self.config.DatasetConfig.num_workers, persistent_workers=self.config.DatasetConfig.persistent_workers, pin_memory=self.config.DatasetConfig.pin_memory)
@@ -1792,14 +1853,13 @@ class DiTFakeDatasetModule:
 class FreqNetDetectionDatasetModule:
     def __init__(self, config):
         self.config = config
-        eval_list = list(config.DatasetConfig.eval_transform_list)
-        self.eval_transform = AIGITransformations(eval_list) if len(eval_list) > 0 else None
+        self.test_transform = resolve_transforms(config)[2]
         prefetch = getattr(config.DatasetConfig, "prefetch", False)
         source_url = config.DatasetConfig.get("source_url", FreqNetDetectionDataset.google_drive_folder_url)
         self.test_dataset = FreqNetDetectionDataset(
             config.DatasetConfig.root_dir,
             "test",
-            self.eval_transform,
+            self.test_transform,
             prefetch=prefetch,
             source_url=source_url,
         )
@@ -1817,14 +1877,13 @@ class FreqNetDetectionDatasetModule:
 class UniversialFakeDetectionDatasetModule:
     def __init__(self, config):
         self.config = config
-        eval_list = list(config.DatasetConfig.eval_transform_list)
-        self.eval_transform = AIGITransformations(eval_list) if len(eval_list) > 0 else None
+        self.test_transform = resolve_transforms(config)[2]
         prefetch = getattr(config.DatasetConfig, "prefetch", False)
         source_url = config.DatasetConfig.get("source_url", UniversialFakeDetectionDataset.source_url)
         self.test_dataset = UniversialFakeDetectionDataset(
             config.DatasetConfig.root_dir,
             "test",
-            self.eval_transform,
+            self.test_transform,
             prefetch=prefetch,
             source_url=source_url,
         )
@@ -1842,8 +1901,7 @@ class UniversialFakeDetectionDatasetModule:
 class CoSpyDatasetModule:
     def __init__(self, config):
         self.config = config
-        eval_list = list(config.DatasetConfig.eval_transform_list)
-        self.eval_transform = AIGITransformations(eval_list) if len(eval_list) > 0 else None
+        self.test_transform = resolve_transforms(config)[2]
         prefetch = getattr(config.DatasetConfig, "prefetch", False)
         source_datasets = config.DatasetConfig.get("source_datasets", None)
         generator_models = config.DatasetConfig.get("generator_models", None)
@@ -1854,7 +1912,7 @@ class CoSpyDatasetModule:
         self.test_dataset = CoSpyDataset(
             config.DatasetConfig.root_dir,
             "test",
-            self.eval_transform,
+            self.test_transform,
             prefetch=prefetch,
             source_datasets=list(source_datasets) if source_datasets else None,
             generator_models=list(generator_models) if generator_models else None,
@@ -2015,10 +2073,7 @@ class VideoFolderDatasetModule:
     def __init__(self, config):
         self.config = config
         cfg = config.DatasetConfig
-        train_list = list(cfg.get("train_transform_list", []))
-        eval_list = list(cfg.get("eval_transform_list", []))
-        self.train_transform = AIGITransformations(train_list) if len(train_list) > 0 else None
-        self.eval_transform = AIGITransformations(eval_list) if len(eval_list) > 0 else None
+        self.train_transform, self.val_transform, self.test_transform = resolve_transforms(config)
         prefetch = bool(cfg.get("prefetch", False))
         common = dict(
             num_frames=cfg.get("num_frames", 16),
@@ -2030,8 +2085,8 @@ class VideoFolderDatasetModule:
             resize_interp=cfg.get("resize_interp", "bilinear"),
         )
         self.train_dataset = VideoFolderDataset(cfg.root_dir, "train", self.train_transform, prefetch=prefetch, **common)
-        self.val_dataset = VideoFolderDataset(cfg.root_dir, "val", self.eval_transform, prefetch=prefetch, **common)
-        self.test_dataset = VideoFolderDataset(cfg.root_dir, "test", self.eval_transform, prefetch=prefetch, **common)
+        self.val_dataset = VideoFolderDataset(cfg.root_dir, "val", self.val_transform, prefetch=prefetch, **common)
+        self.test_dataset = VideoFolderDataset(cfg.root_dir, "test", self.test_transform, prefetch=prefetch, **common)
 
     def train_dataloader(self):
         return DataLoader(self.train_dataset, batch_size=self.config.DatasetConfig.train_batch_size, shuffle=True, num_workers=self.config.DatasetConfig.num_workers, persistent_workers=self.config.DatasetConfig.persistent_workers, pin_memory=self.config.DatasetConfig.pin_memory)
@@ -2148,10 +2203,9 @@ class _TestOnlyVideoModule:
     def __init__(self, config):
         self.config = config
         cfg = config.DatasetConfig
-        eval_list = list(cfg.get("eval_transform_list", []))
-        self.eval_transform = AIGITransformations(eval_list) if len(eval_list) > 0 else None
+        self.test_transform = resolve_transforms(config)[2]
         self.test_dataset = self.DATASET_CLASS(
-            cfg.root_dir, "test", self.eval_transform, prefetch=bool(cfg.get("prefetch", False)),
+            cfg.root_dir, "test", self.test_transform, prefetch=bool(cfg.get("prefetch", False)),
             num_frames=cfg.get("num_frames", 16), fps=cfg.get("fps", None),
             window_seconds=cfg.get("window_seconds", 2.0), frame_size=cfg.get("frame_size", 224),
             hf_repo_id=cfg.get("hf_repo_id", self.DATASET_CLASS.hf_repo_id),
@@ -2922,10 +2976,9 @@ class _TestOnlyImageModule:
     def __init__(self, config):
         self.config = config
         cfg = config.DatasetConfig
-        eval_list = list(cfg.get("eval_transform_list", []))
-        self.eval_transform = AIGITransformations(eval_list) if len(eval_list) > 0 else None
+        self.train_transform, self.val_transform, self.test_transform = resolve_transforms(config)
         self.test_dataset = self.DATASET_CLASS(
-            cfg.root_dir, "test", self.eval_transform, prefetch=bool(cfg.get("prefetch", False)))
+            cfg.root_dir, "test", self.test_transform, prefetch=bool(cfg.get("prefetch", False)))
 
     def train_dataloader(self):
         return None
@@ -2993,20 +3046,18 @@ class SIDSetDatasetModule(_TestOnlyImageModule):
 
 
 class ARForensicsDatasetModule(_TestOnlyImageModule):
-    """The test split for benchmarking; with a ``train_transform_list`` in the config also the train and val splits
-    (D3QE's training data), validated with ``val_transform_list`` (default: ``eval_transform_list``)."""
+    """The test split for benchmarking; with ``DatasetConfig.with_train_splits`` (default false) also the train and val
+    splits (D3QE's training data, 39 GB), with the run's train and val transforms (see ``resolve_transforms``)."""
     DATASET_CLASS = ARForensicsDataset
 
     def __init__(self, config):
         super().__init__(config)
         cfg = config.DatasetConfig
-        train_list = list(cfg.get("train_transform_list", []))
         self.train_dataset = self.val_dataset = None
-        if train_list:
+        if bool(cfg.get("with_train_splits", False)):
             prefetch = bool(cfg.get("prefetch", False))
-            val_list = list(cfg.get("val_transform_list", cfg.get("eval_transform_list", [])))
-            self.train_dataset = ARForensicsDataset(cfg.root_dir, "train", AIGITransformations(train_list), prefetch=prefetch)
-            self.val_dataset = ARForensicsDataset(cfg.root_dir, "val", AIGITransformations(val_list), prefetch=prefetch)
+            self.train_dataset = ARForensicsDataset(cfg.root_dir, "train", self.train_transform, prefetch=prefetch)
+            self.val_dataset = ARForensicsDataset(cfg.root_dir, "val", self.val_transform, prefetch=prefetch)
 
     def _loader(self, dataset, batch_size, shuffle):
         cfg = self.config.DatasetConfig

docs/ADD_DETECTOR.md

@@ -19,13 +19,28 @@ for the maintainers and stop.
    - Imports + helper classes at module top-level (repo rule: no nested defs/imports).
    - Add `models/<modality>/<k>/__init__.py` and a `README.md` (see structure below).
 2. **`conf/model/image/<k>.yaml`** (or `video/`): `defaults: [/model/default, _self_]`, then `model_type: <k>`
-   plus any model knobs. Add `conf/dataset/...` / `conf/trainer/...` only if a new recipe is needed.
+   plus any model knobs, and the model's preprocessing as named transform lists:
+   - `eval_transform_list` (required for image models): the **official** test-time preprocessing, used for
+     inference, benchmarks and the end-of-training test;
+   - `train_transform_list`: the training augmentation;
+   - `val_transform_list` (optional): validation during training, when it differs from the eval list;
+   - `test_transform_list` (optional): replaces the eval list for the end-of-training test only, e.g. a batchable
+     stand-in for SPAI's native-resolution eval, or AIDE's five views with the long side capped at 1024 to bound
+     dataloader-worker memory; benchmarks and inference still use `eval_transform_list`.
+
+   Each name is a step built by `AIGITransformations` in `transformations.py`; add new step names there.
+   The model's lists take precedence over the dataset's: the `train/eval/val_transform_list` of a
+   `conf/dataset/...` config are fallbacks, used only for models whose config sets none, and a warning is printed
+   when a dataset list is shadowed. Validation and test pipelines run on PIL images like inference, so an
+   end-of-training test with `eval_transform_list` preprocesses exactly as the benchmarks do.
+   Video models are out of scope for now: their preprocessing is the registry's video settings plus the dataset
+   lists. Add `conf/dataset/...` / `conf/trainer/...` only if a new recipe is needed.
 3. **Dispatch** — add a branch in `trainer.py` `_build_model` (the `if model_type == "<k>": return SynthScope<Name>Model(config)` chain, ~line 69+). The interface lazy-imports by `model_type` in `interface/backend/engine.py` — mirror it if needed.
 4. **Interface registry** — `interface/backend/registry.py` `_add(ModelSpec(...))`:
    - `key`, `name`, `paper`, `modality` (`image`|`video`), `overrides=["model@ModelConfig=image/<k>"]`,
    - `predict_kind`: `ce` (logits→`softmax[:,1]`), `bce` (`sigmoid`), `bce_npr`, `vib`, or `video`,
    - `checkpoint="<k>.pth"`, `ckpt_kind`: `synthscope` (our trained weights, strict load) **or** `official_<k>` + a `remap=remap_<k>` function (rename official keys → our module names) for the authors' released weights,
-   - `transform`: the eval preprocessing — match the **official** eval exactly (resize vs crop, norm vs none). Add a `tf_*` helper if needed. (Getting this wrong silently tanks results — see SAFE: a resize destroyed the high-freq signal.)
+   - `transform=model_transform("image/<k>")`: builds the eval preprocessing from the model config's `eval_transform_list` — match the **official** eval exactly there (resize vs crop, norm vs none). (Getting this wrong silently tanks results — see SAFE: a resize destroyed the high-freq signal.)
    - `weights`: `"official"` | `"synthscope_trained"` | `"training_free"` (shown in the web UI badge).
 5. **Per-model `README.md`** — mirror `models/image/pgc/README.md`: short method explanation + official-repo/paper links, the pipeline, "SynthScope adaptations", and a results table in the **Paper / SynthScope_official / SynthScope_train** schema.
 

docs/BENCHMARKS.md

@@ -222,7 +222,8 @@ the GPU). Models are downloaded once into the Hugging Face cache (tens of GB eac
 
 - **A detector**: follow [`docs/ADD_DETECTOR.md`](ADD_DETECTOR.md); then add it to the Leaderboard as in section 3.
 - **A dataset**: add `conf/dataset/image/<name>.yaml` with the source (`hf_repo_id`, `source_url`, ...), make it follow the
-  layout in section 2, and add a profile to `bench_eval.py` if its grouping is new.
+  layout in section 2, and add a profile to `bench_eval.py` if its grouping is new. Its transform lists are fallbacks,
+  used only for models whose config (`conf/model/...`) sets no lists of its own.
 - **A generator**: add a function `call(image_png | None, prompt, size=None) -> png bytes` and one entry in `GENERATORS` in
   `interface/backend/generators.py`. `image_png=None` means "create from the prompt alone". Then run section 4 with
   `--generator <your key>`.

docs/CAPABILITIES.md

@@ -72,10 +72,12 @@ To wire it in: `conf/model/<modality>/<key>.yaml` (`model_type: <key>`), a branc
   with groups `model/`, `dataset/`, `trainer/`. Multi-GPU via 🤗 `accelerate` (`accelerate_config.yaml`).
 - **`dataset.py`** — image/video dataset loaders; `_decode_rgb` feeds uint8 `[3,H,W]` tensors;
   `sample_video_frames(..., edge_crop=)` for video.
-- **`transformations.py`** — composable named transforms / augmentations: `resize_224`,
-  `resize_short_{256,384,448}`, `center_crop_{224,256,384,448}`, `random_crop_*`, `pad_random_crop_224`
+- **`transformations.py`** — composable named transforms / augmentations: `resize_{224,256,336,512}`,
+  `resize_short_{256,384,448}`, `center_crop_{224,256,336,384,448}`, `random_crop_*`, `pad_random_crop_224`
   (PGC), `gaussian_blur`, `jpeg_compression`, `random_horizontal/vertical_flip`, `random_rotation_180`,
-  `color_jitter_safe`, `to_tensor`/`to_dtype`. **Eval-transform fidelity is critical** — artifact/
+  `color_jitter_safe`, `to_tensor`/`to_dtype`. Each model config names its pipelines (`eval_transform_list`,
+  `train_transform_list`, optional `val_transform_list` / `test_transform_list`); the web registry builds
+  `ModelSpec.transform` from `eval_transform_list`. **Eval-transform fidelity is critical** — artifact/
   low-level detectors (SAFE/AIDE/SPAI/PGC/NPR) are wrecked by a wrong resize; match the official eval
   exactly (see `repro/investigate/pgc_gap_investigation.md` and the SAFE crop-not-resize lesson).
 - **`metrics.py`** — torchmetrics binary `Accuracy` (real/fake), `AveragePrecision` (AP),
@@ -170,6 +172,6 @@ New detectors are integrated **on a `detector/<key>` branch and pushed for revie
 
 1. Confirm it passes both rules (public repo + strong results). Read `ADD_DETECTOR.md`.
 2. `git checkout -b detector/<key>`; add the 5 files (model, conf, trainer dispatch, registry ModelSpec, README) + smoke test.
-3. **Match the official eval transform exactly** in the `ModelSpec` (resize vs crop, norm) — this is the #1 silent-failure source.
+3. **Match the official eval transform exactly** in the model config's `eval_transform_list` (resize vs crop, norm) — this is the #1 silent-failure source.
 4. Reproduce on the paper's benchmark with official weights via `bench_eval.py --ckpt`; fix `remap_<k>` for key mismatches; record per-gen AP/AUROC in the Paper/SynthScope_official/SynthScope_train schema.
 5. (Optional) add an interpretability map. Push the branch; do **not** merge to `main`.

experiments/image/adapted_dinov2_vitl14.sh

@@ -6,9 +6,7 @@ export CUDA_VISIBLE_DEVICES=1,2,3,4
 export OMP_NUM_THREADS=1
 
 accelerate launch --config_file accelerate_config.yaml --num_processes 4 main.py \
+    model@ModelConfig=image/adapted_dino \
     ModelConfig.bottleneck_dim=64 \
-    ModelConfig.model_type=dino \
     ModelConfig.use_adapter=true \
-    DatasetConfig.train_transform_list=[resize_short_256,gaussian_blur,jpeg_compression,random_crop_224,random_horizontal_flip,to_dtype,normalize_dinov2] \
-    DatasetConfig.eval_transform_list=[resize_short_256,center_crop_224,to_dtype,normalize_dinov2] \
     ModelConfig.backbone_name=dinov2_vitl14

experiments/image/aide.sh

@@ -5,15 +5,16 @@ export TORCH_HOME=/nvmestore/ssalehi/.cache/torch
 export CUDA_VISIBLE_DEVICES=1,2
 export OMP_NUM_THREADS=1
 
+# Five native-resolution views per image (aide.yaml lists): batch 8 and 5 workers bound memory, as in the run behind
+# the README's SynthScope_train checkpoint (repro/retrain_aide_native_v2.sbatch).
 /home/ssalehi/miniconda3/bin/conda run --no-capture-output -n SynthScope accelerate launch --config_file accelerate_config.yaml --num_processes 2 main.py \
     trainer@TrainerConfig=image/aide \
     model@ModelConfig=image/aide \
     dataset@DatasetConfig=image/genimage \
-    DatasetConfig.train_batch_size=16 \
+    DatasetConfig.train_batch_size=8 \
+    DatasetConfig.num_workers=5 \
     DatasetConfig.val_batch_size=16 \
     DatasetConfig.test_batch_size=16 \
-    DatasetConfig.train_transform_list=[resize_short_256,gaussian_blur,jpeg_compression,random_crop_256,random_horizontal_flip,to_dtype] \
-    DatasetConfig.eval_transform_list=[resize_short_256,center_crop_256,to_dtype] \
     logger.name=aide \
     logger.mode=online \
     logger.tags=[SynthScope,AIDE,genimage]

experiments/image/clip_vitl14.sh

@@ -9,9 +9,7 @@ export OMP_NUM_THREADS=1
 # accelerate launch --config_file accelerate_config.yaml --num_processes 2 main.py
 
 accelerate launch --config_file accelerate_config.yaml --num_processes 4 main.py \
+    model@ModelConfig=image/clip \
     ModelConfig.bottleneck_dim=64 \
-    ModelConfig.model_type=clip \
     ModelConfig.use_adapter=false \
-    DatasetConfig.train_transform_list=[resize_short_256,gaussian_blur,jpeg_compression,random_crop_224,random_horizontal_flip,to_dtype,normalize_clip] \
-    DatasetConfig.eval_transform_list=[resize_short_256,center_crop_224,to_dtype,normalize_clip] \
     ModelConfig.backbone_name=CLIP:ViT-L/14

experiments/image/co_spy.sh

@@ -11,8 +11,6 @@ export OMP_NUM_THREADS=1
     DatasetConfig.train_batch_size=16 \
     DatasetConfig.val_batch_size=16 \
     DatasetConfig.test_batch_size=16 \
-    DatasetConfig.train_transform_list=[resize_short_384,gaussian_blur,jpeg_compression,random_crop_384,random_horizontal_flip,to_dtype] \
-    DatasetConfig.eval_transform_list=[resize_short_384,center_crop_384,to_dtype] \
     logger.name=co_spy \
     logger.mode=online \
     logger.tags=[SynthScope,CoSpy,genimage]

experiments/image/d3qe.sh

@@ -22,11 +22,9 @@ SAVE=${SAVE:-/nvmestore/ssalehi/SynthScope/models/d3qe}
     model@ModelConfig=image/d3qe \
     dataset@DatasetConfig=image/arforensics \
     DatasetConfig.root_dir=$DATA \
+    DatasetConfig.with_train_splits=true \
     DatasetConfig.train_batch_size=32 \
     DatasetConfig.val_batch_size=64 \
-    "+DatasetConfig.train_transform_list=[resize_short_256,blur_jpeg_cnndet,random_crop_256,random_horizontal_flip,to_dtype]" \
-    "+DatasetConfig.val_transform_list=[resize_short_256,blur_jpeg_cnndet_val,center_crop_256,to_dtype]" \
-    "DatasetConfig.eval_transform_list=[resize_short_256,center_crop_256,to_dtype]" \
     TrainerConfig.save_path=$SAVE \
     "metrics=[real_accuracy,fake_accuracy]" \
     logger.name=d3qe \

experiments/image/dinov2_vitl14.sh

@@ -9,9 +9,7 @@ export OMP_NUM_THREADS=1
 # accelerate launch --config_file accelerate_config.yaml --num_processes 2 main.py
 
 accelerate launch --config_file accelerate_config.yaml --num_processes 4 main.py \
+    model@ModelConfig=image/dinov2 \
     ModelConfig.bottleneck_dim=64 \
-    ModelConfig.model_type=dinov2 \
     ModelConfig.use_adapter=false \
-    DatasetConfig.train_transform_list=[resize_short_256,gaussian_blur,jpeg_compression,random_crop_224,random_horizontal_flip,to_dtype,normalize_dinov2] \
-    DatasetConfig.eval_transform_list=[resize_short_256,center_crop_224,to_dtype,normalize_dinov2] \
     ModelConfig.backbone_name=dinov2_vitl14

experiments/image/dinov3_vitl14.sh

@@ -9,9 +9,7 @@ export OMP_NUM_THREADS=1
 # accelerate launch --config_file accelerate_config.yaml --num_processes 2 main.py
 
 accelerate launch --config_file accelerate_config.yaml --num_processes 2 main.py \
+    model@ModelConfig=image/dinov3 \
     ModelConfig.bottleneck_dim=64 \
-    ModelConfig.model_type=dinov3 \
     ModelConfig.use_adapter=false \
-    DatasetConfig.train_transform_list=[resize_short_256,gaussian_blur,jpeg_compression,random_crop_256,random_horizontal_flip,to_dtype,normalize_dinov3] \
-    DatasetConfig.eval_transform_list=[resize_short_256,center_crop_256,to_dtype,normalize_dinov3] \
     ModelConfig.backbone_name=dinov3_vitl16

experiments/image/fat_former.sh

@@ -5,10 +5,6 @@ export TORCH_HOME=/nvmestore/ssalehi/.cache/torch
 export CUDA_VISIBLE_DEVICES=1,2
 export OMP_NUM_THREADS=1
 
-# Official FatFormer (Michel-liu/FatFormer, utils/dataset.py) normalizes with **ImageNet**
-# mean/std -- NOT CLIP stats -- despite the CLIP ViT-L/14 backbone. `normalize_dinov2` is the
-# ImageNet Normalize in this repo, so we use it here to match the official preprocessing (and the
-# deployed official-weights eval, which reproduces 98.39 acc / 99.70 mAP with ImageNet norm).
 /home/ssalehi/miniconda3/bin/conda run --no-capture-output -n SynthScope accelerate launch --config_file accelerate_config.yaml --num_processes 2 main.py \
     trainer@TrainerConfig=image/fat_former \
     model@ModelConfig=image/fat_former \
@@ -16,8 +12,6 @@ export OMP_NUM_THREADS=1
     DatasetConfig.train_batch_size=32 \
     DatasetConfig.val_batch_size=32 \
     DatasetConfig.test_batch_size=32 \
-    DatasetConfig.train_transform_list=[resize_short_256,gaussian_blur,jpeg_compression,random_crop_224,random_horizontal_flip,to_dtype,normalize_dinov2] \
-    DatasetConfig.eval_transform_list=[resize_short_256,center_crop_224,to_dtype,normalize_dinov2] \
     logger.name=fat_former \
     logger.mode=online \
     logger.tags=[SynthScope,FatFormer,aigibench]

experiments/image/npr.sh

@@ -25,8 +25,6 @@ SAVE=${SAVE:-/nvmestore/ssalehi/SynthScope/models/npr}
     "+DatasetConfig.train_classes=[car,cat,chair,horse]" \
     DatasetConfig.train_batch_size=32 \
     DatasetConfig.val_batch_size=64 \
-    "DatasetConfig.train_transform_list=[resize_256,random_crop_224,random_horizontal_flip,to_dtype,normalize_dinov2]" \
-    "DatasetConfig.eval_transform_list=[resize_256,center_crop_224,to_dtype,normalize_dinov2]" \
     TrainerConfig.save_path=$SAVE \
     "metrics=[real_accuracy,fake_accuracy]" \
     logger.name=npr \

experiments/image/pgc.sh

@@ -25,8 +25,6 @@ SAVE=${SAVE:-/nvmestore/ssalehi/SynthScope/models/pgc}
     DatasetConfig.root_dir=$DATA \
     DatasetConfig.train_batch_size=32 \
     DatasetConfig.val_batch_size=64 \
-    "DatasetConfig.train_transform_list=[random_horizontal_flip,color_jitter_pgc,pad_random_crop_224,to_dtype,normalize_dinov2]" \
-    "DatasetConfig.eval_transform_list=[center_crop_224,to_dtype,normalize_dinov2]" \
     TrainerConfig.save_path=$SAVE \
     "metrics=[real_accuracy,fake_accuracy]" \
     logger.name=pgc \

experiments/image/safe.sh

@@ -7,14 +7,12 @@ export OMP_NUM_THREADS=1
 
 /home/ssalehi/miniconda3/bin/conda run --no-capture-output -n SynthScope accelerate launch --config_file accelerate_config.yaml --num_processes 2 main.py \
     trainer@TrainerConfig=image/safe \
+    model@ModelConfig=image/safe \
     dataset@DatasetConfig=image/aigibench \
-    ModelConfig.model_type=safe \
     ModelConfig.freeze_backbone=false \
     DatasetConfig.train_batch_size=64 \
     DatasetConfig.val_batch_size=64 \
     DatasetConfig.test_batch_size=64 \
-    DatasetConfig.train_transform_list=[random_crop_256_pad,random_horizontal_flip,random_rotation_180,color_jitter_safe,to_dtype,random_mask_safe] \
-    DatasetConfig.eval_transform_list=[center_crop_256,to_dtype] \
     TrainerConfig.epochs=100 \
     TrainerConfig.lr=0.0005 \
     TrainerConfig.weight_decay=0.05 \

experiments/image/spai.sh

@@ -5,15 +5,12 @@ export TORCH_HOME=/nvmestore/ssalehi/.cache/torch
 export CUDA_VISIBLE_DEVICES=1,2
 export OMP_NUM_THREADS=1
 
-# SPAI expects [0,1] images (to_dtype only); ImageNet normalization is applied inside the model.
 /home/ssalehi/miniconda3/bin/conda run --no-capture-output -n SynthScope accelerate launch --config_file accelerate_config.yaml --num_processes 2 main.py \
     trainer@TrainerConfig=image/spai \
     model@ModelConfig=image/spai \
     DatasetConfig.train_batch_size=32 \
     DatasetConfig.val_batch_size=32 \
     DatasetConfig.test_batch_size=32 \
-    DatasetConfig.train_transform_list=[resize_short_256,gaussian_blur,jpeg_compression,random_crop_224,random_horizontal_flip,to_dtype] \
-    DatasetConfig.eval_transform_list=[resize_short_256,center_crop_224,to_dtype] \
     logger.name=spai \
     logger.mode=online \
     logger.tags=[SynthScope,SPAI,genimage]

experiments/image/vib_net.sh

@@ -31,8 +31,6 @@ SAVE=${SAVE:-/nvmestore/ssalehi/SynthScope/models/vib_net}
     DatasetConfig.prefetch=false \
     DatasetConfig.train_batch_size=256 \
     DatasetConfig.val_batch_size=256 \
-    "DatasetConfig.train_transform_list=[blur_jpeg_cnndet,pad_random_crop_224,random_horizontal_flip,to_dtype,normalize_clip]" \
-    "DatasetConfig.eval_transform_list=[blur_jpeg_cnndet_val,center_crop_224,to_dtype,normalize_clip]" \
     TrainerConfig.save_path=$SAVE \
     "metrics=[real_accuracy,fake_accuracy]" \
     logger.name=vib_net \

experiments/video/d3.sh

@@ -8,7 +8,7 @@ export OMP_NUM_THREADS=1
 # D3 is training-free: a frozen CLIP ViT-B/16 extracts per-frame features, and the per-video
 # second-order std becomes the detection score. Frames are decoded to 224x224 in [0,1] and
 # normalized by the dataset transform pipeline (normalize_clip here, matched to the CLIP
-# backbone -- switch to normalize_dinov2 if you set a DINOv2/ResNet backbone). AP/AUROC are the
+# backbone -- switch to normalize_imagenet if you set a DINOv2/ResNet backbone). AP/AUROC are the
 # meaningful metrics. The video benchmark must be present under DatasetConfig.root_dir;
 # this is a template (data download is out of scope).
 /home/ssalehi/miniconda3/bin/conda run --no-capture-output -n SynthScope accelerate launch --config_file accelerate_config.yaml --num_processes 1 main.py \

experiments/video/restrav.sh

@@ -10,7 +10,7 @@ export OMP_NUM_THREADS=1
 # 224x224 over a CENTER 2 s window (24 frames, BICUBIC) and fed to DINOv2 as RAW [0,1] with
 # *no* ImageNet normalization -- this matches the official ReStraV repo verbatim
 # (dinov2_features.preprocess = frames/255 + BICUBIC resize, no Normalize) and the deployed
-# serving spec (registry video_norm = identity). Do NOT add normalize_dinov2 here: the
+# serving spec (registry video_norm = identity). Do NOT add normalize_imagenet here: the
 # detector is served raw [0,1], so normalizing only at train time creates a train/serve
 # mismatch that collapses cross-generator transfer. Official optimizer is plain Adam (no
 # weight decay), 10 epochs -- matched below. The video benchmark must be present under

experiments/video/stall.sh

@@ -8,7 +8,7 @@ export OMP_NUM_THREADS=1
 # STALL (Ben Hayun et al., CVPR'26) is training-free: a frozen DINOv3 ViT-L/16 extracts
 # per-frame features, which are scored against a VATEX real-video calibration via two whitened
 # isotropic-Gaussian likelihood branches (spatial + temporal). Frames are decoded square at 224
-# in [0,1] and normalized with ImageNet stats -- normalize_dinov2 here, because the official
+# in [0,1] and normalized with ImageNet stats -- normalize_imagenet here, because the official
 # DINOv3 transform uses ImageNet mean/std (NOT normalize_dinov3). AP/AUROC are the meaningful
 # metrics. The video benchmark must be present under DatasetConfig.root_dir.
 #
@@ -24,8 +24,8 @@ export DINO_V3_WEIGHTS=${DINO_V3_WEIGHTS:-/hddstore/ssalehi/SynthScope/dinov3_ch
     DatasetConfig.test_batch_size=8 \
     DatasetConfig.num_frames=16 \
     DatasetConfig.frame_size=224 \
-    DatasetConfig.train_transform_list=[normalize_dinov2] \
-    DatasetConfig.eval_transform_list=[normalize_dinov2] \
+    DatasetConfig.train_transform_list=[normalize_imagenet] \
+    DatasetConfig.eval_transform_list=[normalize_imagenet] \
     metrics=[real_accuracy,fake_accuracy,AP,AUC] \
     logger.name=stall \
     logger.mode=online \

interface/backend/engine.py

@@ -13,7 +13,6 @@ from collections import OrderedDict
 
 import numpy as np
 import torch
-import torchvision.transforms as T
 from PIL import Image
 from safetensors.torch import load_file as load_safetensors
 
@@ -61,14 +60,12 @@ def _overlay_to_png_b64(sal: torch.Tensor, base: Image.Image, out_size: int = 28
 
 
 def _geometric_base(spec, pil: Image.Image) -> Image.Image:
-    """The model's input region in RGB (apply only the Resize/CenterCrop steps of the eval
-    transform, skipping ToTensor/Normalize) so the overlay aligns with the saliency. Custom
+    """The model's input region in RGB (apply only the resize/center-crop steps of the eval
+    transform, skipping to_dtype/normalize) so the overlay aligns with the saliency. Custom
     transforms (AIDE/SPAI native-res) fall back to the native image."""
-    import torchvision.transforms as T
     base = pil.convert("RGB")
-    for t in getattr(spec.transform, "transforms", []) or []:
-        if isinstance(t, (T.Resize, T.CenterCrop)):
-            base = t(base)
+    for t in spec.transform.geometric_steps():
+        base = t(base)
     return base
 
 
@@ -329,7 +326,10 @@ class Engine:
             elif kind == "aide_dct":       # AIDE: native-res DCT per-window energy (patch selection)
                 if pil is None:
                     return None
-                sal = spec.transform.dct_energy_map(pil)       # [nH,Wn]
+                five_view = next((t for t in spec.transform.transforms if hasattr(t, "dct_energy_map")), None)
+                if five_view is None:
+                    return None
+                sal = five_view.dct_energy_map(pil)            # [nH,Wn]
             elif kind == "spai_patch":     # SPAI: per-patch spectral fake-evidence over the 224-grid
                 sal = model.patch_fake_map(x)                  # [nH,nW] or None (five-crop/large grid)
                 if sal is None:
@@ -351,7 +351,7 @@ class Engine:
         t = x[0].detach().float().cpu()
         if t.dim() == 4:
             t = torch.cat(list(t), dim=2)
-        norm = next((s for s in getattr(spec.transform, "transforms", []) if isinstance(s, T.Normalize)), None)
+        norm = spec.transform.normalize_step()
         if norm is not None:
             t = t * torch.tensor(norm.std)[:, None, None] + torch.tensor(norm.mean)[:, None, None]
         elif spec.key == "cure":                       # CuRe maps pixels to (x - 127.5) / 127.5