Datasets:

Shining31
/

WildGen

#!/usr/bin/env python3
"""
Evaluate all legacy AI-generated image detection methods on real images only.

This script evaluates how well each method correctly identifies real images as real.
A good detector should have high accuracy (correctly predicting label=0 for real images).

Usage:
    python evaluate_real_only.py --real-root /path/to/real/images --num-samples 1000

    # Or use defaults
    python evaluate_real_only.py
"""

import argparse
import csv
import json
import os
import sys
from datetime import datetime
from pathlib import Path
from typing import Dict, List, Tuple

import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision.transforms as T
from torch.utils.data import DataLoader
from tqdm import tqdm

# Define directories
SCRIPT_DIR = Path(__file__).resolve().parent
METHODS_DIR = SCRIPT_DIR.parent / "methods"

# Import local eval_utils
from eval_utils import (
    get_image_files,
    ACIDEvalDataset,
    compute_metrics,
)

# All available methods
ALL_METHODS = [
    "CNNDetection",
    "UnivFD",
    "LGrad",
    "HiFi",
    "RINE",
    "DeeCLIP",
    "DIRE",
    "WaRPAD",
    "RIGID",
    "AIDE",
    "AEROBLADE",
    "FatFormer",
    "ManifoldBias",
    "NPR",
    "AlignedForensics",
    "Effort",
]

# Training-free methods (use relative scores without learned thresholds)
TRAINING_FREE_METHODS = {"AEROBLADE", "WaRPAD", "RIGID", "ManifoldBias"}


def create_real_only_dataset(real_root: str, num_samples: int, transform=None, target_size: int = 224):
    """Create dataset containing only real images."""
    image_paths = get_image_files(real_root, limit=num_samples, seed=42)
    # All labels are 0 (real)
    labels = [0] * len(image_paths)
    return ACIDEvalDataset(image_paths, labels, transform=transform, target_size=target_size)


def evaluate_real_images(model_wrapper, dataset, batch_size: int, num_workers: int) -> Dict:
    """Evaluate model on real images dataset."""
    loader = DataLoader(
        dataset,
        batch_size=batch_size,
        shuffle=False,
        num_workers=num_workers,
        pin_memory=True,
    )

    all_preds = []
    all_probs = []
    all_labels = []

    for images, labels, _ in tqdm(loader, desc="Evaluating", leave=False):
        preds, probs = model_wrapper.predict(images)
        all_preds.extend(preds)
        all_probs.extend(probs)
        all_labels.extend(labels.tolist())

    metrics = compute_metrics(all_preds, all_labels, all_probs)

    # Add additional statistics
    metrics["num_samples"] = len(all_labels)
    metrics["num_correct"] = sum(1 for p, l in zip(all_preds, all_labels) if p == l)
    metrics["num_false_positives"] = sum(1 for p in all_preds if p == 1)  # Real predicted as fake
    metrics["false_positive_rate"] = metrics["num_false_positives"] / len(all_preds) if all_preds else 0

    return metrics


# =============================================================================
# Method Wrappers - Implemented directly to avoid import conflicts
# =============================================================================

def _cleanup_module_cache(prefixes):
    """Remove modules matching prefixes from sys.modules to avoid import conflicts."""
    to_remove = [key for key in sys.modules.keys()
                 if any(key == p or key.startswith(p + ".") for p in prefixes)]
    for key in to_remove:
        del sys.modules[key]


