|
|
| 'Evaluate DIRE reconstruction and classification with optional sharding and aggregation.'
|
|
|
| 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"
|
| METHODS_DIR = PROJECT_ROOT / "legacy" / "methods"
|
| 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" / "dire_current_split_zero_shot"
|
| DIRE_CLASSIFIER_WEIGHTS = METHODS_DIR / "DIRE" / "weights" / "lsun_adm.pth"
|
| DIRE_ADM_WEIGHTS = METHODS_DIR / "DIRE" / "models" / "lsun_bedroom.pt"
|
|
|
| if str(LEGACY_EVAL_DIR) not in sys.path:
|
| sys.path.insert(0, str(LEGACY_EVAL_DIR))
|
|
|
| from evaluate_legacy import DIREWrapper
|
|
|
| csv.field_size_limit(min(sys.maxsize, 2_147_483_647))
|
|
|
|
|
| class BinaryCSVDataset(Dataset):
|
| def __init__(self, rows: list[dict[str, Any]], transform: Any):
|
| self.rows = rows
|
| self.transform = transform
|
|
|
| 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")
|
| except Exception as exc:
|
| raise RuntimeError(f"Unreadable benchmark image: {path}") from exc
|
| return (
|
| self.transform(image),
|
| int(row["label"]),
|
| row["source_type"],
|
| row["source"],
|
| path,
|
| int(row["global_index"]),
|
| )
|
|
|
|
|
| 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) -> list[dict[str, Any]]:
|
| rows: list[dict[str, Any]] = []
|
| global_index = 0
|
|
|
| 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)):
|
| for row in ai_groups[source]:
|
| rows.append(
|
| {
|
| "global_index": global_index,
|
| "image_path": row["image_path"],
|
| "label": 1,
|
| "source_type": "ai",
|
| "source": source,
|
| }
|
| )
|
| global_index += 1
|
|
|
| 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):
|
| for row in real_groups[source]:
|
| rows.append(
|
| {
|
| "global_index": global_index,
|
| "image_path": row["image_path"],
|
| "label": 0,
|
| "source_type": "real",
|
| "source": source,
|
| }
|
| )
|
| global_index += 1
|
|
|
| return rows
|
|
|
|
|
| def check_dire_weights() -> None:
|
| missing = [path for path in [DIRE_CLASSIFIER_WEIGHTS, DIRE_ADM_WEIGHTS] if not path.is_file()]
|
| if missing:
|
| missing_str = "\n".join(str(path) for path in missing)
|
| raise FileNotFoundError(f"Missing required DIRE weights:\n{missing_str}")
|
|
|
|
|
| def shard_rows(rows: list[dict[str, Any]], num_shards: int, shard_index: int) -> list[dict[str, Any]]:
|
| if num_shards <= 0:
|
| raise ValueError("--num-shards must be positive")
|
| if shard_index < 0 or shard_index >= num_shards:
|
| raise ValueError("--shard-index must be in [0, num_shards)")
|
| return [row for i, row in enumerate(rows) if i % num_shards == shard_index]
|
|
|
|
|
| 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 worker(args: argparse.Namespace) -> None:
|
| check_dire_weights()
|
| all_rows = build_rows(args.ai_validation_csv, args.real_validation_csv)
|
| selected_rows = shard_rows(all_rows, args.num_shards, args.shard_index)
|
| if args.max_rows > 0:
|
| selected_rows = selected_rows[: args.max_rows]
|
|
|
| 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]),
|
| ]
|
| )
|
| dataset = BinaryCSVDataset(selected_rows, transform=transform)
|
| loader = DataLoader(
|
| dataset,
|
| batch_size=args.batch_size,
|
| shuffle=False,
|
| num_workers=args.num_workers,
|
| pin_memory=args.device.startswith("cuda"),
|
| )
|
|
|
| wrapper = DIREWrapper(
|
| str(DIRE_CLASSIFIER_WEIGHTS),
|
| device=args.device,
|
| adm_weights_path=str(DIRE_ADM_WEIGHTS),
|
| )
|
| if not wrapper.adm_loaded:
|
| raise RuntimeError("DIRE ADM weights were not loaded; refusing to use raw-image fallback.")
|
|
|
| predictions: list[dict[str, Any]] = []
|
| for images, labels, source_types, sources, paths, global_indices in tqdm(
|
| loader,
|
| desc=f"DIRE shard {args.shard_index}/{args.num_shards}",
|
| dynamic_ncols=True,
|
| ):
|
| preds, probs = wrapper.predict(images)
|
| for label, source_type, source, path, global_index, pred, prob in zip(
|
| labels,
|
| source_types,
|
| sources,
|
| paths,
|
| global_indices,
|
| preds,
|
| probs,
|
| ):
|
| predictions.append(
|
| {
|
| "method": "DIRE",
|
| "global_index": int(global_index),
|
| "label": int(label),
|
| "source_type": str(source_type),
|
| "source": str(source),
|
| "image_path": str(path),
|
| "prediction": int(pred),
|
| "fake_probability": float(prob),
|
| }
|
| )
|
|
|
| output_path = args.output_dir / f"predictions_DIRE_shard{args.shard_index:02d}_of_{args.num_shards:02d}.csv"
|
| write_csv(
|
| output_path,
|
| predictions,
|
| [
|
| "method",
|
| "global_index",
|
| "label",
|
| "source_type",
|
| "source",
|
| "image_path",
|
| "prediction",
|
| "fake_probability",
|
| ],
|
| )
|
| print(f"Saved {len(predictions)} predictions to {output_path}")
|
|
|
|
|
| def aggregate(args: argparse.Namespace) -> None:
|
| shard_paths = sorted(args.output_dir.glob("predictions_DIRE_shard*_of_*.csv"))
|
| if not shard_paths:
|
| raise FileNotFoundError(f"No DIRE shard prediction files found in {args.output_dir}")
|
|
|
| rows: list[dict[str, Any]] = []
|
| seen_indices: set[int] = set()
|
| for path in shard_paths:
|
| with path.open("r", newline="", encoding="utf-8") as f:
|
| reader = csv.DictReader(f)
|
| for row in reader:
|
| global_index = int(row["global_index"])
|
| if global_index in seen_indices:
|
| raise ValueError(f"Duplicate global_index {global_index} in {path}")
|
| seen_indices.add(global_index)
|
| rows.append(row)
|
|
|
| ai = [row for row in rows if int(row["label"]) == 1]
|
| real = [row for row in rows if int(row["label"]) == 0]
|
| ai_tp = sum(1 for row in ai if int(row["prediction"]) == 1)
|
| real_tn = sum(1 for row in real if int(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
|
|
|
| summary = {
|
| "method": "DIRE",
|
| "ai_samples": len(ai),
|
| "real_samples": len(real),
|
| "ai_recall": ai_recall,
|
| "real_recall": real_recall,
|
| "balanced_accuracy": (ai_recall + real_recall) / 2.0,
|
| "ai_false_negatives": len(ai) - ai_tp,
|
| "real_false_positives": len(real) - real_tn,
|
| "num_shards": len(shard_paths),
|
| "aggregated_at": datetime.now().isoformat(timespec="seconds"),
|
| }
|
|
|
| write_csv(args.output_dir / "overall_results.csv", [summary], list(summary.keys()))
|
| with (args.output_dir / "overall_results.json").open("w", encoding="utf-8") as f:
|
| json.dump(summary, f, indent=2)
|
| print(json.dumps(summary, indent=2))
|
|
|
|
|
| def main() -> None:
|
| parser = argparse.ArgumentParser(description=__doc__)
|
| parser.add_argument("--mode", choices=["worker", "aggregate"], required=True)
|
| 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("--num-shards", type=int, default=8)
|
| parser.add_argument("--shard-index", type=int, default=0)
|
| parser.add_argument("--batch-size", type=int, default=1)
|
| parser.add_argument("--num-workers", type=int, default=2)
|
| parser.add_argument("--max-rows", type=int, default=0, help="Worker-only debug limit; 0 means no limit")
|
| parser.add_argument("--device", default="cuda" if torch.cuda.is_available() else "cpu")
|
| args = parser.parse_args()
|
|
|
| args.output_dir.mkdir(parents=True, exist_ok=True)
|
| if args.mode == "worker":
|
| worker(args)
|
| else:
|
| aggregate(args)
|
|
|
|
|
| if __name__ == "__main__":
|
| main()
|
|
|
