|
|
| 'Compute per-source balanced AP/AUC and source-macro averages for training-free detectors.'
|
|
|
| from __future__ import annotations
|
|
|
| import argparse
|
| import csv
|
| import json
|
| import random
|
| import sys
|
| from collections import defaultdict
|
| from datetime import datetime
|
| from pathlib import Path
|
| from typing import Any
|
|
|
| import numpy as np
|
| import torch
|
| import torchvision.transforms as T
|
| from PIL import Image
|
| from sklearn.metrics import average_precision_score, roc_auc_score
|
| 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" / "training_free_current_split_table4"
|
|
|
| if str(LEGACY_EVAL_DIR) not in sys.path:
|
| sys.path.insert(0, str(LEGACY_EVAL_DIR))
|
|
|
| from evaluate_real_only import load_method_wrapper
|
|
|
| csv.field_size_limit(min(sys.maxsize, 2_147_483_647))
|
|
|
| TRAINING_FREE_METHODS = ["RIGID", "WaRPAD", "AEROBLADE", "ManifoldBias"]
|
|
|
|
|
| class BinaryRowsDataset(Dataset):
|
| """Binary AI/real dataset backed by selected 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 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 set_seed(seed: int) -> None:
|
| random.seed(seed)
|
| np.random.seed(seed)
|
| torch.manual_seed(seed)
|
| if torch.cuda.is_available():
|
| torch.cuda.manual_seed_all(seed)
|
|
|
|
|
| def select_ai_rows(
|
| ai_csv: Path,
|
| samples_per_source: int,
|
| source_shard_index: int = 0,
|
| source_num_shards: int = 1,
|
| ) -> list[dict[str, Any]]:
|
| grouped: dict[str, list[dict[str, str]]] = defaultdict(list)
|
| for row in read_csv(ai_csv):
|
| grouped[row["source_model_id"]].append(row)
|
|
|
| selected: list[dict[str, Any]] = []
|
| sources = sorted(grouped, key=lambda value: int(value))
|
| sources = [source for idx, source in enumerate(sources) if idx % source_num_shards == source_shard_index]
|
| for source in sources:
|
| source_rows = grouped[source][:samples_per_source]
|
| for row in source_rows:
|
| selected.append(
|
| {
|
| "sample_id": row["sample_id"],
|
| "image_path": row["image_path"],
|
| "label": 1,
|
| "source_type": "ai",
|
| "source": source,
|
| "source_name": row["source_model_name"],
|
| }
|
| )
|
| return selected
|
|
|
|
|
| def select_balanced_real_rows(
|
| real_csv: Path,
|
| total_samples: int,
|
| real_shard_index: int = 0,
|
| real_num_shards: int = 1,
|
| ) -> list[dict[str, Any]]:
|
| grouped: dict[str, list[dict[str, str]]] = defaultdict(list)
|
| for row in read_csv(real_csv):
|
| grouped[row["real_source_label"]].append(row)
|
|
|
| sources = sorted(grouped)
|
| base = total_samples // len(sources)
|
| remainder = total_samples % len(sources)
|
|
|
| selected: list[dict[str, Any]] = []
|
| for idx, source in enumerate(sources):
|
| take = base + (1 if idx < remainder else 0)
|
| for row in grouped[source][:take]:
|
| selected.append(
|
| {
|
| "sample_id": row["sample_id"],
|
| "image_path": row["image_path"],
|
| "label": 0,
|
| "source_type": "real",
|
| "source": source,
|
| "source_name": source,
|
| }
|
| )
|
| return [row for idx, row in enumerate(selected) if idx % real_num_shards == real_shard_index]
|
|
|
|
|
| def evaluate_method(
|
| method: str,
|
| rows: list[dict[str, Any]],
|
| device: str,
|
| batch_size: int,
|
| num_workers: int,
|
| seed: int,
|
| ) -> list[dict[str, Any]]:
|
| set_seed(seed)
|
| wrapper, transform, target_size = load_method_wrapper(method, device)
|
| if transform is None:
|
| transform = getattr(wrapper, "transform", None)
|
|
|
| dataset = BinaryRowsDataset(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),
|
| }
|
| )
|
|
|
| del wrapper
|
| if torch.cuda.is_available():
|
| torch.cuda.empty_cache()
|
| return predictions
|
|
|
|
|
| def read_predictions(path: Path) -> list[dict[str, Any]]:
|
| rows: list[dict[str, Any]] = []
|
| for row in read_csv(path):
|
| rows.append(
|
| {
|
| "method": row["method"],
|
| "label": int(row["label"]),
|
| "source_type": row["source_type"],
|
| "source": row["source"],
|
| "image_path": row["image_path"],
|
| "prediction": int(row["prediction"]),
|
| "fake_probability": float(row["fake_probability"]),
|
| }
|
| )
|
| return rows
|
|
|
|
|
| def summarize_method(method: str, predictions: list[dict[str, Any]]) -> tuple[dict[str, Any], list[dict[str, Any]]]:
|
| real = [row for row in predictions if row["source_type"] == "real"]
|
| ai_by_source: dict[str, list[dict[str, Any]]] = defaultdict(list)
|
| for row in predictions:
|
| if row["source_type"] == "ai":
|
| ai_by_source[row["source"]].append(row)
|
|
|
| per_source: list[dict[str, Any]] = []
|
| for source in sorted(ai_by_source, key=lambda value: int(value)):
|
| ai_rows = ai_by_source[source]
|
| labels = [1] * len(ai_rows) + [0] * len(real)
|
| scores = [row["fake_probability"] for row in ai_rows] + [row["fake_probability"] for row in real]
|
| ap = average_precision_score(labels, scores)
|
| auc = roc_auc_score(labels, scores)
|
| per_source.append(
|
| {
|
| "method": method,
|
| "source": source,
|
| "ai_samples": len(ai_rows),
|
| "real_samples": len(real),
|
| "ap": ap,
|
| "auc": auc,
|
| }
|
| )
|
|
|
| summary = {
|
| "method": method,
|
| "ai_sources": len(per_source),
|
| "ai_samples_total": sum(row["ai_samples"] for row in per_source),
|
| "real_samples_per_pair": len(real),
|
| "macro_ap": float(np.mean([row["ap"] for row in per_source])) if per_source else 0.0,
|
| "macro_auc": float(np.mean([row["auc"] for row in per_source])) if per_source else 0.0,
|
| }
|
| return summary, per_source
|
|
|
|
|
| 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("--run-dir", type=Path, default=None, help="Existing or new run directory")
|
| parser.add_argument("--methods", nargs="+", default=TRAINING_FREE_METHODS, choices=TRAINING_FREE_METHODS)
|
| parser.add_argument("--samples-per-ai-source", type=int, default=100)
|
| parser.add_argument("--real-samples-per-pair", type=int, default=100)
|
| parser.add_argument("--batch-size", type=int, default=16)
|
| parser.add_argument("--num-workers", type=int, default=4)
|
| parser.add_argument("--seed", type=int, default=42)
|
| parser.add_argument("--source-shard-index", type=int, default=0)
|
| parser.add_argument("--source-num-shards", type=int, default=1)
|
| parser.add_argument("--real-shard-index", type=int, default=0)
|
| parser.add_argument("--real-num-shards", type=int, default=1)
|
| parser.add_argument("--reuse-existing", action="store_true")
|
| parser.add_argument("--device", default="cuda" if torch.cuda.is_available() else "cpu")
|
| args = parser.parse_args()
|
|
|
| if args.source_num_shards < 1:
|
| raise ValueError("--source-num-shards must be >= 1")
|
| if not 0 <= args.source_shard_index < args.source_num_shards:
|
| raise ValueError("--source-shard-index must be in [0, source_num_shards)")
|
| if args.real_num_shards < 1:
|
| raise ValueError("--real-num-shards must be >= 1")
|
| if not 0 <= args.real_shard_index < args.real_num_shards:
|
| raise ValueError("--real-shard-index must be in [0, real_num_shards)")
|
|
|
| run_dir = args.run_dir or (args.output_dir / datetime.now().strftime("%Y%m%d_%H%M%S"))
|
| run_dir.mkdir(parents=True, exist_ok=True)
|
|
|
| ai_rows = select_ai_rows(
|
| args.ai_validation_csv,
|
| args.samples_per_ai_source,
|
| source_shard_index=args.source_shard_index,
|
| source_num_shards=args.source_num_shards,
|
| )
|
| real_rows = select_balanced_real_rows(
|
| args.real_validation_csv,
|
| args.real_samples_per_pair,
|
| real_shard_index=args.real_shard_index,
|
| real_num_shards=args.real_num_shards,
|
| )
|
| eval_rows = ai_rows + real_rows
|
|
|
| write_csv(
|
| run_dir / "selected_ai_rows.csv",
|
| ai_rows,
|
| ["sample_id", "image_path", "label", "source_type", "source", "source_name"],
|
| )
|
| write_csv(
|
| run_dir / "selected_real_rows.csv",
|
| real_rows,
|
| ["sample_id", "image_path", "label", "source_type", "source", "source_name"],
|
| )
|
|
|
| print(f"AI rows: {len(ai_rows)}")
|
| print(f"Real rows per pair: {len(real_rows)}")
|
| print(f"Source shard: {args.source_shard_index}/{args.source_num_shards}")
|
| print(f"Real shard: {args.real_shard_index}/{args.real_num_shards}")
|
| print(f"Methods: {', '.join(args.methods)}")
|
| print(f"Output: {run_dir}")
|
| print(f"Device: {args.device}")
|
|
|
| summaries: list[dict[str, Any]] = []
|
| per_source_rows: list[dict[str, Any]] = []
|
| failed_methods: list[dict[str, str]] = []
|
|
|
| for method in args.methods:
|
| pred_path = run_dir / f"predictions_{method}.csv"
|
| try:
|
| if args.reuse_existing and pred_path.exists():
|
| print(f"\n=== {method}: reusing {pred_path} ===")
|
| predictions = read_predictions(pred_path)
|
| else:
|
| print(f"\n=== {method}: evaluating ===")
|
| predictions = evaluate_method(
|
| method=method,
|
| rows=eval_rows,
|
| device=args.device,
|
| batch_size=args.batch_size,
|
| num_workers=args.num_workers,
|
| seed=args.seed,
|
| )
|
| write_csv(
|
| pred_path,
|
| predictions,
|
| ["method", "label", "source_type", "source", "image_path", "prediction", "fake_probability"],
|
| )
|
|
|
| summary, per_source = summarize_method(method, predictions)
|
| summaries.append(summary)
|
| per_source_rows.extend(per_source)
|
| print(f"Macro AP={summary['macro_ap']:.4f} Macro AUC={summary['macro_auc']:.4f}")
|
| except Exception as exc:
|
| print(f"FAILED {method}: {exc}")
|
| failed_methods.append({"method": method, "error": str(exc)})
|
|
|
| write_csv(
|
| run_dir / "table4_results.csv",
|
| summaries,
|
| ["method", "ai_sources", "ai_samples_total", "real_samples_per_pair", "macro_ap", "macro_auc"],
|
| )
|
| write_csv(
|
| run_dir / "per_source_results.csv",
|
| per_source_rows,
|
| ["method", "source", "ai_samples", "real_samples", "ap", "auc"],
|
| )
|
| with (run_dir / "run_config.json").open("w", encoding="utf-8") as f:
|
| json.dump(
|
| {
|
| "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,
|
| "real_samples_per_pair": args.real_samples_per_pair,
|
| "seed": args.seed,
|
| "source_shard_index": args.source_shard_index,
|
| "source_num_shards": args.source_num_shards,
|
| "real_shard_index": args.real_shard_index,
|
| "real_num_shards": args.real_num_shards,
|
| "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()
|
|
|