class HiFiNetWrapper:
    """Wrapper for HiFi-Net (Hierarchical Fine-Grained) detector.

    Uses simple directory change and path manipulation for imports.
    """

    def __init__(self, weights_path: str, device: str = "cuda"):
        if not Path(weights_path).is_dir():
            raise FileNotFoundError(weights_path)
        self.device = device

        hifi_path = METHODS_DIR / "HiFi_IFDL"

        # Save original state
        original_cwd = os.getcwd()
        original_path = sys.path.copy()

        # Clean up any conflicting modules
        _cleanup_module_cache(["models", "utils", "HiFi_Net"])

        # Change to HiFi directory for proper imports
        os.chdir(str(hifi_path))
        sys.path.insert(0, str(hifi_path))

        try:
            # Simple import - works when in correct directory
            from HiFi_Net import HiFi_Net
            self.hifi = HiFi_Net()
            self.FENet = self.hifi.FENet
            self.SegNet = self.hifi.SegNet

        finally:
            os.chdir(original_cwd)
            # Restore sys.path
            sys.path[:] = original_path
            # Clean up HiFi modules to avoid conflicts with other methods
            _cleanup_module_cache(["models", "utils", "HiFi_Net"])

        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 prediction."""
        images = images.to(self.device)

        # Normalize to [0, 1] range expected by HiFi
        if images.max() > 1.0:
            images = images / 255.0

        output = self.FENet(images)
        mask1_fea, mask1_binary, out0, out1, out2, out3 = self.SegNet(output, images)

        # out3 contains classification logits (3 classes: 0=real, 1+=fake)
        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.

    Fixed to handle module import conflicts by using importlib.
    """

    def __init__(self, weights_path: str, device: str = "cuda"):
        if not Path(weights_path).is_file():
            raise FileNotFoundError(weights_path)
        self.device = device

        rine_path = METHODS_DIR / "RINE"

        # Use importlib to load RINE's models.py directly
        import importlib.util

        models_spec = importlib.util.spec_from_file_location(
            "rine_models",
            rine_path / "src" / "models.py"
        )
        rine_models = importlib.util.module_from_spec(models_spec)
        models_spec.loader.exec_module(rine_models)

        # 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 = rine_models.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, weights_only=False)
            # RINE saves only trainable params, need special loading
            for name in state_dict:
                try:
                    # Navigate the model hierarchy and set parameters
                    parts = name.split(".")
                    obj = self.model
                    for part in parts[:-1]:
                        if part.isdigit():
                            obj = obj[int(part)]
                        else:
                            obj = getattr(obj, part)
                    setattr(obj, parts[-1], nn.Parameter(state_dict[name]))
                except Exception:
                    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 FatFormerWrapper:
    """Wrapper for FatFormer (Forgery-Aware Transformer) detector.

    Uses simple directory change and path manipulation for imports.
    """

    def __init__(self, weights_path: str, device: str = "cuda"):
        if not Path(weights_path).is_file():
            raise FileNotFoundError(weights_path)
        self.device = device

        fatformer_path = METHODS_DIR / "FatFormer"

        # Save original state
        original_cwd = os.getcwd()
        original_path = sys.path.copy()

        # Clean up any conflicting modules from previous method loads
        _cleanup_module_cache(["models", "utils"])

        # Change to FatFormer directory for proper import
        os.chdir(str(fatformer_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  # Matches checkpoint
                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()

            # Simple import - works when in correct directory
            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)
            # Restore sys.path
            sys.path[:] = original_path
            # Clean up FatFormer modules to avoid conflicts with other methods
            _cleanup_module_cache(["models", "utils"])

        # FatFormer preprocessing
        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]]:
        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)

        outputs = self.model(images)

        # FatFormer outputs logits for 2 classes: [real, fake]
        probs = torch.softmax(outputs, dim=1)
        fake_probs = probs[:, 1]
        preds = (fake_probs > 0.5).int()

        return preds.cpu().tolist(), fake_probs.cpu().tolist()


