Datasets:

Shining31
/

WildGen

#!/usr/bin/env python3
"""
Quantitative analysis of feature separability in UnivFD (CLIP ViT-L/14) feature space.

Diagnoses discriminative signal in frozen features using cross-validation.
This does not isolate the primary cause of detector failures. Measures include:

1. kNN accuracy (k=1,5,10) — zero-parameter classification in feature space
2. Nearest Centroid accuracy — classify by closest class mean
3. Silhouette Score — cluster cohesion vs separation [-1, 1]
4. Davies-Bouldin Index — lower = better clustering
5. Fisher Discriminant Ratio — between-class / within-class variance
6. Intra-class vs Inter-class cosine distance ratio

The encoder stays frozen; supervised probes are fitted on feature folds,
measuring discriminative signal in frozen features, without identifying a primary failure mechanism.

Usage:
    python evaluate_feature_separability.py [--split-file outputs_univfd/split_config.json]
"""

import argparse
import csv
import json
import os
import random
import sys
from collections import defaultdict
from pathlib import Path

PROJECT_ROOT = Path(__file__).resolve().parents[2]
ARTIFACT_ROOT = PROJECT_ROOT / "artifacts"

import numpy as np
import torch
import torch.nn.functional as F
from PIL import Image
from torch.utils.data import Dataset, DataLoader
from tqdm import tqdm
import torchvision.transforms as T

try:
    import clip
except ImportError:
    raise ImportError("Please install clip: pip install git+https://github.com/openai/CLIP.git")

from sklearn.metrics import (
    silhouette_score,
    davies_bouldin_score,
    balanced_accuracy_score,
    f1_score,
    accuracy_score,
)
from sklearn.neighbors import KNeighborsClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler

CLIP_MEAN = [0.48145466, 0.4578275, 0.40821073]
CLIP_STD = [0.26862954, 0.26130258, 0.27577711]
ALLOWED_EXTS = {".jpg", ".jpeg", ".png", ".webp"}
csv.field_size_limit(min(sys.maxsize, 2_147_483_647))


class FeatureExtractionDataset(Dataset):
    def __init__(self, image_paths, labels, transform):
        self.image_paths = image_paths
        self.labels = labels
        self.transform = transform

    def __len__(self):
        return len(self.image_paths)

    def __getitem__(self, idx):
        path = self.image_paths[idx]
        label = self.labels[idx]
        try:
            img = Image.open(path).convert("RGB")
            img = self.transform(img)
        except Exception as exc:
            raise RuntimeError("Unreadable feature-probe image") from exc
        return img, label


def make_clip_test_transform(img_size=224):
    return T.Compose([
        T.Resize(int(img_size * 1.15)),
        T.CenterCrop(img_size),
        T.ToTensor(),
        T.Normalize(CLIP_MEAN, CLIP_STD),
    ])


def load_fixed_split_validation(ai_csv: Path, real_csv: Path, samples_per_model: int | None, real_samples: int | None):
    """Load fixed-split validation rows directly from CSV indexes."""
    image_paths = []
    binary_labels = []
    model_labels = []

    by_model = defaultdict(list)
    with ai_csv.open("r", newline="", encoding="utf-8") as f:
        for row in csv.DictReader(f):
            by_model[int(row["source_model_id"])].append(row)

    for model_id in sorted(by_model):
        rows = sorted(
            by_model[model_id],
            key=lambda row: (int(row.get("split_rank") or 0), row["sample_id"]),
        )
        if samples_per_model is not None:
            rows = rows[:samples_per_model]
        for row in rows:
            path = row["image_path"]
            if os.path.exists(path):
                image_paths.append(path)
                binary_labels.append(1)
                model_labels.append(model_id)

    real_rows = []
    with real_csv.open("r", newline="", encoding="utf-8") as f:
        real_rows = list(csv.DictReader(f))
    real_rows = sorted(
        real_rows,
        key=lambda row: (row.get("source_dataset", ""), int(row.get("split_rank") or 0), row["sample_id"]),
    )
    if real_samples is not None:
        real_rows = real_rows[:real_samples]
    for row in real_rows:
        path = row["image_path"]
        if os.path.exists(path):
            image_paths.append(path)
            binary_labels.append(0)
            model_labels.append(0)

    return image_paths, binary_labels, model_labels


