Blame for code/scripts/launch/train_joint_adaptation.py

#!/usr/bin/env python3
'Evaluate a frozen checkpoint or fit a detector on joint source/target-domain samples.'

from __future__ import annotations

import argparse
import json
import random
import sys
from pathlib import Path
from typing import Any

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.models as models
import torchvision.transforms as T
from PIL import Image
from sklearn.metrics import balanced_accuracy_score, f1_score, precision_score, recall_score
from torch.utils.data import DataLoader, Dataset
from tqdm import tqdm

try:
    import clip
except ImportError:
    clip = None


IMAGENET_MEAN = [0.485, 0.456, 0.406]
IMAGENET_STD = [0.229, 0.224, 0.225]
CLIP_MEAN = [0.48145466, 0.4578275, 0.40821073]
CLIP_STD = [0.26862954, 0.26130258, 0.27577711]


class ManifestDataset(Dataset):
    def __init__(self, rows: list[dict[str, Any]], transform: T.Compose):
        self.rows = rows
        self.transform = transform

    def __len__(self) -> int:
        return len(self.rows)

    def __getitem__(self, idx: int):
        row = self.rows[idx]
        try:
            image = Image.open(row["path"]).convert("RGB")
            image = self.transform(image)
        except Exception as exc:
            raise RuntimeError(f"Unreadable benchmark image: {row['path']}") from exc
        return image, float(row["label"]), row.get("source", "unknown")


class UnivFDModel(nn.Module):
    def __init__(self, device: str = "cpu", init_gain: float = 0.02):
        super().__init__()
        if clip is None:
            raise ImportError("Please install clip for UnivFD experiments")
        self.clip_model, _ = clip.load("ViT-L/14", device=device)
        self.clip_model.eval()
        for param in self.clip_model.parameters():
            param.requires_grad = False
        self.fc = nn.Linear(768, 1)
        nn.init.normal_(self.fc.weight, 0.0, init_gain)
        nn.init.zeros_(self.fc.bias)

    def forward(self, x):
        with torch.no_grad():
            features = self.clip_model.encode_image(x)
        return self.fc(features.float())


class CNNDetectModel(nn.Module):
    def __init__(self, init_gain: float = 0.02):
        super().__init__()
        self.backbone = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V1)
        self.backbone.fc = nn.Linear(self.backbone.fc.in_features, 1)
        nn.init.normal_(self.backbone.fc.weight, 0.0, init_gain)
        nn.init.zeros_(self.backbone.fc.bias)

    def forward(self, x):
        return self.backbone(x)


def make_transforms(model_type: str, img_size: int = 224) -> tuple[T.Compose, T.Compose]:
    mean, std = (CLIP_MEAN, CLIP_STD) if model_type == "univfd" else (IMAGENET_MEAN, IMAGENET_STD)
    train_tf = T.Compose(
        [
            T.RandomResizedCrop(img_size, scale=(0.6, 1.0)),
            T.RandomHorizontalFlip(),
            T.ToTensor(),
            T.Normalize(mean, std),
        ]
    )
    test_tf = T.Compose(
        [
            T.Resize(int(img_size * 1.15)),
            T.CenterCrop(img_size),
            T.ToTensor(),
            T.Normalize(mean, std),
        ]
    )
    return train_tf, test_tf


def build_model(model_type: str, device: str) -> nn.Module:
    if model_type == "univfd":
        return UnivFDModel(device=device)
    if model_type == "cnndetect":
        return CNNDetectModel()
    raise ValueError(f"Unsupported model_type: {model_type}")


def load_checkpoint(model: nn.Module, model_type: str, checkpoint: Path) -> None:
    state = torch.load(checkpoint, map_location="cpu")
    if model_type == "univfd":
        model.fc.load_state_dict(state)
    else:
        model.load_state_dict(state)


def save_checkpoint(model: nn.Module, model_type: str, path: Path) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    if model_type == "univfd":
        torch.save(model.fc.state_dict(), path)
    else:
        torch.save(model.state_dict(), path)