def load_method_wrapper(method: str, device: str):
    """Dynamically load and initialize method wrapper."""

    # Methods with custom wrappers (fixed for import issues)
    if method == "HiFi":
        wrapper = HiFiNetWrapper(str(METHODS_DIR / "HiFi_IFDL" / "weights"), device)
        return wrapper, None, 256

    elif method == "RINE":
        weights_path = METHODS_DIR / "RINE" / "ckpt" / "model_4class_trainable.pth"
        wrapper = RINEWrapper(str(weights_path), device)
        return wrapper, None, 224

    elif method == "FatFormer":
        weights_path = METHODS_DIR / "FatFormer" / "pretrained" / "fatformer_4class_ckpt.pth"
        wrapper = FatFormerWrapper(str(weights_path), device)
        return wrapper, None, 224

    # For other methods, import from evaluate_legacy
    import importlib.util
    eval_legacy_path = SCRIPT_DIR / "evaluate_legacy.py"
    spec = importlib.util.spec_from_file_location("evaluate_legacy", eval_legacy_path)
    eval_module = importlib.util.module_from_spec(spec)

    # Temporarily suppress output during import
    import io
    import contextlib
    with contextlib.redirect_stdout(io.StringIO()), contextlib.redirect_stderr(io.StringIO()):
        try:
            spec.loader.exec_module(eval_module)
        except Exception:
            pass

    if method == "CNNDetection":
        weights_path = METHODS_DIR / "CNNDetection" / "weights" / "blur_jpg_prob0.5.pth"
        wrapper = eval_module.CNNDetectionWrapper(str(weights_path), device)
        return wrapper, None, 224

    elif method == "UnivFD":
        weights_path = METHODS_DIR / "UniversalFakeDetect" / "pretrained_weights" / "fc_weights.pth"
        wrapper = eval_module.UnivFDWrapper(str(weights_path), device)
        return wrapper, None, 224

    elif method == "LGrad":
        weights_path = METHODS_DIR / "LGrad" / "CNNDetection" / "weights" / "LGrad-4class-Trainon-Progan_car_cat_chair_horse.pth"
        if not weights_path.exists():
            for alt in [
                METHODS_DIR / "LGrad" / "CNNDetection" / "weights" / "LGrad-2class-Trainon-Progan_chair_horse.pth",
                METHODS_DIR / "LGrad" / "CNNDetection" / "weights" / "LGrad-1class-Trainon-Progan_horse.pth",
            ]:
                if alt.exists():
                    weights_path = alt
                    break
        wrapper = eval_module.LGradWrapper(str(weights_path), device)
        return wrapper, None, 224

    elif method == "DeeCLIP":
        weights_path = METHODS_DIR / "DeeCLIP" / "weights" / "deeclip_weight_complete_with_lora_5.pth"
        wrapper = eval_module.DeeCLIPWrapper(str(weights_path), device)
        return wrapper, None, 224

    elif method == "DIRE":
        weights_path = METHODS_DIR / "DIRE" / "weights" / "lsun_adm.pth"
        wrapper = eval_module.DIREWrapper(str(weights_path), device)
        return wrapper, None, 224

    elif method == "WaRPAD":
        wrapper = eval_module.WaRPADWrapper(device=device)
        transform = eval_module.WaRPADWrapper.get_transform()
        target_size = eval_module.WaRPADWrapper.get_target_size()
        return wrapper, transform, target_size

    elif method == "RIGID":
        wrapper = eval_module.RIGIDWrapper(device=device)
        return wrapper, None, 224

    elif method == "AIDE":
        weights_path = METHODS_DIR / "AIDE" / "weights" / "AIDE_checkpoints" / "GenImage_train.pth"
        if not weights_path.exists():
            for alt in [
                METHODS_DIR / "AIDE" / "weights" / "AIDE_checkpoints" / "progan_train.pth",
                METHODS_DIR / "AIDE" / "weights" / "AIDE_checkpoints" / "sd14_train.pth",
            ]:
                if alt.exists():
                    weights_path = alt
                    break
        wrapper = eval_module.AIDEWrapper(str(weights_path), device)
        return wrapper, None, 224

    elif method == "AEROBLADE":
        wrapper = eval_module.AEROBLADEWrapper(device=device)
        return wrapper, None, 224

    elif method == "ManifoldBias":
        wrapper = eval_module.ManifoldBiasWrapper(device=device)
        return wrapper, None, 224

    elif method == "NPR":
        weights_path = METHODS_DIR / "NPR" / "NPR.pth"
        if not weights_path.exists():
            alt_path = METHODS_DIR / "NPR" / "model_epoch_last_3090.pth"
            if alt_path.exists():
                weights_path = alt_path
        wrapper = eval_module.NPRWrapper(str(weights_path), device)
        return wrapper, None, 224

    elif method == "AlignedForensics":
        weights_path = METHODS_DIR / "AlignedForensics" / "weights" / "ours.pth"
        if not weights_path.exists():
            for alt in [
                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",
            ]:
                if alt.exists():
                    weights_path = alt
                    break
        wrapper = eval_module.AlignedForensicsWrapper(str(weights_path), device)
        return wrapper, None, 224

    elif method == "Effort":
        weights_path = METHODS_DIR / "Effort" / "DeepfakeBench" / "training" / "weights" / "genimage_sd14.pth"
        if not weights_path.exists():
            for alt in [
                METHODS_DIR / "Effort" / "DeepfakeBench" / "training" / "weights" / "chameleon_sd14.pth",
                METHODS_DIR / "Effort" / "DeepfakeBench" / "training" / "weights" / "faceforensics.pth",
            ]:
                if alt.exists():
                    weights_path = alt
                    break
        wrapper = eval_module.EffortWrapper(str(weights_path), device)
        transform = eval_module.EffortWrapper.get_transform()
        target_size = eval_module.EffortWrapper.get_target_size()
        return wrapper, transform, target_size

    else:
        raise ValueError(f"Unknown method: {method}")