@torch.no_grad()
def extract_features(clip_model, dataloader, device):
    """Extract CLIP features for all images in a dataloader."""
    all_features = []
    all_labels = []
    for images, labels in tqdm(dataloader, desc="Extracting features"):
        images = images.to(device)
        features = clip_model.encode_image(images).float()
        features = F.normalize(features, dim=-1)
        all_features.append(features.cpu())
        all_labels.append(labels)
    return torch.cat(all_features, dim=0), torch.cat(all_labels, dim=0)


def compute_binary_metrics(features_np, binary_labels):
    """Compute all separability metrics for binary (Real vs AI) classification.

    Uses repeated balanced subsampling of the fixed validation features and five-fold CV.
    """
    results = {}
    from sklearn.model_selection import StratifiedKFold

    real_mask = binary_labels == 0
    fake_mask = binary_labels == 1
    real_features = features_np[real_mask]
    fake_features = features_np[fake_mask]
    n_real = len(real_features)

    # --- Balanced evaluation via repeated subsampling ---
    # Match fake count to real count, repeat 50 times for stability
    n_repeats = 50
    rng = np.random.RandomState(42)

    knn_bal_accs = {k: [] for k in [1, 3, 5, 10]}
    knn_f1_reals = []
    knn_f1_fakes = []
    lr_bal_accs = []
    lr_f1_reals = []
    lr_f1_fakes = []
    nc_bal_accs = []

    for rep in range(n_repeats):
        fake_idx = rng.choice(len(fake_features), n_real, replace=False)
        bal_features = np.vstack([real_features, fake_features[fake_idx]])
        bal_labels = np.array([0] * n_real + [1] * n_real)

        # Shuffle
        perm = rng.permutation(len(bal_labels))
        bal_features = bal_features[perm]
        bal_labels = bal_labels[perm]

        # kNN (5-fold CV)
        skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42 + rep)
        knn_preds = np.zeros_like(bal_labels)
        for train_idx, test_idx in skf.split(bal_features, bal_labels):
            for k in knn_bal_accs:
                knn = KNeighborsClassifier(n_neighbors=k, metric="cosine")
                knn.fit(bal_features[train_idx], bal_labels[train_idx])
                p = knn.predict(bal_features[test_idx])
                if k == 5:
                    knn_preds[test_idx] = p

            lr = LogisticRegression(max_iter=1000, C=1.0, solver="lbfgs")
            lr.fit(bal_features[train_idx], bal_labels[train_idx])

        # Recompute kNN per k with full CV
        for k in knn_bal_accs:
            knn_cv_preds = np.zeros_like(bal_labels)
            for train_idx, test_idx in skf.split(bal_features, bal_labels):
                knn = KNeighborsClassifier(n_neighbors=k, metric="cosine")
                knn.fit(bal_features[train_idx], bal_labels[train_idx])
                knn_cv_preds[test_idx] = knn.predict(bal_features[test_idx])
            knn_bal_accs[k].append(balanced_accuracy_score(bal_labels, knn_cv_preds))

        knn_f1_reals.append(f1_score(bal_labels, knn_preds, pos_label=0))
        knn_f1_fakes.append(f1_score(bal_labels, knn_preds, pos_label=1))

        # Logistic regression (5-fold CV)
        bal_scaled = bal_features
        lr_preds = np.zeros_like(bal_labels)
        for train_idx, test_idx in skf.split(bal_scaled, bal_labels):
            lr = LogisticRegression(max_iter=1000, C=1.0, solver="lbfgs")
            scaler = StandardScaler()
            train_scaled = scaler.fit_transform(bal_features[train_idx])
            test_scaled = scaler.transform(bal_features[test_idx])
            lr.fit(train_scaled, bal_labels[train_idx])
            lr_preds[test_idx] = lr.predict(test_scaled)
        lr_bal_accs.append(balanced_accuracy_score(bal_labels, lr_preds))
        lr_f1_reals.append(f1_score(bal_labels, lr_preds, pos_label=0))
        lr_f1_fakes.append(f1_score(bal_labels, lr_preds, pos_label=1))

        # Nearest centroid (on balanced set, no training needed)
        r_cent = bal_features[bal_labels == 0].mean(axis=0)
        f_cent = bal_features[bal_labels == 1].mean(axis=0)
        r_cent = r_cent / np.linalg.norm(r_cent)
        f_cent = f_cent / np.linalg.norm(f_cent)
        cos_r = bal_features @ r_cent
        cos_f = bal_features @ f_cent
        nc_preds = (cos_f > cos_r).astype(int)
        nc_bal_accs.append(balanced_accuracy_score(bal_labels, nc_preds))

    for k in knn_bal_accs:
        results[f"knn_k{k}_balanced_acc_mean"] = float(np.mean(knn_bal_accs[k]))
        results[f"knn_k{k}_balanced_acc_std"] = float(np.std(knn_bal_accs[k]))

    results["knn_k5_f1_real_mean"] = float(np.mean(knn_f1_reals))
    results["knn_k5_f1_fake_mean"] = float(np.mean(knn_f1_fakes))

    results["logreg_balanced_acc_mean"] = float(np.mean(lr_bal_accs))
    results["logreg_balanced_acc_std"] = float(np.std(lr_bal_accs))
    results["logreg_f1_real_mean"] = float(np.mean(lr_f1_reals))
    results["logreg_f1_fake_mean"] = float(np.mean(lr_f1_fakes))

    results["nearest_centroid_balanced_acc_mean"] = float(np.mean(nc_bal_accs))
    results["nearest_centroid_balanced_acc_std"] = float(np.std(nc_bal_accs))

    # --- Full-dataset Nearest Centroid (uses all data, not affected by imbalance) ---
    real_centroid = real_features.mean(axis=0)
    fake_centroid = fake_features.mean(axis=0)
    real_centroid_norm = real_centroid / np.linalg.norm(real_centroid)
    fake_centroid_norm = fake_centroid / np.linalg.norm(fake_centroid)

    cos_to_real = features_np @ real_centroid_norm
    cos_to_fake = features_np @ fake_centroid_norm
    centroid_preds = (cos_to_fake > cos_to_real).astype(int)
    real_recall_full = float((centroid_preds[real_mask] == 0).mean())
    fake_recall_full = float((centroid_preds[fake_mask] == 1).mean())
    results["nearest_centroid_full_balanced_acc"] = float((real_recall_full + fake_recall_full) / 2)
    results["nearest_centroid_full_real_recall"] = real_recall_full
    results["nearest_centroid_full_fake_recall"] = fake_recall_full

    # --- Silhouette Score (balanced subsample) ---
    fake_sil_idx = rng.choice(len(fake_features), min(n_real, len(fake_features)), replace=False)
    sil_features = np.vstack([real_features, fake_features[fake_sil_idx]])
    sil_labels = np.array([0] * n_real + [1] * len(fake_sil_idx))
    results["silhouette_score_balanced"] = float(silhouette_score(sil_features, sil_labels, metric="cosine"))

    # Also compute on a larger subsample
    n_sil = min(5000, len(fake_features))
    fake_sil_idx2 = rng.choice(len(fake_features), n_sil, replace=False)
    sil_features2 = np.vstack([real_features, fake_features[fake_sil_idx2]])
    sil_labels2 = np.array([0] * n_real + [1] * n_sil)
    results["silhouette_score_full"] = float(silhouette_score(sil_features2, sil_labels2, metric="cosine"))

    # --- Davies-Bouldin Index (balanced) ---
    results["davies_bouldin_balanced"] = float(davies_bouldin_score(sil_features, sil_labels))

    # --- Fisher Discriminant Ratio ---
    mu_real = real_features.mean(axis=0)
    mu_fake = fake_features.mean(axis=0)

    # 1D Fisher (projection onto centroid difference direction)
    w = mu_fake - mu_real
    w = w / (np.linalg.norm(w) + 1e-10)
    proj_real = real_features @ w
    proj_fake = fake_features @ w
    fisher_1d = (proj_fake.mean() - proj_real.mean()) ** 2 / (proj_real.var() + proj_fake.var() + 1e-10)
    results["fisher_1d_ratio"] = float(fisher_1d)

    # Multi-dimensional Fisher
    mu_all = (n_real * mu_real + len(fake_features) * mu_fake) / (n_real + len(fake_features))
    between_class_var = (
        n_real * np.outer(mu_real - mu_all, mu_real - mu_all)
        + len(fake_features) * np.outer(mu_fake - mu_all, mu_fake - mu_all)
    )
    within_class_var = (
        (real_features - mu_real).T @ (real_features - mu_real)
        + (fake_features - mu_fake).T @ (fake_features - mu_fake)
    )
    trace_between = np.trace(between_class_var)
    trace_within = np.trace(within_class_var)
    fisher_ratio = trace_between / (trace_within + 1e-10)
    results["fisher_discriminant_ratio"] = float(fisher_ratio)

    # --- Intra-class vs Inter-class cosine distance ---
    n_sample = min(100, n_real)
    real_sub = real_features[:n_sample]
    fake_sub = fake_features[rng.choice(len(fake_features), n_sample, replace=False)]

    intra_real = 1.0 - (real_sub @ real_sub.T)
    intra_fake = 1.0 - (fake_sub @ fake_sub.T)
    inter_rf = 1.0 - (real_sub @ fake_sub.T)

    np.fill_diagonal(intra_real, 0)
    np.fill_diagonal(intra_fake, 0)

    n = n_sample
    mean_intra_real = intra_real.sum() / (n * (n - 1))
    mean_intra_fake = intra_fake.sum() / (n * (n - 1))
    mean_intra = (mean_intra_real + mean_intra_fake) / 2
    mean_inter = inter_rf.mean()

    results["mean_intra_real_cosine_dist"] = float(mean_intra_real)
    results["mean_intra_fake_cosine_dist"] = float(mean_intra_fake)
    results["mean_intra_class_cosine_dist"] = float(mean_intra)
    results["mean_inter_class_cosine_dist"] = float(mean_inter)
    results["inter_over_intra_ratio"] = float(mean_inter / (mean_intra + 1e-10))

    # --- Centroid separation ---
    centroid_cosine_sim = float(np.dot(real_centroid_norm, fake_centroid_norm))
    results["centroid_cosine_similarity"] = centroid_cosine_sim
    results["centroid_cosine_distance"] = float(1.0 - centroid_cosine_sim)

    return results


