Datasets:

Shining31
/

WildGen

#!/usr/bin/env python3
'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  # noqa: E402

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()