|
|
| 'Evaluate pretrained binary detectors on a fixed AI/real validation split.'
|
|
|
| from __future__ import annotations
|
|
|
| import argparse
|
| import csv
|
| import json
|
| import sys
|
| from collections import defaultdict
|
| from datetime import datetime
|
| from pathlib import Path
|
| from typing import Any
|
|
|
| import torch
|
| import torchvision.transforms as T
|
| from PIL import Image
|
| from torch.utils.data import DataLoader, Dataset
|
| from tqdm import tqdm
|
|
|
|
|
| PROJECT_ROOT = Path(__file__).resolve().parents[2]
|
| LEGACY_EVAL_DIR = PROJECT_ROOT / "legacy" / "evaluation"
|
| DEFAULT_AI_VALIDATION = PROJECT_ROOT / "artifacts" / "metadata" / "fixed_split" / "ai_validation.csv"
|
| DEFAULT_REAL_VALIDATION = PROJECT_ROOT / "artifacts" / "metadata" / "fixed_split" / "real_validation.csv"
|
| DEFAULT_OUTPUT_DIR = PROJECT_ROOT / "artifacts" / "results" / "legacy_current_split_zero_shot"
|
|
|
| if str(LEGACY_EVAL_DIR) not in sys.path:
|
| sys.path.insert(0, str(LEGACY_EVAL_DIR))
|
|
|
| from evaluate_real_only import ALL_METHODS, load_method_wrapper
|
|
|
| csv.field_size_limit(min(sys.maxsize, 2_147_483_647))
|
|
|
|
|
| TRAINING_BASED_METHODS = [
|
| "CNNDetection",
|
| "UnivFD",
|
| "LGrad",
|
| "HiFi",
|
| "RINE",
|
| "DeeCLIP",
|
| "FatFormer",
|
| "AIDE",
|
| "NPR",
|
| "AlignedForensics",
|
| "Effort",
|
| ]
|
|
|
|
|
| class BinaryCSVDataset(Dataset):
|
| """Binary AI/real dataset backed by fixed-split validation CSV rows."""
|
|
|
| def __init__(self, rows: list[dict[str, Any]], transform: Any, target_size: int = 224):
|
| self.rows = rows
|
| self.transform = transform or T.Compose(
|
| [
|
| T.Resize((target_size, target_size)),
|
| T.ToTensor(),
|
| T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
|
| ]
|
| )
|
| self.target_size = target_size
|
|
|
| def __len__(self) -> int:
|
| return len(self.rows)
|
|
|
| def __getitem__(self, idx: int):
|
| row = self.rows[idx]
|
| path = row["image_path"]
|
| try:
|
| image = Image.open(path).convert("RGB")
|
| image = self.transform(image)
|
| except Exception as exc:
|
| raise RuntimeError(f"Failed to load benchmark image: {path}") from exc
|
|
|
| return image, int(row["label"]), row["source_type"], row["source"], path
|
|
|
|
|
| def read_csv(path: Path) -> list[dict[str, str]]:
|
| with path.open("r", newline="", encoding="utf-8") as f:
|
| return list(csv.DictReader(f))
|
|
|
|
|
| def build_rows(
|
| ai_csv: Path,
|
| real_csv: Path,
|
| samples_per_ai_source: int | None,
|
| samples_per_real_source: int | None,
|
| ) -> list[dict[str, Any]]:
|
| rows: list[dict[str, Any]] = []
|
|
|
| ai_groups: dict[str, list[dict[str, str]]] = defaultdict(list)
|
| for row in read_csv(ai_csv):
|
| ai_groups[row["source_model_id"]].append(row)
|
| for source in sorted(ai_groups, key=lambda value: int(value)):
|
| selected = ai_groups[source]
|
| if samples_per_ai_source and samples_per_ai_source > 0:
|
| selected = selected[:samples_per_ai_source]
|
| for row in selected:
|
| rows.append(
|
| {
|
| "image_path": row["image_path"],
|
| "label": 1,
|
| "source_type": "ai",
|
| "source": source,
|
| }
|
| )
|
|
|
| real_groups: dict[str, list[dict[str, str]]] = defaultdict(list)
|
| for row in read_csv(real_csv):
|
| real_groups[row["real_source_label"]].append(row)
|
| for source in sorted(real_groups):
|
| selected = real_groups[source]
|
| if samples_per_real_source and samples_per_real_source > 0:
|
| selected = selected[:samples_per_real_source]
|
| for row in selected:
|
| rows.append(
|
| {
|
| "image_path": row["image_path"],
|
| "label": 0,
|
| "source_type": "real",
|
| "source": source,
|
| }
|
| )
|
|
|
| return rows
|
|
|
|
|
| def compute_summary(method: str, predictions: list[dict[str, Any]]) -> tuple[dict[str, Any], list[dict[str, Any]]]:
|
| ai = [row for row in predictions if row["label"] == 1]
|
| real = [row for row in predictions if row["label"] == 0]
|
| ai_tp = sum(1 for row in ai if row["prediction"] == 1)
|
| real_tn = sum(1 for row in real if row["prediction"] == 0)
|
| ai_recall = ai_tp / len(ai) if ai else 0.0
|
| real_recall = real_tn / len(real) if real else 0.0
|
| balanced_accuracy = (ai_recall + real_recall) / 2.0
|
|
|
| by_source: list[dict[str, Any]] = []
|
| grouped: dict[tuple[str, str], list[dict[str, Any]]] = defaultdict(list)
|
| for row in predictions:
|
| grouped[(row["source_type"], row["source"])].append(row)
|
| for (source_type, source), group in sorted(grouped.items()):
|
| if source_type == "ai":
|
| correct = sum(1 for row in group if row["prediction"] == 1)
|
| metric_name = "ai_recall"
|
| else:
|
| correct = sum(1 for row in group if row["prediction"] == 0)
|
| metric_name = "real_recall"
|
| value = correct / len(group) if group else 0.0
|
| by_source.append(
|
| {
|
| "method": method,
|
| "source_type": source_type,
|
| "source": source,
|
| "num_samples": len(group),
|
| "num_correct": correct,
|
| metric_name: value,
|
| "mean_fake_probability": sum(float(row["fake_probability"]) for row in group) / len(group),
|
| }
|
| )
|
|
|
| summary = {
|
| "method": method,
|
| "ai_samples": len(ai),
|
| "real_samples": len(real),
|
| "ai_recall": ai_recall,
|
| "real_recall": real_recall,
|
| "balanced_accuracy": balanced_accuracy,
|
| "ai_false_negatives": len(ai) - ai_tp,
|
| "real_false_positives": len(real) - real_tn,
|
| }
|
| return summary, by_source
|
|
|
|
|
| def evaluate_method(
|
| method: str,
|
| rows: list[dict[str, Any]],
|
| device: str,
|
| batch_size: int,
|
| num_workers: int,
|
| ) -> tuple[dict[str, Any], list[dict[str, Any]], list[dict[str, Any]]]:
|
| wrapper, transform, target_size = load_method_wrapper(method, device)
|
| if transform is None:
|
| transform = getattr(wrapper, "transform", None)
|
|
|
| dataset = BinaryCSVDataset(rows, transform=transform, target_size=target_size)
|
| loader = DataLoader(
|
| dataset,
|
| batch_size=batch_size,
|
| shuffle=False,
|
| num_workers=num_workers,
|
| pin_memory=device.startswith("cuda"),
|
| )
|
|
|
| predictions: list[dict[str, Any]] = []
|
| for images, labels, source_types, sources, paths in tqdm(loader, desc=method, leave=False):
|
| preds, probs = wrapper.predict(images)
|
| for label, source_type, source, path, pred, prob in zip(labels, source_types, sources, paths, preds, probs):
|
| predictions.append(
|
| {
|
| "method": method,
|
| "label": int(label),
|
| "source_type": str(source_type),
|
| "source": str(source),
|
| "image_path": str(path),
|
| "prediction": int(pred),
|
| "fake_probability": float(prob),
|
| }
|
| )
|
|
|
| summary, by_source = compute_summary(method, predictions)
|
| del wrapper
|
| if torch.cuda.is_available():
|
| torch.cuda.empty_cache()
|
| return summary, by_source, predictions
|
|
|
|
|
| def write_csv(path: Path, rows: list[dict[str, Any]], fieldnames: list[str]) -> None:
|
| path.parent.mkdir(parents=True, exist_ok=True)
|
| with path.open("w", newline="", encoding="utf-8") as f:
|
| writer = csv.DictWriter(f, fieldnames=fieldnames)
|
| writer.writeheader()
|
| writer.writerows(rows)
|
|
|
|
|
| def main() -> None:
|
| parser = argparse.ArgumentParser(description=__doc__)
|
| parser.add_argument("--ai-validation-csv", type=Path, default=DEFAULT_AI_VALIDATION)
|
| parser.add_argument("--real-validation-csv", type=Path, default=DEFAULT_REAL_VALIDATION)
|
| parser.add_argument("--output-dir", type=Path, default=DEFAULT_OUTPUT_DIR)
|
| parser.add_argument("--methods", nargs="+", default=TRAINING_BASED_METHODS, choices=TRAINING_BASED_METHODS)
|
| parser.add_argument("--samples-per-ai-source", type=int, default=0, help="0 means all AI validation rows")
|
| parser.add_argument("--samples-per-real-source", type=int, default=0, help="0 means all real validation rows")
|
| parser.add_argument("--batch-size", type=int, default=32)
|
| parser.add_argument("--num-workers", type=int, default=4)
|
| parser.add_argument("--device", default="cuda" if torch.cuda.is_available() else "cpu")
|
| args = parser.parse_args()
|
|
|
| rows = build_rows(
|
| ai_csv=args.ai_validation_csv,
|
| real_csv=args.real_validation_csv,
|
| samples_per_ai_source=args.samples_per_ai_source if args.samples_per_ai_source > 0 else None,
|
| samples_per_real_source=args.samples_per_real_source if args.samples_per_real_source > 0 else None,
|
| )
|
| timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
|
| run_dir = args.output_dir / timestamp
|
| run_dir.mkdir(parents=True, exist_ok=True)
|
|
|
| print(f"Rows: {len(rows)}")
|
| print(f"Methods: {', '.join(args.methods)}")
|
| print(f"Output: {run_dir}")
|
| print(f"Device: {args.device}")
|
|
|
| summaries: list[dict[str, Any]] = []
|
| by_source_rows: list[dict[str, Any]] = []
|
| failed_methods: list[dict[str, str]] = []
|
|
|
| for method in args.methods:
|
| print(f"\n=== {method} ===")
|
| try:
|
| summary, by_source, predictions = evaluate_method(
|
| method=method,
|
| rows=rows,
|
| device=args.device,
|
| batch_size=args.batch_size,
|
| num_workers=args.num_workers,
|
| )
|
| summaries.append(summary)
|
| by_source_rows.extend(by_source)
|
|
|
| write_csv(
|
| run_dir / f"predictions_{method}.csv",
|
| predictions,
|
| ["method", "label", "source_type", "source", "image_path", "prediction", "fake_probability"],
|
| )
|
| print(
|
| f"AI recall={summary['ai_recall']:.4f} "
|
| f"Real recall={summary['real_recall']:.4f} "
|
| f"BalAcc={summary['balanced_accuracy']:.4f}"
|
| )
|
| except Exception as exc:
|
| print(f"FAILED {method}: {exc}")
|
| failed_methods.append({"method": method, "error": str(exc)})
|
|
|
| write_csv(
|
| run_dir / "overall_results.csv",
|
| summaries,
|
| [
|
| "method",
|
| "ai_samples",
|
| "real_samples",
|
| "ai_recall",
|
| "real_recall",
|
| "balanced_accuracy",
|
| "ai_false_negatives",
|
| "real_false_positives",
|
| ],
|
| )
|
| write_csv(
|
| run_dir / "per_source_results.csv",
|
| by_source_rows,
|
| [
|
| "method",
|
| "source_type",
|
| "source",
|
| "num_samples",
|
| "num_correct",
|
| "ai_recall",
|
| "real_recall",
|
| "mean_fake_probability",
|
| ],
|
| )
|
|
|
| with (run_dir / "run_config.json").open("w", encoding="utf-8") as f:
|
| json.dump(
|
| {
|
| "timestamp": timestamp,
|
| "ai_validation_csv": str(args.ai_validation_csv),
|
| "real_validation_csv": str(args.real_validation_csv),
|
| "methods": args.methods,
|
| "samples_per_ai_source": args.samples_per_ai_source,
|
| "samples_per_real_source": args.samples_per_real_source,
|
| "batch_size": args.batch_size,
|
| "num_workers": args.num_workers,
|
| "device": args.device,
|
| "failed_methods": failed_methods,
|
| },
|
| f,
|
| indent=2,
|
| )
|
|
|
| print(f"\nSaved results to {run_dir}")
|
| if failed_methods:
|
| print("Failed methods:")
|
| for row in failed_methods:
|
| print(f" {row['method']}: {row['error']}")
|
|
|
|
|
| if __name__ == "__main__":
|
| main()
|
|
|