def compute_multiclass_metrics(features_np, model_labels, n_models_subset=20):
    """Compute separability metrics for multiclass (per-model) identification."""
    results = {}

    unique_labels = np.unique(model_labels)
    n_classes = len(unique_labels)
    results["num_classes"] = int(n_classes)

    # Subsample classes for computationally expensive metrics
    if n_classes > n_models_subset:
        rng = np.random.RandomState(42)
        # Always keep class 0 (real)
        other_classes = [c for c in unique_labels if c != 0]
        selected = [0] + list(rng.choice(other_classes, n_models_subset - 1, replace=False))
        mask = np.isin(model_labels, selected)
        sub_features = features_np[mask]
        sub_labels = model_labels[mask]
    else:
        sub_features = features_np
        sub_labels = model_labels

    # Silhouette Score (multiclass)
    sil_size = min(8000, len(sub_features))
    if len(sub_features) > sil_size:
        rng = np.random.RandomState(42)
        idx = rng.choice(len(sub_features), sil_size, replace=False)
        results["silhouette_score_multiclass"] = float(
            silhouette_score(sub_features[idx], sub_labels[idx], metric="cosine")
        )
    else:
        results["silhouette_score_multiclass"] = float(
            silhouette_score(sub_features, sub_labels, metric="cosine")
        )

    # kNN for multiclass (top-1 and top-5 via 5-fold CV on subset)
    from sklearn.model_selection import StratifiedKFold
    skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

    knn_top1_correct = 0
    knn_top5_correct = 0
    knn_total = 0
    for train_idx, test_idx in skf.split(sub_features, sub_labels):
        knn = KNeighborsClassifier(n_neighbors=5, metric="cosine")
        knn.fit(sub_features[train_idx], sub_labels[train_idx])
        top1_preds = knn.predict(sub_features[test_idx])
        top5_probs = knn.predict_proba(sub_features[test_idx])
        classes = knn.classes_
        for i, true_label in enumerate(sub_labels[test_idx]):
            knn_total += 1
            if top1_preds[i] == true_label:
                knn_top1_correct += 1
            top5_classes = classes[np.argsort(top5_probs[i])[-5:]]
            if true_label in top5_classes:
                knn_top5_correct += 1

    results["knn_multiclass_top1_acc"] = float(knn_top1_correct / knn_total)
    results["knn_multiclass_top5_acc"] = float(knn_top5_correct / knn_total)

    # Mean intra-class vs inter-class distance across models
    per_class_features = defaultdict(list)
    for feat, label in zip(sub_features, sub_labels):
        per_class_features[label].append(feat)

    intra_dists = []
    for label, feats in per_class_features.items():
        feats = np.array(feats)
        if len(feats) < 2:
            continue
        sim_matrix = feats @ feats.T
        n = len(feats)
        np.fill_diagonal(sim_matrix, 0)
        mean_sim = sim_matrix.sum() / (n * (n - 1))
        intra_dists.append(1.0 - mean_sim)

    labels_list = list(per_class_features.keys())
    inter_dists = []
    for i in range(len(labels_list)):
        for j in range(i + 1, len(labels_list)):
            fi = np.array(per_class_features[labels_list[i]])
            fj = np.array(per_class_features[labels_list[j]])
            inter_sim = (fi @ fj.T).mean()
            inter_dists.append(1.0 - inter_sim)

    results["mean_intra_class_dist_multiclass"] = float(np.mean(intra_dists))
    results["mean_inter_class_dist_multiclass"] = float(np.mean(inter_dists))
    results["inter_over_intra_multiclass"] = float(np.mean(inter_dists) / (np.mean(intra_dists) + 1e-10))

    return results