def compute_metrics(labels: list[int], preds: list[int], sources: list[str]) -> dict[str, Any]:
    if not labels:
        return {}
    real_total = sum(1 for label in labels if label == 0)
    fake_total = sum(1 for label in labels if label == 1)
    real_correct = sum(1 for label, pred in zip(labels, preds) if label == 0 and pred == 0)
    fake_correct = sum(1 for label, pred in zip(labels, preds) if label == 1 and pred == 1)
    per_source: dict[str, dict[str, int | float]] = {}
    for label, pred, source in zip(labels, preds, sources):
        if label != 1:
            continue
        stats = per_source.setdefault(source, {"correct": 0, "total": 0, "detection_rate": 0.0})
        stats["total"] = int(stats["total"]) + 1
        stats["correct"] = int(stats["correct"]) + int(pred == label)
    for stats in per_source.values():
        stats["detection_rate"] = int(stats["correct"]) / max(1, int(stats["total"]))
    return {
        "balanced_accuracy": float(balanced_accuracy_score(labels, preds)),
        "accuracy": float(sum(int(p == y) for p, y in zip(preds, labels)) / len(labels)),
        "f1_real": float(f1_score(labels, preds, pos_label=0, zero_division=0)),
        "f1_fake": float(f1_score(labels, preds, pos_label=1, zero_division=0)),
        "precision_real": float(precision_score(labels, preds, pos_label=0, zero_division=0)),
        "recall_real": float(recall_score(labels, preds, pos_label=0, zero_division=0)),
        "precision_fake": float(precision_score(labels, preds, pos_label=1, zero_division=0)),
        "recall_fake": float(recall_score(labels, preds, pos_label=1, zero_division=0)),
        "real_accuracy": real_correct / max(1, real_total),
        "fake_accuracy": fake_correct / max(1, fake_total),
        "num_real": real_total,
        "num_fake": fake_total,
        "per_fake_source": per_source,
    }


@torch.no_grad()
def evaluate(model: nn.Module, loader: DataLoader, device: torch.device) -> dict[str, Any]:
    model.eval()
    labels: list[int] = []
    preds: list[int] = []
    sources: list[str] = []
    for images, batch_labels, batch_sources in tqdm(loader, desc="Evaluating", leave=False):
        images = images.to(device, non_blocking=True)
        logits = model(images).squeeze(-1)
        batch_preds = (torch.sigmoid(logits) > 0.5).long().cpu().tolist()
        preds.extend(int(pred) for pred in batch_preds)
        labels.extend(int(label) for label in batch_labels.tolist())
        sources.extend(str(source) for source in batch_sources)
    return compute_metrics(labels, preds, sources)


