#!/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()