def main():
    parser = argparse.ArgumentParser(description="Quantitative feature separability analysis.")
    parser.add_argument("--split-file", type=str, default=str(PROJECT_ROOT / "outputs_univfd" / "split_config.json"))
    parser.add_argument("--ai-validation-csv", type=str, default=str(ARTIFACT_ROOT / "metadata" / "fixed_split" / "ai_validation.csv"))
    parser.add_argument("--real-validation-csv", type=str, default=str(ARTIFACT_ROOT / "metadata" / "fixed_split" / "real_validation.csv"))
    parser.add_argument("--use-fixed_split-csv", action="store_true", default=True, default=True, default=True, default=True,
                        help="Load fixed-split validation CSVs instead of legacy split_config.json")
    parser.add_argument("--mapping", type=str, default="data_local/model_mapping.yaml")
    parser.add_argument("--samples-per-model", type=int, default=100,
                        help="Max test images per model (default: 100, matching reference implementation)")
    parser.add_argument("--real-samples", type=int, default=None,
                        help="Max real validation images when using fixed-split CSVs (default: all)")
    parser.add_argument("--batch-size", type=int, default=128)
    parser.add_argument("--num-workers", type=int, default=8)
    parser.add_argument("--device", type=str, default="cuda")
    parser.add_argument("--output", type=str, default=str(ARTIFACT_ROOT / "results" / "feature_separability_results.json"))
    parser.add_argument("--seed", type=int, default=42)
    args = parser.parse_args()

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

    device = torch.device(args.device if torch.cuda.is_available() else "cpu")
    print(f"Device: {device}")

    image_paths = []
    binary_labels = []  # 0=real, 1=fake
    model_labels = []   # original model_id
    if args.use_fixed_split_csv:
        print(f"\nLoading fixed-split validation CSVs:")
        print(f"  AI:   {args.ai_validation_csv}")
        print(f"  Real: {args.real_validation_csv}")
        image_paths, binary_labels, model_labels = load_fixed_split_validation(
            Path(args.ai_validation_csv),
            Path(args.real_validation_csv),
            samples_per_model=args.samples_per_model,
            real_samples=args.real_samples,
        )
    else:
        # Load test set from legacy split config.
        print(f"\nLoading split config: {args.split_file}")
        with open(args.split_file, "r") as f:
            split_data = json.load(f)
        test_config = split_data["test"]

        for model_id_str, paths in test_config.items():
            model_id = int(model_id_str)
            selected = paths[:args.samples_per_model]
            for p in selected:
                if os.path.exists(p):
                    image_paths.append(p)
                    binary_labels.append(0 if model_id == 0 else 1)
                    model_labels.append(model_id)

    print(f"Test set: {len(image_paths)} images")
    print(f"  Real: {sum(1 for l in binary_labels if l == 0)}")
    print(f"  Fake: {sum(1 for l in binary_labels if l == 1)}")
    print(f"  Models: {len(set(model_labels))}")

    # Load CLIP and extract features
    print("\nLoading CLIP ViT-L/14...")
    clip_model, _ = clip.load("ViT-L/14", device=device)
    clip_model.eval()

    transform = make_clip_test_transform()
    dataset = FeatureExtractionDataset(image_paths, model_labels, transform)
    dataloader = DataLoader(
        dataset, batch_size=args.batch_size, shuffle=False,
        num_workers=args.num_workers, pin_memory=True,
    )

    print("Extracting features...")
    features, labels_tensor = extract_features(clip_model, dataloader, device)
    features_np = features.numpy()
    model_labels_np = labels_tensor.numpy()
    binary_labels_np = np.array(binary_labels)

    print(f"Feature shape: {features_np.shape}")

    del clip_model
    torch.cuda.empty_cache()

    # Compute metrics
    print("\n" + "=" * 70)
    print("BINARY SEPARABILITY (Real vs AI)")
    print("=" * 70)
    binary_results = compute_binary_metrics(features_np, binary_labels_np)

    print(f"\n--- Zero-shot Classification (balanced, 50 trials, 5-fold CV) ---")
    for k in [1, 3, 5, 10]:
        mean = binary_results[f'knn_k{k}_balanced_acc_mean']
        std = binary_results[f'knn_k{k}_balanced_acc_std']
        print(f"  kNN (k={k:>2}) balanced acc:  {mean:.4f} ± {std:.4f}")
    print(f"    kNN k=5 F1(Real):       {binary_results['knn_k5_f1_real_mean']:.4f}")
    print(f"    kNN k=5 F1(Fake):       {binary_results['knn_k5_f1_fake_mean']:.4f}")
    print(f"  Nearest Centroid (balanced, 50 trials):")
    print(f"    Balanced acc:           {binary_results['nearest_centroid_balanced_acc_mean']:.4f} ± {binary_results['nearest_centroid_balanced_acc_std']:.4f}")
    print(f"  Nearest Centroid (full dataset, no training):")
    print(f"    Balanced acc:           {binary_results['nearest_centroid_full_balanced_acc']:.4f}")
    print(f"    Real recall:            {binary_results['nearest_centroid_full_real_recall']:.4f}")
    print(f"    Fake recall:            {binary_results['nearest_centroid_full_fake_recall']:.4f}")

    print(f"\n--- Linear Separability (balanced, 50 trials, 5-fold CV) ---")
    print(f"  LogReg balanced acc:      {binary_results['logreg_balanced_acc_mean']:.4f} ± {binary_results['logreg_balanced_acc_std']:.4f}")
    print(f"  LogReg F1(Real):          {binary_results['logreg_f1_real_mean']:.4f}")
    print(f"  LogReg F1(Fake):          {binary_results['logreg_f1_fake_mean']:.4f}")

    print(f"\n--- Cluster Quality ---")
    print(f"  Silhouette (balanced):    {binary_results['silhouette_score_balanced']:.4f}  (range [-1,1], higher=better)")
    print(f"  Silhouette (5k sample):   {binary_results['silhouette_score_full']:.4f}")
    print(f"  Davies-Bouldin (balanced):{binary_results['davies_bouldin_balanced']:.4f}  (lower=better)")
    print(f"  Fisher 1D ratio:          {binary_results['fisher_1d_ratio']:.4f}  (higher=better)")
    print(f"  Fisher multi-D ratio:     {binary_results['fisher_discriminant_ratio']:.4f}")

    print(f"\n--- Distance Analysis (cosine) ---")
    print(f"  Mean intra-real dist:     {binary_results['mean_intra_real_cosine_dist']:.4f}")
    print(f"  Mean intra-fake dist:     {binary_results['mean_intra_fake_cosine_dist']:.4f}")
    print(f"  Mean inter-class dist:    {binary_results['mean_inter_class_cosine_dist']:.4f}")
    print(f"  Inter/Intra ratio:        {binary_results['inter_over_intra_ratio']:.4f}  (>1 = separable)")
    print(f"  Centroid cos similarity:  {binary_results['centroid_cosine_similarity']:.4f}")
    print(f"  Centroid cos distance:    {binary_results['centroid_cosine_distance']:.4f}")

    print("\n" + "=" * 70)
    print("MULTICLASS SEPARABILITY (Per-Model Identification)")
    print("=" * 70)
    multiclass_results = compute_multiclass_metrics(features_np, model_labels_np)

    print(f"\n  Num classes evaluated:    {multiclass_results['num_classes']}")
    print(f"  Silhouette Score:         {multiclass_results['silhouette_score_multiclass']:.4f}")
    print(f"  kNN Top-1 accuracy:       {multiclass_results['knn_multiclass_top1_acc']:.4f}")
    print(f"  kNN Top-5 accuracy:       {multiclass_results['knn_multiclass_top5_acc']:.4f}")
    print(f"  Mean intra-class dist:    {multiclass_results['mean_intra_class_dist_multiclass']:.4f}")
    print(f"  Mean inter-class dist:    {multiclass_results['mean_inter_class_dist_multiclass']:.4f}")
    print(f"  Inter/Intra ratio:        {multiclass_results['inter_over_intra_multiclass']:.4f}")

    print("Frozen-feature probes measure discriminative signal; they do not isolate the cause of detector failures.")

    # Save results
    all_results = {
        "binary": binary_results,
        "multiclass": multiclass_results,
        "metadata": {
            "num_images": len(image_paths),
            "num_real": sum(1 for l in binary_labels if l == 0),
            "num_fake": sum(1 for l in binary_labels if l == 1),
            "num_models": len(set(model_labels)),
            "feature_dim": features_np.shape[1],
            "split_file": args.split_file,
        },
    }

    with open(args.output, "w") as f:
        json.dump(all_results, f, indent=2)
    print(f"\nResults saved to: {args.output}")


if __name__ == "__main__":
    main()