def train_one_epoch(

    model: nn.Module,

    loader: DataLoader,

    criterion: nn.Module,

    optimizer: optim.Optimizer,

    device: torch.device,

    epoch: int,

    num_epochs: int,

) -> dict[str, float]:
    model.train()
    if hasattr(model, "clip_model"):
        model.clip_model.eval()
    running_loss = 0.0
    correct = 0
    total = 0
    for images, labels, _sources in tqdm(loader, desc=f"Epoch {epoch}/{num_epochs}", leave=False):
        images = images.to(device, non_blocking=True)
        labels = labels.to(device, non_blocking=True)
        optimizer.zero_grad(set_to_none=True)
        logits = model(images).squeeze(-1)
        loss = criterion(logits, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item() * labels.numel()
        preds = (torch.sigmoid(logits) > 0.5).float()
        correct += (preds == labels).sum().item()
        total += labels.numel()
    return {"train_loss": running_loss / max(1, total), "train_acc": correct / max(1, total)}


def validation_interval(num_epochs: int, num_validations: int) -> int:
    return max(1, num_epochs // max(1, num_validations))


def main() -> None:
    parser = argparse.ArgumentParser(description="Train/evaluate a transfer binary adaptation job.")
    parser.add_argument("--model-type", choices=["univfd", "cnndetect"], required=True)
    parser.add_argument("--manifest", type=Path, required=True)
    parser.add_argument("--output-dir", type=Path, required=True)
    parser.add_argument("--checkpoint", type=Path, default=None)
    parser.add_argument("--strategy", choices=["zero_shot", "warm_start"], required=True)
    parser.add_argument("--epochs", type=int, default=None)
    parser.add_argument("--total-samples-per-source", type=int, default=9000)
    parser.add_argument("--num-validations", type=int, default=10)
    parser.add_argument("--batch-size", type=int, default=64)
    parser.add_argument("--num-workers", type=int, default=4)
    parser.add_argument("--lr", type=float, default=1e-4)
    parser.add_argument("--seed", type=int, default=42)
    parser.add_argument("--device", type=str, default="cuda" if torch.cuda.is_available() else "cpu")
    args = parser.parse_args()
    if args.checkpoint is not None and args.checkpoint.name not in {"fc_weights_final.pth", "model_final.pth"}:
        parser.error("Configured protocol requires a final-epoch checkpoint")

    random.seed(args.seed)
    torch.manual_seed(args.seed)

    with args.manifest.open("r", encoding="utf-8") as f:
        manifest = json.load(f)
    train_rows = manifest.get("train", [])
    test_rows = manifest.get("test", [])
    k_per_source = int(manifest.get("k_per_source", 0))
    if args.epochs is None:
        args.epochs = 0 if args.strategy == "zero_shot" or k_per_source == 0 else max(1, args.total_samples_per_source // k_per_source)

    device = torch.device(args.device)
    train_tf, test_tf = make_transforms(args.model_type)
    model = build_model(args.model_type, args.device).to(device)
    if args.checkpoint is not None:
        load_checkpoint(model, args.model_type, args.checkpoint)
        model.to(device)
    elif args.strategy in {"zero_shot", "warm_start"}:
        raise ValueError(f"{args.strategy} requires --checkpoint")

    pin_memory = torch.cuda.is_available()
    test_loader = DataLoader(
        ManifestDataset(test_rows, test_tf),
        batch_size=args.batch_size,
        shuffle=False,
        num_workers=args.num_workers,
        pin_memory=pin_memory,
    )

    history: list[dict[str, Any]] = []
    best_metrics: dict[str, Any] | None = None
    if args.strategy != "zero_shot" and args.epochs > 0:
        if not train_rows:
            raise ValueError("Training strategy requires non-empty manifest train rows")
        train_loader = DataLoader(
            ManifestDataset(train_rows, train_tf),
            batch_size=args.batch_size,
            shuffle=True,
            num_workers=args.num_workers,
            pin_memory=pin_memory,
        )
        criterion = nn.BCEWithLogitsLoss()
        if args.model_type == "univfd":
            optimizer = optim.AdamW(model.fc.parameters(), lr=args.lr, weight_decay=0.0)
        else:
            optimizer = optim.Adam(model.parameters(), lr=args.lr)
        interval = validation_interval(args.epochs, args.num_validations)
        best_balanced_acc = -1.0
        for epoch in range(1, args.epochs + 1):
            train_metrics = train_one_epoch(model, train_loader, criterion, optimizer, device, epoch, args.epochs)
            validate_now = epoch == args.epochs or epoch % interval == 0
            record: dict[str, Any] = {"epoch": epoch, "validated": validate_now, **train_metrics}
            if validate_now:
                metrics = evaluate(model, test_loader, device)
                record.update(metrics)
                if metrics.get("balanced_accuracy", -1.0) > best_balanced_acc:
                    best_balanced_acc = float(metrics["balanced_accuracy"])
                    best_metrics = metrics
                print(
                    f"Epoch {epoch}/{args.epochs}: train_acc={train_metrics['train_acc']:.4f} "
                    f"bal_acc={metrics.get('balanced_accuracy', 0):.4f}"
                )
            else:
                print(f"Epoch {epoch}/{args.epochs}: train_acc={train_metrics['train_acc']:.4f}")
            history.append(record)
        save_checkpoint(
            model,
            args.model_type,
            args.output_dir / ("fc_weights_final.pth" if args.model_type == "univfd" else "model_final.pth"),
        )

    final_metrics = evaluate(model, test_loader, device)
    if best_metrics is None:
        best_metrics = final_metrics

    result = {
        "model_type": args.model_type,
        "strategy": args.strategy,
        "checkpoint": str(args.checkpoint) if args.checkpoint else None,
        "manifest": str(args.manifest),
        "manifest_name": manifest.get("name"),
        "k_per_source": k_per_source,
        "real_ratio": manifest.get("real_ratio"),
        "epochs": args.epochs,
        "train_count": len(train_rows),
        "test_count": len(test_rows),
        "diagnostic_best_metrics": best_metrics,
        "reporting_policy": "final_epoch",
        "final_metrics": final_metrics,
        "history": history,
    }
    args.output_dir.mkdir(parents=True, exist_ok=True)
    with (args.output_dir / "results.json").open("w", encoding="utf-8") as f:
        json.dump(result, f, indent=2, ensure_ascii=False)
    print(json.dumps({k: result[k] for k in ["model_type", "strategy", "k_per_source", "final_metrics"]}, indent=2))


if __name__ == "__main__":
    try:
        main()
    except Exception as exc:
        print(f"Error: {exc}", file=sys.stderr)
        raise