def parse_args():
    parser = argparse.ArgumentParser(
        description="Evaluate legacy detection methods on real images only."
    )
    parser.add_argument(
        "--methods",
        type=str,
        nargs="+",
        default=ALL_METHODS,
        choices=ALL_METHODS,
        help="Methods to evaluate (default: all)",
    )
    parser.add_argument(
        "--real-root",
        type=str,
        default="data_local/images/real",
        help="Root directory of real images",
    )
    parser.add_argument(
        "--num-samples",
        type=int,
        default=1000,
        help="Number of real images to evaluate",
    )
    parser.add_argument(
        "--output-dir",
        type=str,
        default=str(SCRIPT_DIR / "results_real"),
        help="Output directory for results",
    )
    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)

    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")

    print("=" * 70)
    print("LEGACY METHOD EVALUATION ON REAL IMAGES")
    print("=" * 70)
    print(f"Real image root: {args.real_root}")
    print(f"Number of samples: {args.num_samples}")
    print(f"Methods to evaluate: {len(args.methods)}")
    print(f"Output directory: {args.output_dir}")
    print(f"Device: {args.device}")
    print("=" * 70)

    # Check real root exists
    if not os.path.isdir(args.real_root):
        print(f"Error: Real image directory not found: {args.real_root}")
        sys.exit(1)

    # Results storage
    all_results = {}
    failed_methods = []

    # Summary CSV
    summary_path = os.path.join(args.output_dir, f"summary_{timestamp}.csv")

    with open(summary_path, "w", newline="") as f:
        writer = csv.writer(f)
        writer.writerow([
            "method", "accuracy", "precision", "recall", "f1",
            "false_positive_rate", "num_samples", "num_false_positives", "timestamp"
        ])

        for method in args.methods:
            print(f"\n{'='*70}")
            print(f"Evaluating: {method}")
            print("=" * 70)

            try:
                # Load method
                print(f"Loading {method}...")
                wrapper, transform, target_size = load_method_wrapper(method, args.device)
                print(f"  Target size: {target_size}")

                # Create dataset
                dataset = create_real_only_dataset(
                    args.real_root,
                    args.num_samples,
                    transform=transform,
                    target_size=target_size
                )
                print(f"  Loaded {len(dataset)} real images")

                # Evaluate
                metrics = evaluate_real_images(
                    wrapper, dataset, args.batch_size, args.num_workers
                )

                all_results[method] = metrics

                # Print results
                print(f"\n  Results for {method}:")
                print(f"    Accuracy: {metrics['accuracy']:.4f}")
                print(f"    Precision: {metrics['precision']:.4f}")
                print(f"    Recall: {metrics['recall']:.4f}")
                print(f"    F1: {metrics['f1']:.4f}")
                print(f"    False Positive Rate: {metrics['false_positive_rate']:.4f}")
                print(f"    False Positives: {metrics['num_false_positives']}/{metrics['num_samples']}")

                # Write to CSV
                writer.writerow([
                    method,
                    f"{metrics['accuracy']:.4f}",
                    f"{metrics['precision']:.4f}",
                    f"{metrics['recall']:.4f}",
                    f"{metrics['f1']:.4f}",
                    f"{metrics['false_positive_rate']:.4f}",
                    metrics['num_samples'],
                    metrics['num_false_positives'],
                    timestamp,
                ])
                f.flush()

                # Clean up GPU memory
                del wrapper
                torch.cuda.empty_cache()

            except Exception as e:
                print(f"  ERROR: {method} failed - {str(e)}")
                import traceback
                traceback.print_exc()
                failed_methods.append((method, str(e)))
                continue

    # Save detailed results as JSON
    json_path = os.path.join(args.output_dir, f"detailed_results_{timestamp}.json")
    with open(json_path, "w") as f:
        json.dump({
            "timestamp": timestamp,
            "config": {
                "real_root": args.real_root,
                "num_samples": args.num_samples,
                "device": args.device,
            },
            "results": all_results,
            "failed_methods": failed_methods,
        }, f, indent=2)

    # Print summary
    print("\n" + "=" * 70)
    print("SUMMARY")
    print("=" * 70)

    if all_results:
        print(f"\n{'Method':<20} {'Accuracy':>10} {'FPR':>10} {'FP Count':>12}")
        print("-" * 55)

        # Sort by accuracy (descending)
        sorted_results = sorted(all_results.items(), key=lambda x: x[1]['accuracy'], reverse=True)
        for method, metrics in sorted_results:
            print(f"{method:<20} {metrics['accuracy']:>10.4f} {metrics['false_positive_rate']:>10.4f} {metrics['num_false_positives']:>8}/{metrics['num_samples']}")

    if failed_methods:
        print(f"\nFailed methods ({len(failed_methods)}):")
        for method, error in failed_methods:
            print(f"  - {method}: {error[:50]}...")

    print(f"\nResults saved to:")
    print(f"  Summary CSV: {summary_path}")
    print(f"  Detailed JSON: {json_path}")
    print("=" * 70)


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
	"""
	Evaluate all legacy AI-generated image detection methods on real images only.

	This script evaluates how well each method correctly identifies real images as real.
	A good detector should have high accuracy (correctly predicting label=0 for real images).

	Usage:
	python evaluate_real_only.py --real-root /path/to/real/images --num-samples 1000

	# Or use defaults
	python evaluate_real_only.py
	"""

	import argparse
	import csv
	import json
	import os
	import sys
	from datetime import datetime
	from pathlib import Path
	from typing import Dict, List, Tuple

	import torch
	import torch.nn as nn
	import torch.nn.functional as F
	import torchvision.transforms as T
	from torch.utils.data import DataLoader
	from tqdm import tqdm

	# Define directories
	SCRIPT_DIR = Path(__file__).resolve().parent
	METHODS_DIR = SCRIPT_DIR.parent / "methods"

	# Import local eval_utils
	from eval_utils import (
	get_image_files,
	ACIDEvalDataset,
	compute_metrics,
	)

	# All available methods
	ALL_METHODS = [
	"CNNDetection",
	"UnivFD",
	"LGrad",
	"HiFi",
	"RINE",
	"DeeCLIP",
	"DIRE",
	"WaRPAD",
	"RIGID",
	"AIDE",
	"AEROBLADE",
	"FatFormer",
	"ManifoldBias",
	"NPR",
	"AlignedForensics",
	"Effort",
	]

	# Training-free methods (use relative scores without learned thresholds)
	TRAINING_FREE_METHODS = {"AEROBLADE", "WaRPAD", "RIGID", "ManifoldBias"}


	def create_real_only_dataset(real_root: str, num_samples: int, transform=None, target_size: int = 224):
	"""Create dataset containing only real images."""
	image_paths = get_image_files(real_root, limit=num_samples, seed=42)
	# All labels are 0 (real)
	labels = [0] * len(image_paths)
	return ACIDEvalDataset(image_paths, labels, transform=transform, target_size=target_size)


	def evaluate_real_images(model_wrapper, dataset, batch_size: int, num_workers: int) -> Dict:
	"""Evaluate model on real images dataset."""
	loader = DataLoader(
	dataset,
	batch_size=batch_size,
	shuffle=False,
	num_workers=num_workers,
	pin_memory=True,
	)

	all_preds = []
	all_probs = []
	all_labels = []

	for images, labels, _ in tqdm(loader, desc="Evaluating", leave=False):
	preds, probs = model_wrapper.predict(images)
	all_preds.extend(preds)
	all_probs.extend(probs)
	all_labels.extend(labels.tolist())

	metrics = compute_metrics(all_preds, all_labels, all_probs)

	# Add additional statistics
	metrics["num_samples"] = len(all_labels)
	metrics["num_correct"] = sum(1 for p, l in zip(all_preds, all_labels) if p == l)
	metrics["num_false_positives"] = sum(1 for p in all_preds if p == 1) # Real predicted as fake
	metrics["false_positive_rate"] = metrics["num_false_positives"] / len(all_preds) if all_preds else 0

	return metrics


	# =============================================================================
	# Method Wrappers - Implemented directly to avoid import conflicts
	# =============================================================================

	def _cleanup_module_cache(prefixes):
	"""Remove modules matching prefixes from sys.modules to avoid import conflicts."""
	to_remove = [key for key in sys.modules.keys()
	if any(key == p or key.startswith(p + ".") for p in prefixes)]
	for key in to_remove:
	del sys.modules[key]


	class HiFiNetWrapper:
	"""Wrapper for HiFi-Net (Hierarchical Fine-Grained) detector.

	Uses simple directory change and path manipulation for imports.
	"""

	def __init__(self, weights_path: str, device: str = "cuda"):
	if not Path(weights_path).is_dir():
	raise FileNotFoundError(weights_path)
	self.device = device

	hifi_path = METHODS_DIR / "HiFi_IFDL"

	# Save original state
	original_cwd = os.getcwd()
	original_path = sys.path.copy()

	# Clean up any conflicting modules
	_cleanup_module_cache(["models", "utils", "HiFi_Net"])

	# Change to HiFi directory for proper imports
	os.chdir(str(hifi_path))
	sys.path.insert(0, str(hifi_path))

	try:
	# Simple import - works when in correct directory
	from HiFi_Net import HiFi_Net
	self.hifi = HiFi_Net()
	self.FENet = self.hifi.FENet
	self.SegNet = self.hifi.SegNet

	finally:
	os.chdir(original_cwd)
	# Restore sys.path
	sys.path[:] = original_path
	# Clean up HiFi modules to avoid conflicts with other methods
	_cleanup_module_cache(["models", "utils", "HiFi_Net"])

	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 prediction."""
	images = images.to(self.device)

	# Normalize to [0, 1] range expected by HiFi
	if images.max() > 1.0:
	images = images / 255.0

	output = self.FENet(images)
	mask1_fea, mask1_binary, out0, out1, out2, out3 = self.SegNet(output, images)

	# out3 contains classification logits (3 classes: 0=real, 1+=fake)
	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.

	Fixed to handle module import conflicts by using importlib.
	"""

	def __init__(self, weights_path: str, device: str = "cuda"):
	if not Path(weights_path).is_file():
	raise FileNotFoundError(weights_path)
	self.device = device

	rine_path = METHODS_DIR / "RINE"

	# Use importlib to load RINE's models.py directly
	import importlib.util

	models_spec = importlib.util.spec_from_file_location(
	"rine_models",
	rine_path / "src" / "models.py"
	)
	rine_models = importlib.util.module_from_spec(models_spec)
	models_spec.loader.exec_module(rine_models)

	# 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 = rine_models.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, weights_only=False)
	# RINE saves only trainable params, need special loading
	for name in state_dict:
	try:
	# Navigate the model hierarchy and set parameters
	parts = name.split(".")
	obj = self.model
	for part in parts[:-1]:
	if part.isdigit():
	obj = obj[int(part)]
	else:
	obj = getattr(obj, part)
	setattr(obj, parts[-1], nn.Parameter(state_dict[name]))
	except Exception:
	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 FatFormerWrapper:
	"""Wrapper for FatFormer (Forgery-Aware Transformer) detector.

	Uses simple directory change and path manipulation for imports.
	"""

	def __init__(self, weights_path: str, device: str = "cuda"):
	if not Path(weights_path).is_file():
	raise FileNotFoundError(weights_path)
	self.device = device

	fatformer_path = METHODS_DIR / "FatFormer"

	# Save original state
	original_cwd = os.getcwd()
	original_path = sys.path.copy()

	# Clean up any conflicting modules from previous method loads
	_cleanup_module_cache(["models", "utils"])

	# Change to FatFormer directory for proper import
	os.chdir(str(fatformer_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 # Matches checkpoint
	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()

	# Simple import - works when in correct directory
	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)
	# Restore sys.path
	sys.path[:] = original_path
	# Clean up FatFormer modules to avoid conflicts with other methods
	_cleanup_module_cache(["models", "utils"])

	# FatFormer preprocessing
	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]]:
	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)

	outputs = self.model(images)

	# FatFormer outputs logits for 2 classes: [real, fake]
	probs = torch.softmax(outputs, dim=1)
	fake_probs = probs[:, 1]
	preds = (fake_probs > 0.5).int()

	return preds.cpu().tolist(), fake_probs.cpu().tolist()


	def load_method_wrapper(method: str, device: str):
	"""Dynamically load and initialize method wrapper."""

	# Methods with custom wrappers (fixed for import issues)
	if method == "HiFi":
	wrapper = HiFiNetWrapper(str(METHODS_DIR / "HiFi_IFDL" / "weights"), device)
	return wrapper, None, 256

	elif method == "RINE":
	weights_path = METHODS_DIR / "RINE" / "ckpt" / "model_4class_trainable.pth"
	wrapper = RINEWrapper(str(weights_path), device)
	return wrapper, None, 224

	elif method == "FatFormer":
	weights_path = METHODS_DIR / "FatFormer" / "pretrained" / "fatformer_4class_ckpt.pth"
	wrapper = FatFormerWrapper(str(weights_path), device)
	return wrapper, None, 224

	# For other methods, import from evaluate_legacy
	import importlib.util
	eval_legacy_path = SCRIPT_DIR / "evaluate_legacy.py"
	spec = importlib.util.spec_from_file_location("evaluate_legacy", eval_legacy_path)
	eval_module = importlib.util.module_from_spec(spec)

	# Temporarily suppress output during import
	import io
	import contextlib
	with contextlib.redirect_stdout(io.StringIO()), contextlib.redirect_stderr(io.StringIO()):
	try:
	spec.loader.exec_module(eval_module)
	except Exception:
	pass

	if method == "CNNDetection":
	weights_path = METHODS_DIR / "CNNDetection" / "weights" / "blur_jpg_prob0.5.pth"
	wrapper = eval_module.CNNDetectionWrapper(str(weights_path), device)
	return wrapper, None, 224

	elif method == "UnivFD":
	weights_path = METHODS_DIR / "UniversalFakeDetect" / "pretrained_weights" / "fc_weights.pth"
	wrapper = eval_module.UnivFDWrapper(str(weights_path), device)
	return wrapper, None, 224

	elif method == "LGrad":
	weights_path = METHODS_DIR / "LGrad" / "CNNDetection" / "weights" / "LGrad-4class-Trainon-Progan_car_cat_chair_horse.pth"
	if not weights_path.exists():
	for alt in [
	METHODS_DIR / "LGrad" / "CNNDetection" / "weights" / "LGrad-2class-Trainon-Progan_chair_horse.pth",
	METHODS_DIR / "LGrad" / "CNNDetection" / "weights" / "LGrad-1class-Trainon-Progan_horse.pth",
	]:
	if alt.exists():
	weights_path = alt
	break
	wrapper = eval_module.LGradWrapper(str(weights_path), device)
	return wrapper, None, 224

	elif method == "DeeCLIP":
	weights_path = METHODS_DIR / "DeeCLIP" / "weights" / "deeclip_weight_complete_with_lora_5.pth"
	wrapper = eval_module.DeeCLIPWrapper(str(weights_path), device)
	return wrapper, None, 224

	elif method == "DIRE":
	weights_path = METHODS_DIR / "DIRE" / "weights" / "lsun_adm.pth"
	wrapper = eval_module.DIREWrapper(str(weights_path), device)
	return wrapper, None, 224

	elif method == "WaRPAD":
	wrapper = eval_module.WaRPADWrapper(device=device)
	transform = eval_module.WaRPADWrapper.get_transform()
	target_size = eval_module.WaRPADWrapper.get_target_size()
	return wrapper, transform, target_size

	elif method == "RIGID":
	wrapper = eval_module.RIGIDWrapper(device=device)
	return wrapper, None, 224

	elif method == "AIDE":
	weights_path = METHODS_DIR / "AIDE" / "weights" / "AIDE_checkpoints" / "GenImage_train.pth"
	if not weights_path.exists():
	for alt in [
	METHODS_DIR / "AIDE" / "weights" / "AIDE_checkpoints" / "progan_train.pth",
	METHODS_DIR / "AIDE" / "weights" / "AIDE_checkpoints" / "sd14_train.pth",
	]:
	if alt.exists():
	weights_path = alt
	break
	wrapper = eval_module.AIDEWrapper(str(weights_path), device)
	return wrapper, None, 224

	elif method == "AEROBLADE":
	wrapper = eval_module.AEROBLADEWrapper(device=device)
	return wrapper, None, 224

	elif method == "ManifoldBias":
	wrapper = eval_module.ManifoldBiasWrapper(device=device)
	return wrapper, None, 224

	elif method == "NPR":
	weights_path = METHODS_DIR / "NPR" / "NPR.pth"
	if not weights_path.exists():
	alt_path = METHODS_DIR / "NPR" / "model_epoch_last_3090.pth"
	if alt_path.exists():
	weights_path = alt_path
	wrapper = eval_module.NPRWrapper(str(weights_path), device)
	return wrapper, None, 224

	elif method == "AlignedForensics":
	weights_path = METHODS_DIR / "AlignedForensics" / "weights" / "ours.pth"
	if not weights_path.exists():
	for alt in [
	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",
	]:
	if alt.exists():
	weights_path = alt
	break
	wrapper = eval_module.AlignedForensicsWrapper(str(weights_path), device)
	return wrapper, None, 224

	elif method == "Effort":
	weights_path = METHODS_DIR / "Effort" / "DeepfakeBench" / "training" / "weights" / "genimage_sd14.pth"
	if not weights_path.exists():
	for alt in [
	METHODS_DIR / "Effort" / "DeepfakeBench" / "training" / "weights" / "chameleon_sd14.pth",
	METHODS_DIR / "Effort" / "DeepfakeBench" / "training" / "weights" / "faceforensics.pth",
	]:
	if alt.exists():
	weights_path = alt
	break
	wrapper = eval_module.EffortWrapper(str(weights_path), device)
	transform = eval_module.EffortWrapper.get_transform()
	target_size = eval_module.EffortWrapper.get_target_size()
	return wrapper, transform, target_size

	else:
	raise ValueError(f"Unknown method: {method}")


	def parse_args():
	parser = argparse.ArgumentParser(
	description="Evaluate legacy detection methods on real images only."
	)
	parser.add_argument(
	"--methods",
	type=str,
	nargs="+",
	default=ALL_METHODS,
	choices=ALL_METHODS,
	help="Methods to evaluate (default: all)",
	)
	parser.add_argument(
	"--real-root",
	type=str,
	default="data_local/images/real",
	help="Root directory of real images",
	)
	parser.add_argument(
	"--num-samples",
	type=int,
	default=1000,
	help="Number of real images to evaluate",
	)
	parser.add_argument(
	"--output-dir",
	type=str,
	default=str(SCRIPT_DIR / "results_real"),
	help="Output directory for results",
	)
	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)

	timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")

	print("=" * 70)
	print("LEGACY METHOD EVALUATION ON REAL IMAGES")
	print("=" * 70)
	print(f"Real image root: {args.real_root}")
	print(f"Number of samples: {args.num_samples}")
	print(f"Methods to evaluate: {len(args.methods)}")
	print(f"Output directory: {args.output_dir}")
	print(f"Device: {args.device}")
	print("=" * 70)

	# Check real root exists
	if not os.path.isdir(args.real_root):
	print(f"Error: Real image directory not found: {args.real_root}")
	sys.exit(1)

	# Results storage
	all_results = {}
	failed_methods = []

	# Summary CSV
	summary_path = os.path.join(args.output_dir, f"summary_{timestamp}.csv")

	with open(summary_path, "w", newline="") as f:
	writer = csv.writer(f)
	writer.writerow([
	"method", "accuracy", "precision", "recall", "f1",
	"false_positive_rate", "num_samples", "num_false_positives", "timestamp"
	])

	for method in args.methods:
	print(f"\n{'='*70}")
	print(f"Evaluating: {method}")
	print("=" * 70)

	try:
	# Load method
	print(f"Loading {method}...")
	wrapper, transform, target_size = load_method_wrapper(method, args.device)
	print(f" Target size: {target_size}")

	# Create dataset
	dataset = create_real_only_dataset(
	args.real_root,
	args.num_samples,
	transform=transform,
	target_size=target_size
	)
	print(f" Loaded {len(dataset)} real images")

	# Evaluate
	metrics = evaluate_real_images(
	wrapper, dataset, args.batch_size, args.num_workers
	)

	all_results[method] = metrics

	# Print results
	print(f"\n Results for {method}:")
	print(f" Accuracy: {metrics['accuracy']:.4f}")
	print(f" Precision: {metrics['precision']:.4f}")
	print(f" Recall: {metrics['recall']:.4f}")
	print(f" F1: {metrics['f1']:.4f}")
	print(f" False Positive Rate: {metrics['false_positive_rate']:.4f}")
	print(f" False Positives: {metrics['num_false_positives']}/{metrics['num_samples']}")

	# Write to CSV
	writer.writerow([
	method,
	f"{metrics['accuracy']:.4f}",
	f"{metrics['precision']:.4f}",
	f"{metrics['recall']:.4f}",
	f"{metrics['f1']:.4f}",
	f"{metrics['false_positive_rate']:.4f}",
	metrics['num_samples'],
	metrics['num_false_positives'],
	timestamp,
	])
	f.flush()

	# Clean up GPU memory
	del wrapper
	torch.cuda.empty_cache()

	except Exception as e:
	print(f" ERROR: {method} failed - {str(e)}")
	import traceback
	traceback.print_exc()
	failed_methods.append((method, str(e)))
	continue

	# Save detailed results as JSON
	json_path = os.path.join(args.output_dir, f"detailed_results_{timestamp}.json")
	with open(json_path, "w") as f:
	json.dump({
	"timestamp": timestamp,
	"config": {
	"real_root": args.real_root,
	"num_samples": args.num_samples,
	"device": args.device,
	},
	"results": all_results,
	"failed_methods": failed_methods,
	}, f, indent=2)

	# Print summary
	print("\n" + "=" * 70)
	print("SUMMARY")
	print("=" * 70)

	if all_results:
	print(f"\n{'Method':<20} {'Accuracy':>10} {'FPR':>10} {'FP Count':>12}")
	print("-" * 55)

	# Sort by accuracy (descending)
	sorted_results = sorted(all_results.items(), key=lambda x: x[1]['accuracy'], reverse=True)
	for method, metrics in sorted_results:
	print(f"{method:<20} {metrics['accuracy']:>10.4f} {metrics['false_positive_rate']:>10.4f} {metrics['num_false_positives']:>8}/{metrics['num_samples']}")

	if failed_methods:
	print(f"\nFailed methods ({len(failed_methods)}):")
	for method, error in failed_methods:
	print(f" - {method}: {error[:50]}...")

	print(f"\nResults saved to:")
	print(f" Summary CSV: {summary_path}")
	print(f" Detailed JSON: {json_path}")
	print("=" * 70)


	if __name__ == "__main__":
	raise SystemExit("Internal wrappers: use scripts/eval/evaluate_pretrained_detectors.py or the dedicated DIRE/training-free evaluator.")