#!/usr/bin/env python3
"""
Unified evaluation script for legacy AI-generated image detection methods on ACID dataset.
This script evaluates CNNDetection and UnivFD pretrained models to verify that
existing methods struggle to generalize to unseen AI models in the ACID dataset.
Usage:
python evaluate_legacy.py --method CNNDetection --acid-root /path/to/acid/images
python evaluate_legacy.py --method UnivFD --acid-root /path/to/acid/images
"""
import argparse
import csv
import os
import sys
from datetime import datetime
from pathlib import Path
from typing import Dict, List, Tuple, Optional
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader
from tqdm import tqdm
import torchvision.transforms as T
# Define directories first
SCRIPT_DIR = Path(__file__).resolve().parent
METHODS_DIR = SCRIPT_DIR.parent / "methods"
# Import local eval_utils BEFORE modifying sys.path to avoid conflicts with method utils
from eval_utils import (
load_model_mapping,
get_model_folders,
get_image_files,
ACIDEvalDataset,
create_per_model_datasets,
create_real_dataset,
get_model_name,
compute_metrics,
save_image_paths,
)
# Training-free methods that use relative scores without learned thresholds.
# For these methods, AUC and AP are the primary metrics (accuracy is less meaningful).
TRAINING_FREE_METHODS = {"AEROBLADE", "WaRPAD", "RIGID", "ManifoldBias"}
# Add method directories to path for their imports (after local utils import)
# NOTE: We intentionally DO NOT add WaRPAD, RINE/src, or other paths with utils.py files
# that could conflict with HiFi_IFDL's utils/utils.py package structure.
# These will be added dynamically in their respective wrappers.
sys.path.insert(0, str(METHODS_DIR / "CNNDetection"))
sys.path.insert(0, str(METHODS_DIR / "UniversalFakeDetect"))
sys.path.insert(0, str(METHODS_DIR / "LGrad" / "CNNDetection"))
sys.path.insert(0, str(METHODS_DIR / "FusingGlobalandLocal"))
sys.path.insert(0, str(METHODS_DIR / "DeeCLIP"))
sys.path.insert(0, str(METHODS_DIR / "DIRE"))
class CNNDetectionWrapper:
"""Wrapper for CNNDetection model."""
def __init__(self, weights_path: str, device: str = "cuda"):
if not Path(weights_path).is_file():
raise FileNotFoundError(weights_path)
self.device = device
# Import CNNDetection model using importlib for reliable path handling
import importlib.util
resnet_path = METHODS_DIR / "CNNDetection" / "networks" / "resnet.py"
spec = importlib.util.spec_from_file_location("resnet", resnet_path)
resnet_module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(resnet_module)
resnet50 = resnet_module.resnet50
self.model = resnet50(num_classes=1)
state_dict = torch.load(weights_path, map_location="cpu", weights_only=False)
# Handle different state dict formats
if "model" in state_dict:
state_dict = state_dict["model"]
self.model.load_state_dict(state_dict)
self.model = self.model.to(device)
self.model.eval()
# CNNDetection uses ImageNet normalization
import torchvision.transforms as T
self.transform = T.Compose([
T.Resize(256),
T.CenterCrop(224),
T.ToTensor(),
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
@torch.no_grad()
def predict(self, images: torch.Tensor) -> Tuple[List[int], List[float]]:
"""
Predict if images are fake.
Args:
images: Batch of images [B, 3, H, W]
Returns:
predictions: Binary predictions (0=real, 1=fake)
probabilities: Probability of being fake
"""
images = images.to(self.device)
logits = self.model(images)
probs = torch.sigmoid(logits).squeeze(-1)
preds = (probs > 0.5).int()
return preds.cpu().tolist(), probs.cpu().tolist()
class UnivFDWrapper:
"""Wrapper for UniversalFakeDetect (UnivFD) model."""
def __init__(self, weights_path: str, device: str = "cuda"):
if not Path(weights_path).is_file():
raise FileNotFoundError(weights_path)
self.device = device
# Load CLIP model
try:
import clip
except ImportError:
raise ImportError("Please install clip: pip install git+https://github.com/openai/CLIP.git")
self.clip_model, self.preprocess = clip.load("ViT-L/14", device=device)
self.clip_model.eval()
# Load FC weights
fc_weights = torch.load(weights_path, map_location="cpu")
# The FC layer maps from CLIP feature dim (768) to 1
self.fc = nn.Linear(768, 1)
# Handle different weight formats
if isinstance(fc_weights, dict):
if "weight" in fc_weights:
self.fc.weight.data = fc_weights["weight"]
self.fc.bias.data = fc_weights["bias"]
else:
self.fc.load_state_dict(fc_weights)
else:
self.fc.load_state_dict(fc_weights)
self.fc = self.fc.to(device)
self.fc.eval()
# CLIP uses 224x224 input
import torchvision.transforms as T
self.transform = T.Compose([
T.Resize(224),
T.CenterCrop(224),
T.ToTensor(),
T.Normalize(mean=[0.48145466, 0.4578275, 0.40821073],
std=[0.26862954, 0.26130258, 0.27577711]),
])
@torch.no_grad()
def predict(self, images: torch.Tensor) -> Tuple[List[int], List[float]]:
"""
Predict if images are fake.
Args:
images: Batch of images [B, 3, H, W]
Returns:
predictions: Binary predictions (0=real, 1=fake)
probabilities: Probability of being fake
"""
images = images.to(self.device)
# Extract CLIP features
features = self.clip_model.encode_image(images)
features = features.float()
# Apply FC layer
logits = self.fc(features).squeeze(-1)
probs = torch.sigmoid(logits)
preds = (probs > 0.5).int()
return preds.cpu().tolist(), probs.cpu().tolist()
class LGradWrapper:
"""Wrapper for LGrad (Learning on Gradients) detector.
Reference: "Learning on Gradients: Generalized Artifacts Representation for GAN-Generated Images Detection"
Tan et al., CVPR 2023
GitHub: https://github.com/chuangchuangtan/LGrad
LGrad works by:
1. Passing images through a pretrained StyleGAN discriminator
2. Computing gradients of the discriminator output w.r.t. input images via backpropagation
3. Using these gradient images as input to a binary classifier
The key insight is that the discriminator gradients reveal artifacts specific to
generated images that are not visible in the original pixel space.
Requirements:
- StyleGAN discriminator weights: Download from the LGrad repo or use the provided path
- Classifier weights: Pre-trained ResNet50 on gradient images
"""
# Default path to StyleGAN discriminator weights (256x256 bedroom model)
DEFAULT_STYLEGAN_WEIGHTS = "weights/stylegan_discriminator.pth"
def __init__(self, weights_path: str, device: str = "cuda", stylegan_weights_path: str = None):
if not Path(weights_path).is_file():
raise FileNotFoundError(weights_path)
self.device = device
# Import LGrad classifier model (uses same ResNet architecture as CNNDetection)
import importlib.util
resnet_path = METHODS_DIR / "LGrad" / "CNNDetection" / "networks" / "resnet.py"
spec = importlib.util.spec_from_file_location("resnet_lgrad", resnet_path)
resnet_module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(resnet_module)
resnet50 = resnet_module.resnet50
self.model = resnet50(num_classes=1)
state_dict = torch.load(weights_path, map_location="cpu", weights_only=False)
if "model" in state_dict:
state_dict = state_dict["model"]
self.model.load_state_dict(state_dict)
self.model = self.model.to(device)
self.model.eval()
# Load StyleGAN discriminator for gradient computation
lgrad_path = METHODS_DIR / "LGrad" / "img2gad_pytorch"
sys.path.insert(0, str(lgrad_path))
from models import build_model as build_stylegan_model
self.discriminator = build_stylegan_model(
gan_type='stylegan',
module='discriminator',
resolution=256,
label_size=0,
image_channels=3
)
# Load StyleGAN discriminator weights
if stylegan_weights_path is None:
stylegan_weights_path = METHODS_DIR / "LGrad" / "img2gad_pytorch" / self.DEFAULT_STYLEGAN_WEIGHTS
if os.path.exists(stylegan_weights_path):
self.discriminator.load_state_dict(torch.load(stylegan_weights_path, map_location="cpu", weights_only=False), strict=True)
print(f"Loaded StyleGAN discriminator weights from {stylegan_weights_path}")
else:
raise FileNotFoundError(stylegan_weights_path)
self.discriminator = self.discriminator.to(device)
self.discriminator.eval()
# Transform for gradient computation (StyleGAN expects 256x256, normalized to [-1, 1])
self.grad_transform = T.Compose([
T.Resize((256, 256)),
T.ToTensor(),
T.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
])
# Transform for classifier input (ImageNet normalization after gradient computation)
self.classifier_transform = T.Compose([
T.Resize(256),
T.CenterCrop(224),
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
# Standard transform for dataset loading (same as get_transform)
self.transform = T.Compose([
T.Resize(256),
T.CenterCrop(224),
T.ToTensor(),
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
def _compute_discriminator_gradient(self, images: torch.Tensor) -> torch.Tensor:
"""Compute gradients of StyleGAN discriminator output w.r.t. input images.
This is the core of LGrad: the gradient image reveals artifacts that the
discriminator is sensitive to, which differ between real and generated images.
Args:
images: Batch of images [B, 3, H, W] normalized to [-1, 1] range
Returns:
Gradient images [B, 3, H, W] normalized to [0, 1] range
"""
# Ensure images require gradients for backpropagation
images = images.clone().detach().requires_grad_(True)
# Forward pass through discriminator
disc_output = self.discriminator(images)
# Compute gradients w.r.t. input images
# We sum the discriminator output and backpropagate to get per-pixel gradients
self.discriminator.zero_grad()
grad = torch.autograd.grad(
disc_output.sum(),
images,
create_graph=False,
retain_graph=False,
allow_unused=False
)[0]
# Normalize gradients to [0, 1] range (per-image normalization as in original LGrad)
batch_size = grad.shape[0]
grad_normalized = []
for i in range(batch_size):
g = grad[i]
g = g - g.min()
if g.max() != 0:
g = g / g.max()
grad_normalized.append(g)
return torch.stack(grad_normalized, dim=0)
def predict(self, images: torch.Tensor) -> Tuple[List[int], List[float]]:
"""Predict if images are fake using LGrad method.
Args:
images: Batch of images [B, 3, H, W] - expects images already preprocessed
with grad_transform (256x256, normalized to [-1, 1])
Returns:
predictions: Binary predictions (0=real, 1=fake)
probabilities: Probability of being fake
"""
images = images.to(self.device)
# Step 1: Resize to 256x256 and normalize to [-1, 1] for discriminator
# (images are expected to be in ImageNet normalized format, convert back first)
# Actually, we need raw [0,1] images, then apply grad_transform
# For efficiency, we'll denormalize and renormalize
# Assume input is ImageNet normalized, denormalize first
mean = torch.tensor([0.485, 0.456, 0.406], device=self.device).view(1, 3, 1, 1)
std = torch.tensor([0.229, 0.224, 0.225], device=self.device).view(1, 3, 1, 1)
images_01 = images * std + mean # Back to [0, 1]
# Resize to 256x256 for discriminator
if images_01.shape[-1] != 256 or images_01.shape[-2] != 256:
images_256 = F.interpolate(images_01, size=(256, 256), mode='bilinear', align_corners=False)
else:
images_256 = images_01
# Normalize to [-1, 1] for StyleGAN discriminator
images_disc = images_256 * 2.0 - 1.0
# Step 2: Compute discriminator gradients (requires grad, so no torch.no_grad())
grad_images = self._compute_discriminator_gradient(images_disc)
# Step 3: Prepare gradient images for classifier
# Center crop to 224x224 (matching original: Resize(256) -> CenterCrop(224))
# Since gradient is already 256x256, we just need the center crop
with torch.no_grad():
if grad_images.shape[-1] == 256 and grad_images.shape[-2] == 256:
# Center crop from 256 to 224 (crop 16 pixels from each side)
crop_margin = (256 - 224) // 2 # 16
grad_images = grad_images[:, :, crop_margin:-crop_margin, crop_margin:-crop_margin]
elif grad_images.shape[-1] != 224 or grad_images.shape[-2] != 224:
# Fallback: resize then center crop if not 256x256
grad_images = F.interpolate(grad_images, size=(256, 256), mode='bilinear', align_corners=False)
crop_margin = (256 - 224) // 2
grad_images = grad_images[:, :, crop_margin:-crop_margin, crop_margin:-crop_margin]
# Apply ImageNet normalization
grad_images = (grad_images - mean) / std
# Step 4: Classify gradient images
logits = self.model(grad_images)
probs = torch.sigmoid(logits).squeeze(-1)
preds = (probs > 0.5).int()
return preds.cpu().tolist(), probs.cpu().tolist()
@classmethod
def get_transform(cls):
"""Get the transform for input images.
Note: LGrad needs to perform its own preprocessing (discriminator gradient),
so we just return a basic transform to get images to [0, 1] tensor format.
The actual discriminator preprocessing happens in predict().
"""
return T.Compose([
T.Resize(256),
T.CenterCrop(224),
T.ToTensor(),
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
class HiFiNetWrapper:
"""Wrapper for HiFi-Net (Hierarchical Fine-Grained) detector."""
def __init__(self, weights_path: str, device: str = "cuda"):
if not Path(weights_path).is_dir():
raise FileNotFoundError(weights_path)
self.device = device
# HiFi-Net requires specific imports and working directory setup
hifi_path = METHODS_DIR / "HiFi_IFDL"
# Add HiFi paths to front of sys.path
sys.path.insert(0, str(hifi_path))
sys.path.insert(0, str(hifi_path / "models"))
# Change to HiFi directory for proper weight loading
original_cwd = os.getcwd()
os.chdir(str(hifi_path))
try:
from HiFi_Net import HiFi_Net
self.hifi = HiFi_Net()
finally:
os.chdir(original_cwd)
self.transform = T.Compose([
T.Resize((256, 256)),
T.ToTensor(),
])
@torch.no_grad()
def predict(self, images: torch.Tensor) -> Tuple[List[int], List[float]]:
"""HiFi-Net processes images one at a time via detect() method."""
predictions = []
probabilities = []
# HiFi expects file paths, so we need to process tensors differently
# Using the underlying FENet and SegNet directly
images = images.to(self.device)
# Normalize to [0, 1] range expected by HiFi
if images.max() > 1.0:
images = images / 255.0
output = self.hifi.FENet(images)
mask1_fea, mask1_binary, out0, out1, out2, out3 = self.hifi.SegNet(output, images)
# out3 contains classification logits (3 classes: 0=real, 1+=fake)
# Following HiFi-Net's one_hot_label_new: prob = 1 - x[:,0]
# This gives probability of being ANY fake class (not just class 1)
probs = torch.softmax(out3, dim=1)
fake_probs = 1 - probs[:, 0] # Probability of not being real
preds = (fake_probs > 0.5).int()
return preds.cpu().tolist(), fake_probs.cpu().tolist()
class RINEWrapper:
"""Wrapper for RINE (Representations from Intermediate Encoder-blocks) detector."""
def __init__(self, weights_path: str, device: str = "cuda"):
if not Path(weights_path).is_file():
raise FileNotFoundError(weights_path)
self.device = device
# Import RINE model
rine_path = METHODS_DIR / "RINE"
sys.path.insert(0, str(rine_path / "src"))
from models import Model
# Determine config based on weight file name
if "1class" in weights_path:
nproj, proj_dim = 4, 1024
elif "2class" in weights_path:
nproj, proj_dim = 4, 128
elif "4class" in weights_path:
nproj, proj_dim = 2, 1024
else:
nproj, proj_dim = 4, 1024 # default
self.model = Model(
backbone=("ViT-L/14", 1024),
nproj=nproj,
proj_dim=proj_dim,
device=device,
)
# Load weights
if os.path.exists(weights_path):
state_dict = torch.load(weights_path, map_location=device)
# RINE saves only trainable params, need special loading
for name in state_dict:
try:
exec(f'self.model.{name.replace(".", "[", 1).replace(".", "].", 1)} = torch.nn.Parameter(state_dict["{name}"])')
except:
pass
self.model = self.model.to(device)
self.model.eval()
# CLIP preprocessing
self.transform = T.Compose([
T.Resize(224),
T.CenterCrop(224),
T.ToTensor(),
T.Normalize(mean=[0.48145466, 0.4578275, 0.40821073],
std=[0.26862954, 0.26130258, 0.27577711]),
])
@torch.no_grad()
def predict(self, images: torch.Tensor) -> Tuple[List[int], List[float]]:
images = images.to(self.device)
outputs = self.model(images)
logits = outputs[0] # First element is classification logits
probs = torch.sigmoid(logits).squeeze(-1)
preds = (probs > 0.5).int()
return preds.cpu().tolist(), probs.cpu().tolist()
class DeeCLIPWrapper:
"""Wrapper for DeeCLIP (CLIP + LoRA + DeeFuser) detector."""
def __init__(self, weights_path: str, device: str = "cuda"):
if not Path(weights_path).is_file():
raise FileNotFoundError(weights_path)
self.device = device
# Import DeeCLIP model
deeclip_path = METHODS_DIR / "DeeCLIP"
sys.path.insert(0, str(deeclip_path))
from model import DeeCLIP
self.model = DeeCLIP(layer_indices=[1, 3, 5, 8, 10, 13, 15, 17, 19, 21, 22, 23])
# Load weights
if os.path.exists(weights_path):
state_dict = torch.load(weights_path, map_location="cpu")
self.model.load_state_dict(state_dict, strict=False)
self.model = self.model.to(device)
self.model.eval()
# CLIP ViT-L/14 preprocessing
self.transform = T.Compose([
T.Resize(224),
T.CenterCrop(224),
T.ToTensor(),
T.Normalize(mean=[0.48145466, 0.4578275, 0.40821073],
std=[0.26862954, 0.26130258, 0.27577711]),
])
@torch.no_grad()
def predict(self, images: torch.Tensor) -> Tuple[List[int], List[float]]:
images = images.to(self.device)
# DeeCLIP returns (embeddings, logits) in train mode, (features, visual, logits) in eval
outputs = self.model(images, train=False)
logits = outputs[-1] # Last element is logits
probs = torch.sigmoid(logits).squeeze(-1)
preds = (probs > 0.5).int()
return preds.cpu().tolist(), probs.cpu().tolist()
class DIREWrapper:
"""Wrapper for DIRE (Diffusion Reconstruction Error) detector.
Reference: "DIRE for Diffusion-Generated Image Detection"
Wang et al., ICCV 2023
GitHub: https://github.com/ZhendongWang6/DIRE
DIRE works by:
1. Encoding an image to latent space via DDIM reverse process
2. Reconstructing the image via DDIM forward process
3. Computing DIRE = |original - reconstruction|
4. Classifying the DIRE image with a binary classifier
The key insight is that diffusion-generated images can be approximately
reconstructed by a diffusion model, while real images cannot.
Requirements:
- ADM diffusion model weights for reconstruction (256x256_diffusion_uncond.pt)
- DIRE classifier weights (trained on DIRE images)
Note: Computing DIRE images is expensive (requires diffusion model inference).
For efficiency, images are processed one at a time.
"""
# Default ADM model path
# Use lsun_bedroom.pt to match the lsun_adm.pth classifier training
DEFAULT_ADM_WEIGHTS = "models/lsun_bedroom.pt"
def __init__(self, weights_path: str, device: str = "cuda", adm_weights_path: str = None):
if not Path(weights_path).is_file():
raise FileNotFoundError(weights_path)
self.device = device
# Import DIRE classifier model
import importlib.util
resnet_path = METHODS_DIR / "DIRE" / "networks" / "resnet.py"
spec = importlib.util.spec_from_file_location("resnet_dire", resnet_path)
resnet_module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(resnet_module)
resnet50 = resnet_module.resnet50
self.model = resnet50(num_classes=1)
if os.path.exists(weights_path):
state_dict = torch.load(weights_path, map_location="cpu", weights_only=False)
if "model" in state_dict:
state_dict = state_dict["model"]
self.model.load_state_dict(state_dict)
self.model = self.model.to(device)
self.model.eval()
# Load ADM diffusion model for DIRE computation
guided_diffusion_path = METHODS_DIR / "DIRE" / "guided-diffusion"
sys.path.insert(0, str(guided_diffusion_path))
from guided_diffusion.script_util import (
model_and_diffusion_defaults,
create_model_and_diffusion,
)
# ADM model configuration for 256x256 unconditional model
self.image_size = 256
model_config = model_and_diffusion_defaults()
model_config.update({
"image_size": 256,
"attention_resolutions": "32,16,8",
"class_cond": False,
"diffusion_steps": 1000,
"dropout": 0.1,
"learn_sigma": True,
"noise_schedule": "linear",
"num_channels": 256,
"num_head_channels": 64,
"num_res_blocks": 2,
"resblock_updown": True,
"use_fp16": True,
"use_scale_shift_norm": True,
"timestep_respacing": "ddim20", # Use DDIM with 20 steps for efficiency
"use_checkpoint": False,
"num_heads": 4,
"num_heads_upsample": -1,
"channel_mult": "",
"use_kl": False,
"predict_xstart": False,
"rescale_timesteps": False,
"rescale_learned_sigmas": False,
"use_new_attention_order": False,
})
self.diffusion_model, self.diffusion = create_model_and_diffusion(**model_config)
# Load ADM weights
if adm_weights_path is None:
adm_weights_path = METHODS_DIR / "DIRE" / self.DEFAULT_ADM_WEIGHTS
self.adm_loaded = False
if os.path.exists(adm_weights_path):
adm_state_dict = torch.load(adm_weights_path, map_location="cpu")
self.diffusion_model.load_state_dict(adm_state_dict)
self.diffusion_model = self.diffusion_model.to(device)
self.diffusion_model.convert_to_fp16()
self.diffusion_model.eval()
self.adm_loaded = True
print(f"Loaded ADM diffusion model from {adm_weights_path}")
else:
raise FileNotFoundError(adm_weights_path)
# DDIM parameters
self.real_step = 0 # Number of real denoising steps (0 = full reconstruction)
# Transform for classifier input
self.transform = T.Compose([
T.Resize(256),
T.CenterCrop(224),
T.ToTensor(),
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
def _reshape_image(self, imgs: torch.Tensor) -> torch.Tensor:
"""Reshape images to 256x256 for diffusion model."""
if len(imgs.shape) == 3:
imgs = imgs.unsqueeze(0)
if imgs.shape[2] != imgs.shape[3]:
# Center crop to square
min_dim = min(imgs.shape[2], imgs.shape[3])
start_h = (imgs.shape[2] - min_dim) // 2
start_w = (imgs.shape[3] - min_dim) // 2
imgs = imgs[:, :, start_h:start_h+min_dim, start_w:start_w+min_dim]
if imgs.shape[2] != self.image_size:
imgs = F.interpolate(imgs, size=(self.image_size, self.image_size), mode="bicubic", align_corners=False)
return imgs
def _compute_dire(self, images: torch.Tensor) -> torch.Tensor:
"""Compute DIRE (Diffusion Reconstruction Error) images.
Args:
images: Batch of images [B, 3, H, W] in [-1, 1] range
Returns:
DIRE images [B, 3, H, W] in [0, 1] range
"""
batch_size = images.shape[0]
# Step 1: DDIM reverse (encode image to latent)
latent = self.diffusion.ddim_reverse_sample_loop(
self.diffusion_model,
(batch_size, 3, self.image_size, self.image_size),
noise=images,
clip_denoised=True,
model_kwargs={},
real_step=self.real_step,
)
# Step 2: DDIM forward (reconstruct from latent)
# Note: Original compute_dire.sh uses --use_ddim True, so ddim_sample_loop is used.
recons = self.diffusion.ddim_sample_loop(
self.diffusion_model,
(batch_size, 3, self.image_size, self.image_size),
noise=latent,
clip_denoised=True,
model_kwargs={},
real_step=self.real_step,
)
# Step 3: Compute DIRE as absolute difference
# Scale from [-1, 1] to [0, 1] for the difference
dire = torch.abs(images - recons)
# Normalize DIRE to [0, 1] range (original uses dire * 255 / 2 / 255 = dire / 2)
dire = dire / 2.0
return dire
@torch.no_grad()
def predict(self, images: torch.Tensor) -> Tuple[List[int], List[float]]:
"""Predict if images are fake using DIRE method.
Args:
images: Batch of images [B, 3, H, W] - ImageNet normalized
Returns:
predictions: Binary predictions (0=real, 1=fake)
probabilities: Probability of being fake
"""
images = images.to(self.device)
if not self.adm_loaded:
raise RuntimeError("DIRE requires the ADM reconstruction model")
# Denormalize from ImageNet to [0, 1]
mean = torch.tensor([0.485, 0.456, 0.406], device=self.device).view(1, 3, 1, 1)
std = torch.tensor([0.229, 0.224, 0.225], device=self.device).view(1, 3, 1, 1)
images_01 = images * std + mean
# Reshape to 256x256 for diffusion model
images_256 = self._reshape_image(images_01)
# Convert to [-1, 1] range for diffusion model
images_diff = images_256 * 2.0 - 1.0
# Compute DIRE images (process one at a time to avoid OOM)
dire_images = []
for i in range(images_diff.shape[0]):
img = images_diff[i:i+1]
dire = self._compute_dire(img)
dire_images.append(dire)
dire_images = torch.cat(dire_images, dim=0)
# Resize DIRE images for classifier (224x224)
if dire_images.shape[-1] != 224 or dire_images.shape[-2] != 224:
dire_images = F.interpolate(dire_images, size=(224, 224), mode='bilinear', align_corners=False)
# Apply ImageNet normalization to DIRE images
dire_images = (dire_images - mean) / std
# Classify DIRE images
logits = self.model(dire_images)
probs = torch.sigmoid(logits).squeeze(-1)
preds = (probs > 0.5).int()
return preds.cpu().tolist(), probs.cpu().tolist()
@classmethod
def get_transform(cls):
"""Get the transform for input images."""
return T.Compose([
T.Resize(256),
T.CenterCrop(224),
T.ToTensor(),
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
class WaRPADWrapper:
"""Wrapper for WaRPAD (Training-free detection via Cropping Robustness).
Reference: "Training-free Detection of AI-generated images via Cropping Robustness"
Link: https://arxiv.org/abs/2511.14030
IMPORTANT: WaRPAD requires high-resolution input (896x896) with BICUBIC interpolation.
Use get_transform() to get the proper transform for the dataset.
"""
# Class-level constants for transform
PREP_SIZE = 896
PATCH_SIZE = 224
def __init__(self, weights_path: str = None, device: str = "cuda"):
self.device = device
# Load DINOv2 model from torch.hub
self.model = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitl14')
self.model = self.model.to(device)
self.model.eval()
# WaRPAD parameters
self.patch_size = self.PATCH_SIZE
self.prep_size = self.PREP_SIZE
self.noise_level = 0.1
# Haar wavelet transform
try:
from pytorch_wavelets import DWTForward, DWTInverse
self.dwt = DWTForward(J=2, wave='haar').to(device)
self.idwt = DWTInverse(wave='haar').to(device)
self.use_wavelet = True
except ImportError:
raise ImportError("WaRPAD requires pytorch_wavelets; approximate perturbations are not supported")
@classmethod
def get_transform(cls) -> T.Compose:
"""Get the transform required for WaRPAD.
WaRPAD requires 896x896 images resized with BICUBIC interpolation
to preserve high-frequency details needed for detection.
Returns:
torchvision transform for WaRPAD preprocessing
"""
from PIL import Image
return T.Compose([
T.Resize((cls.PREP_SIZE, cls.PREP_SIZE), interpolation=Image.BICUBIC),
T.ToTensor(),
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
@classmethod
def get_target_size(cls) -> int:
"""Get the target image size for WaRPAD."""
return cls.PREP_SIZE
def _compute_warpad_score(self, image: torch.Tensor) -> Tuple[float, float]:
"""Compute WaRPAD score for a single image.
Returns:
Tuple of (fake_probability, raw_similarity_score)
"""
b, c, h, w = image.shape
# Unfold into patches
patches = image.unfold(2, self.patch_size, self.patch_size).unfold(3, self.patch_size, self.patch_size)
patches = patches.reshape(b, c, -1, self.patch_size, self.patch_size).transpose(1, 2)
patches = patches.reshape(-1, c, self.patch_size, self.patch_size)
if self.use_wavelet:
# Apply wavelet perturbation (original WaRPAD method)
yl, yh = self.dwt(patches)
yl_zeros = torch.zeros_like(yl)
pert_hf = self.idwt((yl_zeros, yh))
perturbed = patches - self.noise_level * pert_hf
else:
raise RuntimeError("WaRPAD requires wavelet perturbations")
# Get features
outputs = self.model.forward_features(patches, None)["x_norm_clstoken"]
perturbed_outputs = self.model.forward_features(perturbed, None)["x_norm_clstoken"]
# Compute cosine similarity
similarity = F.cosine_similarity(outputs, perturbed_outputs, dim=-1)
similarity = similarity.reshape(b, -1)
# WaRPAD uses mean similarity as score
# fake images have LOWER similarity (less robust to perturbation)
raw_score = similarity.mean().item()
# Convert to fake probability
# With wavelet perturbation, scores are typically in range [0.98, 1.0]
# Lower similarity = more likely fake
# Using a sigmoid-based conversion for smoother probability mapping
if self.use_wavelet:
# Threshold around 0.995, with sigmoid mapping
threshold = 0.995
scale = 200.0 # Steepness of sigmoid
fake_prob = 1.0 / (1.0 + np.exp(scale * (raw_score - threshold)))
else:
raise RuntimeError("WaRPAD requires wavelet perturbations")
return fake_prob, raw_score
@torch.no_grad()
def predict(self, images: torch.Tensor) -> Tuple[List[int], List[float]]:
images = images.to(self.device)
# Images should already be at prep_size (896x896) from the dataset transform
# If not, resize with bicubic (fallback for compatibility)
if images.shape[-1] != self.prep_size or images.shape[-2] != self.prep_size:
images = F.interpolate(images, size=(self.prep_size, self.prep_size), mode='bicubic', align_corners=False)
probabilities = []
for i in range(images.shape[0]):
prob, _ = self._compute_warpad_score(images[i:i+1])
probabilities.append(prob)
predictions = [1 if p > 0.5 else 0 for p in probabilities]
return predictions, probabilities
class RIGIDWrapper:
"""Wrapper for RIGID (Training-free detection via Noise Perturbation Robustness).
Reference: https://github.com/IBM/RIGID
Key insight: Real images are more robust to noise perturbation than AI-generated images.
"""
def __init__(self, weights_path: str = None, device: str = "cuda"):
self.device = device
# Load DINOv2 model (same as WaRPAD)
self.model = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitl14')
self.model = self.model.to(device)
self.model.eval()
# RIGID hyperparameter
self.lamb = 0.05
self.transform = T.Compose([
T.Resize(224),
T.CenterCrop(224),
T.ToTensor(),
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
@torch.no_grad()
def predict(self, images: torch.Tensor) -> Tuple[List[int], List[float]]:
images = images.to(self.device)
# Resize to 224x224 if needed
if images.shape[-1] != 224:
images = F.interpolate(images, size=(224, 224), mode='bilinear', align_corners=False)
# Get original features
features = self.model(images)
# Add Gaussian noise perturbation
noise = torch.randn_like(images)
perturbed = images + noise * self.lamb
# Get perturbed features
perturbed_features = self.model(perturbed)
# Compute cosine similarity (same as original RIGID)
similarity = F.cosine_similarity(features, perturbed_features, dim=-1)
# Return raw similarity as score (matching original RIGID behavior)
# Real images: higher similarity (more robust to noise) ~0.99
# Fake images: lower similarity (less robust) ~0.95-0.97
#
# Since our evaluation expects fake_probs (higher = more likely fake),
# we invert the similarity: fake_prob = 1 - similarity
# This preserves the relative ordering for AUC computation
fake_probs = 1.0 - similarity
# Threshold at 0.5 corresponds to similarity of 0.5
# But for AUC evaluation, the threshold doesn't matter - only ranking matters
preds = (fake_probs > 0.5).int()
return preds.cpu().tolist(), fake_probs.cpu().tolist()
class AEROBLADEWrapper:
"""Wrapper for AEROBLADE (Autoencoder Reconstruction-Based Latent Detector).
AEROBLADE is a training-free method that detects AI-generated images by measuring
autoencoder reconstruction error. The key insight is that images generated by
latent diffusion models (like Stable Diffusion) have lower reconstruction error
when passed through the same autoencoder used during generation.
Reference: https://arxiv.org/abs/2401.17879
GitHub: https://github.com/jonasricker/aeroblade
This implementation strictly follows the original codebase:
- Uses lpips_vgg_2 (second VGG layer) as distance metric (best in reference implementation)
- Uses SD1, SD2, and Kandinsky 2.1 autoencoders
- Takes maximum distance across all autoencoders
"""
def __init__(self, weights_path: str = None, device: str = "cuda"):
self.device = device
# Add AEROBLADE to path
aeroblade_path = METHODS_DIR / "AEROBLADE" / "src"
if str(aeroblade_path) not in sys.path:
sys.path.insert(0, str(aeroblade_path))
# Import LPIPS - use spatial=True to get per-layer outputs
# Following aeroblade/distances.py _PatchedLPIPS
import lpips
import warnings
with warnings.catch_warnings():
warnings.simplefilter("ignore")
self.lpips_model = lpips.LPIPS(net='vgg', spatial=True).to(device)
self.lpips_model.eval()
# Original AEROBLADE code stores: lpips_layers[0] = sum, lpips_layers[i+1] = layer i
# So lpips_vgg_2 accesses lpips_layers[2] = layers_batch[1] = second VGG layer (0-indexed: 1)
# Standard LPIPS returns layers directly without sum prefix, so we use index 1
self.lpips_layer = 1 # Second VGG layer (0-indexed) as in lpips_vgg_2
# Load VAE autoencoders from Stable Diffusion
# Following run_aeroblade.py defaults:
# - CompVis/stable-diffusion-v1-1 (SD1)
# - stabilityai/stable-diffusion-2-base (SD2)
# - kandinsky-community/kandinsky-2-1 (KD2.1)
from diffusers import AutoPipelineForImage2Image
from diffusers.models import VQModel
self.autoencoders = {}
self.ae_types = {} # 'vae' or 'movq'
# Note: stabilityai/stable-diffusion-2-base is gated on HuggingFace,
# so we use Manojb/stable-diffusion-2-1-base as a community mirror
repo_ids = [
"CompVis/stable-diffusion-v1-1", # SD1
"Manojb/stable-diffusion-2-1-base", # SD2 (community mirror)
"kandinsky-community/kandinsky-2-1", # KD2.1
]
print(f"Loading AEROBLADE autoencoders (following original implementation)...")
for repo_id in repo_ids:
try:
# Load full pipeline and extract AE (as in aeroblade/image.py)
pipe = AutoPipelineForImage2Image.from_pretrained(
repo_id,
torch_dtype=torch.float16,
use_safetensors=True,
variant="fp16" if "kandinsky-2" not in repo_id else None,
)
# Extract autoencoder from pipeline
if hasattr(pipe, "vae"):
ae = pipe.vae
ae_type = "vae"
# Upcast VAE if available (for numerical stability)
if hasattr(pipe, "upcast_vae"):
pipe.upcast_vae()
elif hasattr(pipe, "movq"):
ae = pipe.movq
ae_type = "movq"
else:
raise RuntimeError(f"No autoencoder found in {repo_id}")
ae = ae.to(device)
ae.eval()
self.autoencoders[repo_id] = ae
self.ae_types[repo_id] = ae_type
print(f" Loaded: {repo_id} ({ae_type})")
# Clean up pipeline to save memory
del pipe
torch.cuda.empty_cache()
except Exception as e:
raise RuntimeError(f"Required AEROBLADE autoencoder failed to load: {repo_id}") from e
if not self.autoencoders:
raise RuntimeError("Failed to load any autoencoders for AEROBLADE")
def _compute_lpips_layer(self, img_a: torch.Tensor, img_b: torch.Tensor) -> torch.Tensor:
"""Compute LPIPS distance for a specific layer.
Following aeroblade/distances.py _PatchedLPIPS and LPIPS class.
Returns the distance for lpips_vgg_2 (second VGG layer, 0-indexed as 1).
"""
# LPIPS expects inputs in [0, 1] with normalize=True, or [-1, 1] without
# We pass [0, 1] images and let LPIPS normalize them
with torch.no_grad():
# Get per-layer distances using retPerLayer
# Standard LPIPS returns (total, [layer0, layer1, layer2, ...])
total, layers = self.lpips_model(img_a, img_b, retPerLayer=True, normalize=True)
# Get the second VGG layer (index 1) matching lpips_vgg_2 from original
layer_dist = layers[self.lpips_layer]
# Average over spatial dimensions (as in original when spatial=False for output)
layer_dist = layer_dist.mean(dim=(2, 3))
return layer_dist.squeeze()
def _compute_reconstruction_error(self, images: torch.Tensor, ae, ae_type: str) -> torch.Tensor:
"""Compute reconstruction error through autoencoder.
Following aeroblade/image.py compute_reconstructions().
"""
from diffusers.models import VQModel
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_img2img import retrieve_latents
# Normalize to [-1, 1] as expected by VAE (as in original: images * 2.0 - 1.0)
images_norm = images * 2.0 - 1.0
# Encode - use retrieve_latents for proper handling (as in original)
generator = torch.Generator(device=self.device).manual_seed(1)
latents = retrieve_latents(ae.encode(images_norm), generator=generator)
# Get decode dtype from model
if hasattr(ae, 'post_quant_conv'):
decode_dtype = next(iter(ae.post_quant_conv.parameters())).dtype
else:
decode_dtype = images.dtype
# Decode
if isinstance(ae, VQModel):
reconstructions = ae.decode(
latents.to(decode_dtype), force_not_quantize=True, return_dict=False
)[0]
else:
reconstructions = ae.decode(latents.to(decode_dtype), return_dict=False)[0]
# De-normalize to [0, 1]
reconstructions = (reconstructions / 2 + 0.5).clamp(0, 1)
images_01 = images.clamp(0, 1)
# Compute LPIPS distance for the specified layer
lpips_dist = self._compute_lpips_layer(images_01.float(), reconstructions.float())
return lpips_dist
@torch.no_grad()
def predict(self, images: torch.Tensor) -> Tuple[List[int], List[float]]:
"""Predict if images are fake based on reconstruction error.
AEROBLADE's key insight:
- Real images: HIGH reconstruction error (hard to reconstruct)
- AI-generated images: LOW reconstruction error (easy to reconstruct)
We invert this to get fake probability:
- Low error → High fake probability
- High error → Low fake probability
Args:
images: Batch of images [B, 3, H, W] in ImageNet-normalized format
(the standard format from the evaluation pipeline)
Returns:
predictions: Binary predictions (0=real, 1=fake)
probabilities: Probability of being fake
"""
images = images.to(self.device, dtype=torch.float16)
# De-normalize from ImageNet normalization back to [0, 1] range
# The dataset applies: (img - mean) / std, so we reverse: img * std + mean
mean = torch.tensor([0.485, 0.456, 0.406], device=self.device, dtype=torch.float16).view(1, 3, 1, 1)
std = torch.tensor([0.229, 0.224, 0.225], device=self.device, dtype=torch.float16).view(1, 3, 1, 1)
images = images * std + mean # Back to [0, 1] range
images = images.clamp(0, 1) # Ensure valid range
# Resize to 512x512 if needed (AEROBLADE expects 512x512 images)
if images.shape[-1] != 512 or images.shape[-2] != 512:
images = F.interpolate(images, size=(512, 512), mode='bilinear', align_corners=False)
# Compute reconstruction error for each autoencoder and take maximum
# Following original: maximum distance across all autoencoders
max_errors = None
for repo_id, ae in self.autoencoders.items():
errors = self._compute_reconstruction_error(images, ae, self.ae_types[repo_id])
if max_errors is None:
max_errors = errors
else:
max_errors = torch.maximum(max_errors, errors)
# Convert reconstruction error to fake probability
# AEROBLADE's key insight: lower reconstruction error → more likely AI-generated
# Because generated images come from the same latent space as the autoencoder
#
# Original AEROBLADE returns raw (negated) distances for AUC computation
# We follow the same approach: invert error so higher value = more likely fake
# This preserves ranking for AUC and doesn't rely on arbitrary thresholds
fake_probs = 1.0 - max_errors.float()
fake_probs = torch.clamp(fake_probs, 0.0, 1.0)
preds = (fake_probs > 0.5).int()
return preds.cpu().tolist(), fake_probs.cpu().tolist()
class FatFormerWrapper:
"""Wrapper for FatFormer (Forgery-Aware Transformer) detector.
Reference: https://arxiv.org/abs/2303.17111
GitHub: https://github.com/Michel-liu/FatFormer
FatFormer uses CLIP ViT-L/14 as backbone with:
- Forgery-aware adapters that process spatial and frequency domain features
- Language-guided alignment for improved generalization
Requirements:
- pytorch_wavelets: pip install pytorch_wavelets
- CLIP ViT-L/14 weights at: FatFormer/pretrained/ViT-L-14.pt
(Download from: https://openaipublic.azureedge.net/clip/models/b8cca3fd41ae0c99ba7e8951adf17d267cdb84cd88be6f7c2e0eca1737a03836/ViT-L-14.pt)
"""
def __init__(self, weights_path: str, device: str = "cuda"):
if not Path(weights_path).is_file():
raise FileNotFoundError(weights_path)
self.device = device
# FatFormer requires specific imports
fatformer_path = METHODS_DIR / "FatFormer"
# Save original cwd and change to FatFormer directory for proper import
original_cwd = os.getcwd()
os.chdir(str(fatformer_path))
# Add FatFormer to path
sys.path.insert(0, str(fatformer_path))
try:
# Create args namespace with required parameters
class Args:
backbone = "CLIP:ViT-L/14"
num_classes = 2
num_vit_adapter = 3
num_context_embedding = 8
init_context_embedding = ""
hidden_dim = 768
clip_vision_width = 1024
frequency_encoder_layer = 2
decoder_layer = 4
num_heads = 12
args = Args()
# Import and build model
from models import build_model
self.model = build_model(args)
# Load checkpoint
if os.path.exists(weights_path):
checkpoint = torch.load(weights_path, map_location="cpu", weights_only=False)
if "model" in checkpoint:
state_dict = checkpoint["model"]
else:
state_dict = checkpoint
self.model.load_state_dict(state_dict, strict=False)
self.model = self.model.to(device)
self.model.eval()
finally:
os.chdir(original_cwd)
# FatFormer preprocessing (from utils/dataset.py)
# Uses ImageNet normalization, resize to 256, center crop to 224
self.transform = T.Compose([
T.Resize((256, 256)),
T.CenterCrop(224),
T.ToTensor(),
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
@torch.no_grad()
def predict(self, images: torch.Tensor) -> Tuple[List[int], List[float]]:
"""Predict if images are fake.
Args:
images: Batch of images [B, 3, H, W]
Returns:
predictions: Binary predictions (0=real, 1=fake)
probabilities: Probability of being fake
"""
images = images.to(self.device)
# Resize if needed
if images.shape[-1] != 224 or images.shape[-2] != 224:
images = F.interpolate(images, size=(224, 224), mode='bilinear', align_corners=False)
# Forward pass
outputs = self.model(images)
# FatFormer outputs logits for 2 classes: [real, fake]
# Apply softmax and get fake probability (class 1)
probs = torch.softmax(outputs, dim=1)
fake_probs = probs[:, 1]
preds = (fake_probs > 0.5).int()
return preds.cpu().tolist(), fake_probs.cpu().tolist()
class AIDEWrapper:
"""Wrapper for AIDE (AI-generated Image DEtector with Hybrid Features)."""
def __init__(self, weights_path: str, device: str = "cuda"):
if not Path(weights_path).is_file():
raise FileNotFoundError(weights_path)
self.device = device
# Add AIDE path to sys.path for proper module resolution
aide_path = METHODS_DIR / "AIDE"
# Save original sys.path
original_path = sys.path.copy()
# Add necessary paths
sys.path.insert(0, str(aide_path))
sys.path.insert(0, str(aide_path / "models"))
sys.path.insert(0, str(aide_path / "data"))
try:
# Import AIDE components
from data.dct import DCT_base_Rec_Module
# Need to import srm_filter_kernel first to resolve relative import
import srm_filter_kernel
import sys as _sys
_sys.modules['models.srm_filter_kernel'] = srm_filter_kernel
# Now import AIDE model
import importlib.util
aide_model_path = aide_path / "models" / "AIDE.py"
# Read and modify the source to fix relative import
with open(aide_model_path, 'r') as f:
source = f.read()
# Replace relative import with absolute
modified_source = source.replace(
'from .srm_filter_kernel import all_normalized_hpf_list',
'from srm_filter_kernel import all_normalized_hpf_list'
)
# Execute the modified source
exec_globals = {'__name__': 'aide_model', '__file__': str(aide_model_path)}
exec(compile(modified_source, str(aide_model_path), 'exec'), exec_globals)
AIDE_Model = exec_globals['AIDE_Model']
finally:
# Restore original sys.path to avoid polluting the namespace
pass # Keep paths for model to work properly
# Initialize DCT module for preprocessing
self.dct = DCT_base_Rec_Module()
# Build model without loading pretrained weights (we'll load from checkpoint)
self.model = AIDE_Model(resnet_path=None, convnext_path=None)
# Load checkpoint
if os.path.exists(weights_path):
state_dict = torch.load(weights_path, map_location="cpu", weights_only=False)
if "model" in state_dict:
state_dict = state_dict["model"]
# Load state dict (may need to handle prefix differences)
self.model.load_state_dict(state_dict, strict=False)
self.model = self.model.to(device)
self.model.eval()
# Move DCT module to device
self.dct = self.dct.to(device)
# Transform: resize to 256x256 and normalize
self.transform = T.Compose([
T.Resize((256, 256)),
T.ToTensor(),
])
# Normalization for the final input
self.normalize = T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
def _preprocess_batch(self, images: torch.Tensor) -> torch.Tensor:
"""Preprocess a batch of images for AIDE.
AIDE expects input of shape [B, 5, 3, 256, 256] where:
- images[:, 0] = x_minmin (DCT min-frequency patch)
- images[:, 1] = x_maxmax (DCT max-frequency patch)
- images[:, 2] = x_minmin1 (DCT second min-frequency patch)
- images[:, 3] = x_maxmax1 (DCT second max-frequency patch)
- images[:, 4] = x_0 (original image, normalized)
"""
batch_size = images.shape[0]
stacked_inputs = []
for i in range(batch_size):
img = images[i] # [3, H, W]
# Resize to 256x256 if needed
if img.shape[-1] != 256 or img.shape[-2] != 256:
img = F.interpolate(img.unsqueeze(0), size=(256, 256), mode='bilinear', align_corners=False).squeeze(0)
# Apply DCT to get frequency-based patches
# DCT expects [C, H, W] and returns 4 tensors of shape [3, 32, 32]
x_minmin, x_maxmax, x_minmin1, x_maxmax1 = self.dct(img)
# Resize DCT outputs from 32x32 to 256x256
# Add batch dimension, interpolate, then remove
x_minmin = F.interpolate(x_minmin.unsqueeze(0), size=(256, 256), mode='bilinear', align_corners=False).squeeze(0)
x_maxmax = F.interpolate(x_maxmax.unsqueeze(0), size=(256, 256), mode='bilinear', align_corners=False).squeeze(0)
x_minmin1 = F.interpolate(x_minmin1.unsqueeze(0), size=(256, 256), mode='bilinear', align_corners=False).squeeze(0)
x_maxmax1 = F.interpolate(x_maxmax1.unsqueeze(0), size=(256, 256), mode='bilinear', align_corners=False).squeeze(0)
# Normalize all inputs
x_minmin = self.normalize(x_minmin)
x_maxmax = self.normalize(x_maxmax)
x_minmin1 = self.normalize(x_minmin1)
x_maxmax1 = self.normalize(x_maxmax1)
x_0 = self.normalize(img)
# Stack: [5, 3, 256, 256]
stacked = torch.stack([x_minmin, x_maxmax, x_minmin1, x_maxmax1, x_0], dim=0)
stacked_inputs.append(stacked)
# Stack batch: [B, 5, 3, 256, 256]
return torch.stack(stacked_inputs, dim=0)
@torch.no_grad()
def predict(self, images: torch.Tensor) -> Tuple[List[int], List[float]]:
images = images.to(self.device)
# Preprocess batch
inputs = self._preprocess_batch(images)
# Forward pass
logits = self.model(inputs) # [B, 2]
# Get probabilities (class 1 = fake)
probs = torch.softmax(logits, dim=1)
fake_probs = probs[:, 1]
preds = (fake_probs > 0.5).int()
return preds.cpu().tolist(), fake_probs.cpu().tolist()
class AlignedForensicsWrapper:
"""Wrapper for AlignedForensics detector.
Reference: "Aligned Datasets Improve Detection of Latent Diffusion-Generated Images"
Rajan et al., ICLR 2025
GitHub: https://github.com/AniSundar18/AlignedForensics
Key Idea: Training fake image detectors on aligned (same content) real/fake pairs
reduces spurious correlations and improves generalization. Uses ResNet-50 with
modified first layer (stride=1 instead of 2) for better spatial resolution.
"""
def __init__(self, weights_path: str, device: str = "cuda"):
if not Path(weights_path).is_file():
raise FileNotFoundError(weights_path)
self.device = device
if not os.path.exists(weights_path):
raise FileNotFoundError(f"AlignedForensics checkpoint not found: {weights_path}")
# Add AlignedForensics paths
aligned_path = METHODS_DIR / "AlignedForensics" / "training_code"
if str(aligned_path) not in sys.path:
sys.path.insert(0, str(aligned_path))
# Import model architecture
from networks import create_architecture, load_weights
# Create ResNet-50 with no downsampling in first layer
self.model = create_architecture(
"res50nodown",
pretrained=False,
num_classes=1,
dropout=0.5
)
# Load weights
if os.path.exists(weights_path):
load_weights(self.model, weights_path)
print(f"Loaded AlignedForensics checkpoint from {weights_path}")
self.model = self.model.to(device)
self.model.eval()
# AlignedForensics uses ImageNet normalization
self.transform = T.Compose([
T.Resize(256),
T.CenterCrop(224),
T.ToTensor(),
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
@torch.no_grad()
def predict(self, images: torch.Tensor) -> Tuple[List[int], List[float]]:
"""Predict if images are fake.
Args:
images: Batch of images [B, 3, H, W]
Returns:
predictions: Binary predictions (0=real, 1=fake)
probabilities: Probability of being fake
"""
images = images.to(self.device)
# Forward pass - model returns (logits, features) tuple
outputs = self.model(images)
if isinstance(outputs, tuple):
logits = outputs[0] # First element is logits
else:
logits = outputs
# Get last dimension if multi-dimensional
while len(logits.shape) > 1:
logits = logits.mean(dim=-1) if logits.shape[-1] > 1 else logits.squeeze(-1)
probs = torch.sigmoid(logits)
preds = (probs > 0.5).int()
return preds.cpu().tolist(), probs.cpu().tolist()
class _SVDResidualLinear(nn.Module):
"""Custom module to represent the residual using SVD components.
Used by EffortWrapper for SVD-based orthogonal decomposition of linear layers.
"""
def __init__(self, in_features, out_features, r, bias=True, init_weight=None):
super(_SVDResidualLinear, self).__init__()
self.in_features = in_features
self.out_features = out_features
self.r = r
self.weight_main = nn.Parameter(torch.Tensor(out_features, in_features), requires_grad=False)
if init_weight is not None:
self.weight_main.data.copy_(init_weight)
else:
nn.init.kaiming_uniform_(self.weight_main, a=np.sqrt(5))
if bias:
self.bias = nn.Parameter(torch.Tensor(out_features))
nn.init.zeros_(self.bias)
else:
self.register_parameter('bias', None)
def forward(self, x):
if hasattr(self, 'U_residual') and hasattr(self, 'V_residual') and self.S_residual is not None:
residual_weight = self.U_residual @ torch.diag(self.S_residual) @ self.V_residual
weight = self.weight_main + residual_weight
else:
weight = self.weight_main
return F.linear(x, weight, self.bias)
def _replace_with_svd_residual(module, r):
"""Replace nn.Linear with SVDResidualLinear for Effort method."""
if isinstance(module, nn.Linear):
in_features = module.in_features
out_features = module.out_features
bias = module.bias is not None
new_module = _SVDResidualLinear(in_features, out_features, r, bias=bias, init_weight=module.weight.data.clone())
if bias and module.bias is not None:
new_module.bias.data.copy_(module.bias.data)
U, S, Vh = torch.linalg.svd(module.weight.data, full_matrices=False)
r = min(r, len(S))
U_r = U[:, :r]
S_r = S[:r]
Vh_r = Vh[:r, :]
weight_main = U_r @ torch.diag(S_r) @ Vh_r
new_module.weight_main.data.copy_(weight_main)
U_residual = U[:, r:]
S_residual = S[r:]
Vh_residual = Vh[r:, :]
if len(S_residual) > 0:
new_module.S_residual = nn.Parameter(S_residual.clone())
new_module.U_residual = nn.Parameter(U_residual.clone())
new_module.V_residual = nn.Parameter(Vh_residual.clone())
else:
new_module.S_residual = None
new_module.U_residual = None
new_module.V_residual = None
return new_module
return module
def _apply_svd_residual_to_self_attn(model, r):
"""Apply SVD residual decomposition to self-attention layers in a model."""
for name, module in model.named_children():
if 'self_attn' in name:
for sub_name, sub_module in module.named_modules():
if isinstance(sub_module, nn.Linear):
parent_module = module
sub_module_names = sub_name.split('.')
for module_name in sub_module_names[:-1]:
parent_module = getattr(parent_module, module_name)
setattr(parent_module, sub_module_names[-1], _replace_with_svd_residual(sub_module, r))
else:
_apply_svd_residual_to_self_attn(module, r)
for param_name, param in model.named_parameters():
if any(x in param_name for x in ['S_residual', 'U_residual', 'V_residual']):
param.requires_grad = True
else:
param.requires_grad = False
return model
class EffortWrapper:
"""Wrapper for Effort (Efficient Orthogonal Modeling) detector.
Reference: "Effort: Efficient Orthogonal Modeling for Generalizable AI-Generated Image Detection"
Yan et al., ICML 2025 Oral
GitHub: https://github.com/YZY-stack/Effort-AIGI-Detection
Effort uses SVD decomposition of CLIP ViT-L/14 self-attention weights:
- Main weights (frozen): Top-r singular components
- Residual weights (trainable): Remaining singular components
This preserves generalizable features while learning task-specific patterns.
Architecture: CLIP ViT-L/14 + SVD residual decomposition + Linear head (2 classes)
"""
def __init__(self, weights_path: str, device: str = "cuda"):
if not Path(weights_path).is_file():
raise FileNotFoundError(weights_path)
self.device = device
from transformers import CLIPModel
# Load CLIP ViT-L/14 from HuggingFace
print("Loading CLIP ViT-L/14 for Effort...")
clip_model = CLIPModel.from_pretrained("openai/clip-vit-large-patch14")
# Apply SVD to self_attn layers (r=1024-1=1023 keeps top 1023 singular values)
clip_model.vision_model = _apply_svd_residual_to_self_attn(clip_model.vision_model, r=1024-1)
# Create the detector module
self.model = nn.Module()
self.model.backbone = clip_model.vision_model
self.model.head = nn.Linear(1024, 2)
# Load weights
if os.path.exists(weights_path):
checkpoint = torch.load(weights_path, map_location="cpu", weights_only=False)
state_dict = checkpoint.get("state_dict", checkpoint)
# Remove "module." prefix if present (from DataParallel training)
new_state_dict = {}
for k, v in state_dict.items():
if k.startswith("module."):
k = k[7:]
new_state_dict[k] = v
# Load backbone and head weights
backbone_state = {k.replace("backbone.", ""): v for k, v in new_state_dict.items() if k.startswith("backbone.")}
head_state = {k.replace("head.", ""): v for k, v in new_state_dict.items() if k.startswith("head.")}
if backbone_state:
self.model.backbone.load_state_dict(backbone_state, strict=False)
if head_state:
self.model.head.load_state_dict(head_state, strict=True)
print(f"Loaded Effort checkpoint from {weights_path}")
self.model = self.model.to(device)
self.model.eval()
@staticmethod
def get_transform():
"""Return the CLIP ViT-L/14 preprocessing transform."""
return T.Compose([
T.Resize((224, 224)),
T.ToTensor(),
T.Normalize(mean=[0.48145466, 0.4578275, 0.40821073],
std=[0.26862954, 0.26130258, 0.27577711]),
])
@staticmethod
def get_target_size():
"""Return the target image size."""
return 224
@torch.no_grad()
def predict(self, images: torch.Tensor) -> Tuple[List[int], List[float]]:
"""Predict if images are fake.
Args:
images: Batch of images [B, 3, H, W]
Returns:
predictions: Binary predictions (0=real, 1=fake)
probabilities: Probability of being fake
"""
images = images.to(self.device)
# Resize if needed
if images.shape[-1] != 224 or images.shape[-2] != 224:
images = F.interpolate(images, size=(224, 224), mode='bilinear', align_corners=False)
# Forward pass through backbone
features = self.model.backbone(images)['pooler_output']
# Classification
logits = self.model.head(features)
# Get probabilities (class 1 = fake)
probs = torch.softmax(logits, dim=1)
fake_probs = probs[:, 1]
preds = (fake_probs > 0.5).int()
return preds.cpu().tolist(), fake_probs.cpu().tolist()
class NPRWrapper:
"""Wrapper for NPR (Nearest-neighbor Pattern Representation) detector.
Reference: "Rethinking the Up-Sampling Operations in CNN-based Generative Network
for Generalizable Deepfake Detection"
Tan et al., CVPR 2024
GitHub: https://github.com/chuangchuangtan/NPR-DeepfakeDetection
Key Idea: Detect artifacts from upsampling operations in CNN-based generators.
The NPR representation is computed as the difference between the original image
and the nearest-neighbor downsampled-then-upsampled version, highlighting
interpolation patterns specific to generative models.
"""
def __init__(self, weights_path: str, device: str = "cuda"):
if not Path(weights_path).is_file():
raise FileNotFoundError(weights_path)
self.device = device
# Import NPR model
import importlib.util
resnet_path = METHODS_DIR / "NPR" / "networks" / "resnet.py"
spec = importlib.util.spec_from_file_location("resnet_npr", resnet_path)
resnet_module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(resnet_module)
resnet50 = resnet_module.resnet50
self.model = resnet50(num_classes=1)
if os.path.exists(weights_path):
state_dict = torch.load(weights_path, map_location="cpu", weights_only=False)
# Handle different checkpoint formats
if "model" in state_dict:
state_dict = state_dict["model"]
# Remove "module." prefix from DataParallel training
new_state_dict = {}
for k, v in state_dict.items():
if k.startswith("module."):
new_state_dict[k[7:]] = v # Remove "module." prefix
else:
new_state_dict[k] = v
self.model.load_state_dict(new_state_dict, strict=True)
self.model = self.model.to(device)
self.model.eval()
# NPR uses ImageNet normalization, resize to 256, center crop to 224
self.transform = T.Compose([
T.Resize(256),
T.CenterCrop(224),
T.ToTensor(),
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
@torch.no_grad()
def predict(self, images: torch.Tensor) -> Tuple[List[int], List[float]]:
"""Predict if images are fake.
Args:
images: Batch of images [B, 3, H, W]
Returns:
predictions: Binary predictions (0=real, 1=fake)
probabilities: Probability of being fake
"""
images = images.to(self.device)
# Ensure image dimensions are even (required by NPR's interpolation)
n, c, h, w = images.shape
if h % 2 == 1:
images = images[:, :, :-1, :]
if w % 2 == 1:
images = images[:, :, :, :-1]
logits = self.model(images)
probs = torch.sigmoid(logits).squeeze(-1)
preds = (probs > 0.5).int()
return preds.cpu().tolist(), probs.cpu().tolist()
class ManifoldBiasWrapper:
"""Wrapper for Manifold Induced Biases detector.
Reference: "Manifold Induced Biases for Zero-shot and Few-shot Detection of Generated Images"
Brokman et al., ICLR 2025
GitHub: https://github.com/JonathanBrok/Manifold-Induced-Biases-for-Zero-shot-and-Few-shot-Detection-of-Generated-Images
This is a training-free zero-shot method that:
1. Uses Stable Diffusion v1.4 (UNet, VAE) to analyze diffusion behavior
2. Uses CLIP to measure similarity in embedding space
3. Computes a criterion score based on manifold-induced biases
Higher criterion score = more likely AI-generated
Lower criterion score = more likely real
"""
def __init__(self, weights_path: str = None, device: str = "cuda"):
self.device = device
# Add ManifoldBias to path
manifold_path = METHODS_DIR / "ManifoldBias"
if str(manifold_path) not in sys.path:
sys.path.insert(0, str(manifold_path))
# Import the criterion functions
from manifold_bias_criteria import (
get_sd_v14_model,
factory_sdv14_based_criterion,
)
from transformers import CLIPModel, AutoImageProcessor
# Store factory function for lazy criterion creation
self.factory_sdv14_based_criterion = factory_sdv14_based_criterion
# Load SD v1.4 models
print("Loading ManifoldBias models (SD v1.4, CLIP)...")
print(" This may take a while on first run (downloading models)...")
(
self.unet,
self.tokenizer,
self.text_encoder,
self.vae,
self.scheduler,
) = get_sd_v14_model(device)
# Load CLIP model
self.cos = torch.nn.CosineSimilarity(dim=1, eps=1e-6).to(device)
self.processor = AutoImageProcessor.from_pretrained("openai/clip-vit-large-patch14")
self.clip = CLIPModel.from_pretrained("openai/clip-vit-large-patch14").to(device)
self.num_noise = 8
self.time_frac = 0.01 # Fraction of diffusion time
self.epsilon_reg = 1e-8 # Regularization parameter
self.siz = 512 # Image size
# Create the criterion function with a generic prompt (skip LLaVA auto-captioning)
# Using a generic prompt is faster and avoids LLaVA compatibility issues
self.criterion_fn = self.factory_sdv14_based_criterion(
device,
self.num_noise,
self.epsilon_reg,
self.time_frac,
self.tokenizer,
self.text_encoder,
None, # image_to_text - not used when prompts_list is provided
self.vae,
self.scheduler,
self.unet,
self.clip,
self.processor,
self.cos,
self.siz,
prompts_list=["a photograph"], # Generic prompt used for all images
)
print("ManifoldBias models loaded successfully")
@torch.no_grad()
def predict(self, images: torch.Tensor) -> Tuple[List[int], List[float]]:
"""Predict if images are fake based on manifold-induced biases.
The criterion score indicates:
- Higher values: more likely AI-generated
- Lower values: more likely real
We convert this to fake probability using a sigmoid centered at empirical threshold.
Note: To avoid OOM with num_noise=8, images are processed one at a time.
Args:
images: Batch of images [B, 3, H, W] in [0, 1] range
Returns:
predictions: Binary predictions (0=real, 1=fake)
probabilities: Probability of being fake
"""
images = images.to(self.device)
# Process images one at a time to avoid OOM with num_noise=8
# With num_noise=8, effective batch size is 8 per image which requires significant VRAM
criterion_scores = []
for i in range(images.shape[0]):
# Clear cache before each image
torch.cuda.empty_cache()
# Convert single image from [C, H, W] [0,1] to [H, W, C] [0,255] tensor
img = images[i] # [C, H, W]
img = img.permute(1, 2, 0) # [H, W, C]
img = (img * 255).clamp(0, 255).to(torch.uint8)
# Run the criterion on single image
results = self.criterion_fn([img])
criterion_scores.append(results[0]["criterion"])
# Convert criterion to fake probability
# Empirical threshold around 0.5-0.7 based on examples
threshold = 0.6
scale = 5.0 # steepness of sigmoid
fake_probs = []
preds = []
for score in criterion_scores:
# Sigmoid mapping: score > threshold → high fake prob
prob = 1.0 / (1.0 + np.exp(-scale * (score - threshold)))
fake_probs.append(float(prob))
preds.append(1 if prob > 0.5 else 0)
return preds, fake_probs
def evaluate_model(
model_wrapper,
dataset: ACIDEvalDataset,
batch_size: int = 32,
num_workers: int = 4,
) -> Dict[str, float]:
"""
Evaluate a model on a dataset.
Args:
model_wrapper: Model wrapper with predict() method
dataset: Evaluation dataset
batch_size: Batch size for evaluation
num_workers: Number of data loading workers
Returns:
Dictionary of metrics
"""
loader = DataLoader(
dataset,
batch_size=batch_size,
shuffle=False,
num_workers=num_workers,
pin_memory=True,
)
all_preds = []
all_labels = []
all_probs = []
for images, labels, _ in tqdm(loader, desc="Evaluating"):
preds, probs = model_wrapper.predict(images)
all_preds.extend(preds)
all_labels.extend(labels.tolist())
all_probs.extend(probs)
return compute_metrics(all_preds, all_labels, all_probs)
def evaluate_per_model(
model_wrapper,
fake_root: str,
model_mapping: Optional[Dict] = None,
samples_per_model: int = 100,
batch_size: int = 32,
num_workers: int = 4,
) -> Dict[int, Dict[str, float]]:
"""
Evaluate model on each AI model separately.
Args:
model_wrapper: Model wrapper with predict() method
fake_root: Root directory of fake images
model_mapping: Optional model mapping
samples_per_model: Samples per model
batch_size: Batch size
num_workers: Number of workers
Returns:
Dictionary mapping model_id to metrics
"""
datasets = create_per_model_datasets(fake_root, model_mapping, samples_per_model)
results = {}
for model_id, dataset in tqdm(datasets.items(), desc="Evaluating per model"):
if len(dataset) > 0:
metrics = evaluate_model(model_wrapper, dataset, batch_size, num_workers)
results[model_id] = metrics
return results
def evaluate_per_model_with_real(
model_wrapper,
fake_datasets: Dict[int, ACIDEvalDataset],
real_preds: List[int],
real_probs: List[float],
real_labels: List[int],
batch_size: int = 32,
num_workers: int = 4,
) -> Dict[int, Dict[str, float]]:
"""
Evaluate model on each AI model paired with real images for proper AUC/AP calculation.
For training-free methods, AUC/AP require both classes (real and fake) to be meaningful.
This function pairs each AI model's fake images with the same set of real images.
Args:
model_wrapper: Model wrapper with predict() method
fake_datasets: Dictionary mapping model_id to fake image dataset
real_preds: Pre-computed predictions for real images
real_probs: Pre-computed probabilities for real images
real_labels: Labels for real images (all 0s)
batch_size: Batch size
num_workers: Number of workers
Returns:
Dictionary mapping model_id to metrics (with proper AUC/AP)
"""
results = {}
for model_id, fake_dataset in tqdm(fake_datasets.items(), desc="Evaluating per model (with real)"):
if len(fake_dataset) == 0:
continue
# Get predictions for this model's fake images
loader = DataLoader(
fake_dataset,
batch_size=batch_size,
shuffle=False,
num_workers=num_workers,
pin_memory=True,
)
fake_preds = []
fake_probs = []
fake_labels = []
for images, labels, _ in loader:
preds, probs = model_wrapper.predict(images)
fake_preds.extend(preds)
fake_probs.extend(probs)
fake_labels.extend(labels.tolist())
# Combine real and fake for this model
all_preds = real_preds + fake_preds
all_probs = real_probs + fake_probs
all_labels = real_labels + fake_labels
# Compute metrics with both classes present
metrics = compute_metrics(all_preds, all_labels, all_probs)
results[model_id] = metrics
return results
def save_results(
results: Dict[int, Dict[str, float]],
model_mapping: Optional[Dict],
output_path: str,
method_name: str,
):
"""Save evaluation results to CSV."""
with open(output_path, "w", newline="") as f:
writer = csv.writer(f)
writer.writerow([
"method", "model_id", "model_name", "accuracy", "precision",
"recall", "f1", "auc", "ap", "timestamp"
])
timestamp = datetime.now().isoformat()
for model_id, metrics in results.items():
model_name = get_model_name(model_id, model_mapping) if model_mapping else f"Model_{model_id}"
writer.writerow([
method_name,
model_id,
model_name,
f"{metrics.get('accuracy', 0):.4f}",
f"{metrics.get('precision', 0):.4f}",
f"{metrics.get('recall', 0):.4f}",
f"{metrics.get('f1', 0):.4f}",
f"{metrics.get('auc', 0):.4f}",
f"{metrics.get('ap', 0):.4f}",
timestamp,
])
def print_summary(results: Dict[int, Dict[str, float]], model_mapping: Optional[Dict], method_name: str = ""):
"""Print summary statistics.
For training-free methods (AEROBLADE, WaRPAD, RIGID, ManifoldBias),
AUC and AP are the primary metrics since accuracy depends on arbitrary thresholds.
"""
if not results:
print("No results to summarize.")
return
is_training_free = method_name in TRAINING_FREE_METHODS
accuracies = [m["accuracy"] for m in results.values()]
f1_scores = [m["f1"] for m in results.values()]
aucs = [m.get("auc", 0) for m in results.values()]
aps = [m.get("ap", 0) for m in results.values()]
print("\n" + "=" * 60)
print("EVALUATION SUMMARY")
if is_training_free:
print(f"[Training-free method: {method_name}]")
print("[Primary metrics: AUC and AP (accuracy uses arbitrary threshold)]")
print("=" * 60)
print(f"Number of models evaluated: {len(results)}")
# For training-free methods, show AUC/AP first as primary metrics
if is_training_free:
print(f"\nAUC (primary):")
print(f" Mean: {sum(aucs) / len(aucs):.4f}")
print(f" Min: {min(aucs):.4f}")
print(f" Max: {max(aucs):.4f}")
print(f"\nAP (primary):")
print(f" Mean: {sum(aps) / len(aps):.4f}")
print(f" Min: {min(aps):.4f}")
print(f" Max: {max(aps):.4f}")
print(f"\nAccuracy (arbitrary threshold, for reference only):")
print(f" Mean: {sum(accuracies) / len(accuracies):.4f}")
else:
print(f"\nAccuracy:")
print(f" Mean: {sum(accuracies) / len(accuracies):.4f}")
print(f" Min: {min(accuracies):.4f}")
print(f" Max: {max(accuracies):.4f}")
print(f"\nF1 Score:")
print(f" Mean: {sum(f1_scores) / len(f1_scores):.4f}")
print(f" Min: {min(f1_scores):.4f}")
print(f" Max: {max(f1_scores):.4f}")
print(f"\nAUC:")
print(f" Mean: {sum(aucs) / len(aucs):.4f}")
print(f" Min: {min(aucs):.4f}")
print(f" Max: {max(aucs):.4f}")
print(f"\nAP:")
print(f" Mean: {sum(aps) / len(aps):.4f}")
print(f" Min: {min(aps):.4f}")
print(f" Max: {max(aps):.4f}")
# Show worst performing models
print("\n" + "-" * 60)
if is_training_free:
print("Bottom 10 Models (by AUC):")
sorted_results = sorted(results.items(), key=lambda x: x[1].get("auc", 0))
for model_id, metrics in sorted_results[:10]:
model_name = get_model_name(model_id, model_mapping) if model_mapping else f"Model_{model_id}"
print(f" {model_name}: auc={metrics.get('auc', 0):.4f}, ap={metrics.get('ap', 0):.4f}")
else:
print("Bottom 10 Models (by accuracy):")
sorted_results = sorted(results.items(), key=lambda x: x[1]["accuracy"])
for model_id, metrics in sorted_results[:10]:
model_name = get_model_name(model_id, model_mapping) if model_mapping else f"Model_{model_id}"
print(f" {model_name}: acc={metrics['accuracy']:.4f}, f1={metrics['f1']:.4f}")
print("=" * 60)
def parse_args():
parser = argparse.ArgumentParser(
description="Evaluate legacy AI-generated image detection methods on ACID dataset."
)
parser.add_argument(
"--method",
type=str,
required=True,
choices=["CNNDetection", "UnivFD", "LGrad", "HiFi", "RINE", "DeeCLIP", "DIRE", "WaRPAD", "RIGID", "AIDE", "AEROBLADE", "FatFormer", "ManifoldBias", "NPR", "AlignedForensics", "Effort"],
help="Method to evaluate",
)
parser.add_argument(
"--acid-root",
type=str,
default="data_local/images/ai",
help="Root directory of ACID fake images",
)
parser.add_argument(
"--real-root",
type=str,
default="data_local/images/real",
help="Root directory of real images",
)
parser.add_argument(
"--real-samples",
type=int,
default=100,
help="Number of real samples for evaluation",
)
parser.add_argument(
"--model-mapping",
type=str,
default="data_local/model_mapping.yaml",
help="Path to model_mapping.yaml",
)
parser.add_argument(
"--output-dir",
type=str,
default=str(SCRIPT_DIR / "results"),
help="Output directory for results",
)
parser.add_argument(
"--samples-per-model",
type=int,
default=100,
help="Number of samples per model for evaluation",
)
parser.add_argument(
"--batch-size",
type=int,
default=32,
help="Batch size for evaluation",
)
parser.add_argument(
"--num-workers",
type=int,
default=4,
help="Number of data loading workers",
)
parser.add_argument(
"--device",
type=str,
default="cuda" if torch.cuda.is_available() else "cpu",
help="Device to use for inference",
)
return parser.parse_args()
def main():
args = parse_args()
# Create output directory
os.makedirs(args.output_dir, exist_ok=True)
# Load model mapping if available
model_mapping = None
if os.path.exists(args.model_mapping):
print(f"Loading model mapping from {args.model_mapping}")
model_mapping = load_model_mapping(args.model_mapping)
print(f"Loaded {len(model_mapping)} model mappings")
# Initialize model
print(f"\nInitializing {args.method}...")
if args.method == "CNNDetection":
weights_path = METHODS_DIR / "CNNDetection" / "weights" / "blur_jpg_prob0.5.pth"
model_wrapper = CNNDetectionWrapper(str(weights_path), args.device)
elif args.method == "UnivFD":
weights_path = METHODS_DIR / "UniversalFakeDetect" / "pretrained_weights" / "fc_weights.pth"
model_wrapper = UnivFDWrapper(str(weights_path), args.device)
elif args.method == "LGrad":
# LGrad provides multiple checkpoints: 1class, 2class, 4class
# Default to 4class (trained on Progan car, cat, chair, horse) for best generalization
weights_path = METHODS_DIR / "LGrad" / "CNNDetection" / "weights" / "LGrad-4class-Trainon-Progan_car_cat_chair_horse.pth"
if not weights_path.exists():
# Try alternative names
alt_paths = [
METHODS_DIR / "LGrad" / "CNNDetection" / "weights" / "LGrad-2class-Trainon-Progan_chair_horse.pth",
METHODS_DIR / "LGrad" / "CNNDetection" / "weights" / "LGrad-1class-Trainon-Progan_horse.pth",
]
for alt in alt_paths:
if alt.exists():
weights_path = alt
break
model_wrapper = LGradWrapper(str(weights_path), args.device)
elif args.method == "HiFi":
weights_path = METHODS_DIR / "HiFi_IFDL" / "weights"
model_wrapper = HiFiNetWrapper(str(weights_path), args.device)
elif args.method == "RINE":
weights_path = METHODS_DIR / "RINE" / "ckpt" / "model_4class_trainable.pth"
model_wrapper = RINEWrapper(str(weights_path), args.device)
elif args.method == "DeeCLIP":
weights_path = METHODS_DIR / "DeeCLIP" / "weights" / "deeclip_weight_complete_with_lora_5.pth"
model_wrapper = DeeCLIPWrapper(str(weights_path), args.device)
elif args.method == "DIRE":
# DIRE provides multiple checkpoints (lsun_adm, imagenet_adm, etc.)
# Default to lsun_adm which is trained on LSUN-Bedroom ADM data
weights_path = METHODS_DIR / "DIRE" / "weights" / "lsun_adm.pth"
model_wrapper = DIREWrapper(str(weights_path), args.device)
elif args.method == "WaRPAD":
model_wrapper = WaRPADWrapper(device=args.device)
elif args.method == "RIGID":
model_wrapper = RIGIDWrapper(device=args.device)
elif args.method == "AIDE":
# AIDE provides multiple checkpoints (GenImage_train, progan_train, sd14_train)
# Default to GenImage_train which is trained on GenImage dataset
weights_path = METHODS_DIR / "AIDE" / "weights" / "AIDE_checkpoints" / "GenImage_train.pth"
if not weights_path.exists():
# Try alternative checkpoints
alt_paths = [
METHODS_DIR / "AIDE" / "weights" / "AIDE_checkpoints" / "progan_train.pth",
METHODS_DIR / "AIDE" / "weights" / "AIDE_checkpoints" / "sd14_train.pth",
]
for alt in alt_paths:
if alt.exists():
weights_path = alt
break
model_wrapper = AIDEWrapper(str(weights_path), args.device)
elif args.method == "AEROBLADE":
# AEROBLADE is training-free, uses pretrained VAE autoencoders from HuggingFace
# No weights need to be downloaded separately
model_wrapper = AEROBLADEWrapper(device=args.device)
elif args.method == "FatFormer":
# FatFormer uses CLIP ViT-L/14 with forgery-aware adapters
# Requires: 1) CLIP weights at pretrained/ViT-L-14.pt, 2) FatFormer checkpoint
weights_path = METHODS_DIR / "FatFormer" / "pretrained" / "fatformer_4class_ckpt.pth"
if not weights_path.exists():
raise FileNotFoundError(
f"FatFormer checkpoint not found at {weights_path}. "
"Download from: https://drive.google.com/file/d/1Q_Kgq4ygDf8XEHgAf-SgDN6Ru_IOTLkj/view"
)
model_wrapper = FatFormerWrapper(str(weights_path), args.device)
elif args.method == "ManifoldBias":
# ManifoldBias is a training-free zero-shot method
# Uses SD v1.4 (UNet, VAE), CLIP, and LLaVA for auto-captioning
# Models are downloaded from HuggingFace on first use
model_wrapper = ManifoldBiasWrapper(device=args.device)
elif args.method == "NPR":
# NPR detects upsampling artifacts in CNN-based generators
# Default checkpoint: NPR.pth (trained on ProGAN 4-class)
weights_path = METHODS_DIR / "NPR" / "NPR.pth"
if not weights_path.exists():
# Try alternative checkpoint
alt_path = METHODS_DIR / "NPR" / "model_epoch_last_3090.pth"
if alt_path.exists():
weights_path = alt_path
model_wrapper = NPRWrapper(str(weights_path), args.device)
elif args.method == "AlignedForensics":
# AlignedForensics uses aligned real/fake pairs for training
# ResNet-50 with no downsampling in first layer (stride=1)
# Multiple checkpoints available from Google Drive
weights_path = METHODS_DIR / "AlignedForensics" / "weights" / "ours.pth"
if not weights_path.exists():
# Try alternative checkpoints
alt_paths = [
METHODS_DIR / "AlignedForensics" / "test_code" / "weights" / "ours-sync" / "weights.pth",
METHODS_DIR / "AlignedForensics" / "weights" / "ours_sync.pth",
METHODS_DIR / "AlignedForensics" / "weights" / "model_epoch_best.pth",
]
for alt in alt_paths:
if alt.exists():
weights_path = alt
break
model_wrapper = AlignedForensicsWrapper(str(weights_path), args.device)
elif args.method == "Effort":
# Effort uses CLIP ViT-L/14 with SVD orthogonal decomposition
# GenImage checkpoint trained on Stable Diffusion v1.4 data
weights_path = METHODS_DIR / "Effort" / "DeepfakeBench" / "training" / "weights" / "genimage_sd14.pth"
if not weights_path.exists():
# Try alternative checkpoints
alt_paths = [
METHODS_DIR / "Effort" / "DeepfakeBench" / "training" / "weights" / "chameleon_sd14.pth",
METHODS_DIR / "Effort" / "DeepfakeBench" / "training" / "weights" / "faceforensics.pth",
]
for alt in alt_paths:
if alt.exists():
weights_path = alt
break
model_wrapper = EffortWrapper(str(weights_path), args.device)
else:
raise ValueError(f"Unknown method: {args.method}")
print(f"Model initialized on {args.device}")
# Get method-specific transform and target size (if applicable)
# Some methods like WaRPAD require higher resolution input
method_transform = None
method_target_size = 224 # Default
if args.method == "WaRPAD":
method_transform = WaRPADWrapper.get_transform()
method_target_size = WaRPADWrapper.get_target_size()
print(f"Using WaRPAD-specific transform (target size: {method_target_size}x{method_target_size})")
elif args.method == "Effort":
method_transform = EffortWrapper.get_transform()
method_target_size = EffortWrapper.get_target_size()
print(f"Using Effort CLIP transform (target size: {method_target_size}x{method_target_size})")
# Check if this is a training-free method
is_training_free = args.method in TRAINING_FREE_METHODS
# Evaluate on real images first (if real_root is provided)
real_metrics = None
real_dataset = None
real_preds = []
real_probs = []
real_labels = []
if args.real_root and os.path.isdir(args.real_root):
print(f"\n{'='*60}")
print("EVALUATING ON REAL IMAGES")
print(f"{'='*60}")
print(f"Real image root: {args.real_root}")
print(f"Number of samples: {args.real_samples}")
real_dataset = create_real_dataset(
args.real_root, args.real_samples,
transform=method_transform, target_size=method_target_size
)
print(f"Loaded {len(real_dataset)} real images")
# For training-free methods, we need to store predictions to pair with fake images later
if is_training_free:
print("Collecting real image predictions for per-model AUC/AP calculation...")
real_loader = DataLoader(
real_dataset,
batch_size=args.batch_size,
shuffle=False,
num_workers=args.num_workers,
pin_memory=True,
)
for images, labels, _ in tqdm(real_loader, desc="Processing real images"):
preds, probs = model_wrapper.predict(images)
real_preds.extend(preds)
real_probs.extend(probs)
real_labels.extend(labels.tolist())
real_metrics = compute_metrics(real_preds, real_labels, real_probs)
else:
real_metrics = evaluate_model(
model_wrapper,
real_dataset,
args.batch_size,
args.num_workers,
)
print(f"\nReal Image Results:")
print(f" Accuracy: {real_metrics['accuracy']:.4f}")
print(f" Precision: {real_metrics['precision']:.4f}")
print(f" Recall: {real_metrics['recall']:.4f}")
print(f" F1: {real_metrics['f1']:.4f}")
# Note: For real images, accuracy = proportion correctly classified as real (prediction=0)
# High accuracy means model correctly identifies real images as real
# Evaluate per model (fake images)
print(f"\n{'='*60}")
print("EVALUATING ON AI-GENERATED IMAGES (PER MODEL)")
print(f"{'='*60}")
print(f"ACID root: {args.acid_root}")
print(f"Samples per model: {args.samples_per_model}")
# Create datasets first (so we can save image paths)
fake_datasets = create_per_model_datasets(
args.acid_root, model_mapping, args.samples_per_model,
transform=method_transform, target_size=method_target_size
)
# Evaluate each model
if is_training_free and real_preds:
# For training-free methods, pair each AI model with real images for proper AUC/AP
print(f"\n[Training-free method: pairing {len(real_preds)} real images with each AI model for AUC/AP]")
results = evaluate_per_model_with_real(
model_wrapper,
fake_datasets,
real_preds,
real_probs,
real_labels,
args.batch_size,
args.num_workers,
)
else:
# For trained methods, evaluate fake images only (threshold-based metrics are meaningful)
results = {}
for model_id, dataset in tqdm(fake_datasets.items(), desc="Evaluating per model"):
if len(dataset) > 0:
metrics = evaluate_model(model_wrapper, dataset, args.batch_size, args.num_workers)
results[model_id] = metrics
# Save results
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
output_path = os.path.join(args.output_dir, f"{args.method}_results_{timestamp}.csv")
save_results(results, model_mapping, output_path, args.method)
print(f"\nResults saved to {output_path}")
# Save real image results separately if available
if real_metrics:
real_output_path = os.path.join(args.output_dir, f"{args.method}_real_results_{timestamp}.csv")
with open(real_output_path, "w", newline="") as f:
writer = csv.writer(f)
writer.writerow(["method", "dataset", "accuracy", "precision", "recall", "f1", "auc", "timestamp"])
writer.writerow([
args.method,
"real",
f"{real_metrics.get('accuracy', 0):.4f}",
f"{real_metrics.get('precision', 0):.4f}",
f"{real_metrics.get('recall', 0):.4f}",
f"{real_metrics.get('f1', 0):.4f}",
f"{real_metrics.get('auc', 'nan'):.4f}" if isinstance(real_metrics.get('auc'), (int, float)) else "nan",
timestamp,
])
print(f"Real results saved to {real_output_path}")
# Save image paths for reproducibility
image_paths_file = os.path.join(args.output_dir, f"{args.method}_image_paths_{timestamp}.json")
save_image_paths(
image_paths_file,
fake_datasets,
real_dataset,
model_mapping,
)
print(f"Image paths saved to {image_paths_file}")
# Print summary
print_summary(results, model_mapping, args.method)
# Print combined summary
if real_metrics:
is_training_free = args.method in TRAINING_FREE_METHODS
print(f"\n{'='*60}")
print("COMBINED SUMMARY")
print(f"{'='*60}")
if is_training_free:
# For training-free methods, show AUC/AP as primary metrics
fake_aucs = [m.get("auc", 0) for m in results.values()]
fake_aps = [m.get("ap", 0) for m in results.values()]
mean_fake_auc = sum(fake_aucs) / len(fake_aucs) if fake_aucs else 0
mean_fake_ap = sum(fake_aps) / len(fake_aps) if fake_aps else 0
print(f"[Training-free method: primary metrics are AUC/AP]")
print(f"Real Images AUC: {real_metrics.get('auc', 0):.4f}")
print(f"Fake Images Mean AUC: {mean_fake_auc:.4f}")
print(f"Real Images AP: {real_metrics.get('ap', 0):.4f}")
print(f"Fake Images Mean AP: {mean_fake_ap:.4f}")
else:
fake_accuracies = [m["accuracy"] for m in results.values()]
mean_fake_acc = sum(fake_accuracies) / len(fake_accuracies) if fake_accuracies else 0
print(f"Real Images Accuracy (correctly classified as real): {real_metrics['accuracy']:.4f}")
print(f"Fake Images Accuracy (correctly classified as fake): {mean_fake_acc:.4f}")
print(f"{'='*60}")
if __name__ == "__main__":
raise SystemExit("Internal wrappers: use scripts/eval/evaluate_pretrained_detectors.py or the dedicated DIRE/training-free evaluator.")
#!/usr/bin/env python3
"""
Unified evaluation script for legacy AI-generated image detection methods on ACID dataset.
This script evaluates CNNDetection and UnivFD pretrained models to verify that
existing methods struggle to generalize to unseen AI models in the ACID dataset.
Usage:
python evaluate_legacy.py --method CNNDetection --acid-root /path/to/acid/images
python evaluate_legacy.py --method UnivFD --acid-root /path/to/acid/images
"""
import argparse
import csv
import os
import sys
from datetime import datetime
from pathlib import Path
from typing import Dict, List, Tuple, Optional
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader
from tqdm import tqdm
import torchvision.transforms as T
# Define directories first
SCRIPT_DIR = Path(__file__).resolve().parent
METHODS_DIR = SCRIPT_DIR.parent / "methods"
# Import local eval_utils BEFORE modifying sys.path to avoid conflicts with method utils
from eval_utils import (
load_model_mapping,
get_model_folders,
get_image_files,
ACIDEvalDataset,
create_per_model_datasets,
create_real_dataset,
get_model_name,
compute_metrics,
save_image_paths,
)
# Training-free methods that use relative scores without learned thresholds.
# For these methods, AUC and AP are the primary metrics (accuracy is less meaningful).
TRAINING_FREE_METHODS = {"AEROBLADE", "WaRPAD", "RIGID", "ManifoldBias"}
# Add method directories to path for their imports (after local utils import)
# NOTE: We intentionally DO NOT add WaRPAD, RINE/src, or other paths with utils.py files
# that could conflict with HiFi_IFDL's utils/utils.py package structure.
# These will be added dynamically in their respective wrappers.
sys.path.insert(0, str(METHODS_DIR / "CNNDetection"))
sys.path.insert(0, str(METHODS_DIR / "UniversalFakeDetect"))
sys.path.insert(0, str(METHODS_DIR / "LGrad" / "CNNDetection"))
sys.path.insert(0, str(METHODS_DIR / "FusingGlobalandLocal"))
sys.path.insert(0, str(METHODS_DIR / "DeeCLIP"))
sys.path.insert(0, str(METHODS_DIR / "DIRE"))
class CNNDetectionWrapper:
"""Wrapper for CNNDetection model."""
def __init__(self, weights_path: str, device: str = "cuda"):
if not Path(weights_path).is_file():
raise FileNotFoundError(weights_path)
self.device = device
# Import CNNDetection model using importlib for reliable path handling
import importlib.util
resnet_path = METHODS_DIR / "CNNDetection" / "networks" / "resnet.py"
spec = importlib.util.spec_from_file_location("resnet", resnet_path)
resnet_module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(resnet_module)
resnet50 = resnet_module.resnet50
self.model = resnet50(num_classes=1)
state_dict = torch.load(weights_path, map_location="cpu", weights_only=False)
# Handle different state dict formats
if "model" in state_dict:
state_dict = state_dict["model"]
self.model.load_state_dict(state_dict)
self.model = self.model.to(device)
self.model.eval()
# CNNDetection uses ImageNet normalization
import torchvision.transforms as T
self.transform = T.Compose([
T.Resize(256),
T.CenterCrop(224),
T.ToTensor(),
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
def predict(self, images: torch.Tensor) -> Tuple[List[int], List[float]]:
"""