""" Evaluate generation quality: FID, Precision, and Recall per class. Handles variable-size real images by resizing to a fixed resolution. """ import argparse import json import os import sys from pathlib import Path import torch import numpy as np from PIL import Image from torch.utils.data import Dataset, DataLoader from torchvision import transforms # Use torch_fidelity's Inception model for feature extraction from torch_fidelity.helpers import vassert from torch_fidelity.utils import create_feature_extractor class ResizedImageDataset(Dataset): """Load images from a directory and resize to fixed size.""" EXTS = {'.png', '.jpg', '.jpeg', '.tif', '.tiff', '.bmp'} def __init__(self, root, size=299): self.root = Path(root) self.size = size self.files = sorted([ f for f in self.root.iterdir() if f.suffix.lower() in self.EXTS ]) self.transform = transforms.Compose([ transforms.Resize((size, size), interpolation=transforms.InterpolationMode.BICUBIC), transforms.ToTensor(), ]) def __len__(self): return len(self.files) def __getitem__(self, idx): img = Image.open(self.files[idx]).convert('RGB') return self.transform(img) def extract_features(dataset, device, batch_size=64): """Extract Inception features from a dataset.""" feat_extractor = create_feature_extractor('inception-v3-compat', ['2048'], cuda=(device.type == 'cuda')) feat_extractor.eval() loader = DataLoader(dataset, batch_size=batch_size, shuffle=False, num_workers=4, pin_memory=True, drop_last=False) all_features = [] with torch.no_grad(): for batch in loader: # torch_fidelity expects uint8 [0,255] input batch_uint8 = (batch * 255).clamp(0, 255).to(torch.uint8).to(device) features = feat_extractor(batch_uint8) # features is a dict, get the 2048-dim features feat = features[0] if isinstance(features, tuple) else list(features.values())[0] all_features.append(feat.cpu().float()) return torch.cat(all_features, dim=0).numpy() def compute_fid(mu1, sigma1, mu2, sigma2): """Compute FID between two sets of statistics.""" from scipy import linalg diff = mu1 - mu2 covmean, _ = linalg.sqrtm(sigma1 @ sigma2, disp=False) if np.iscomplexobj(covmean): covmean = covmean.real fid = diff @ diff + np.trace(sigma1 + sigma2 - 2 * covmean) return float(fid) def compute_precision_recall(feats_gen, feats_real, k=3): """Compute Precision and Recall using k-nearest neighbors.""" from sklearn.metrics import pairwise_distances # Subsample real features if too many (for efficiency) max_real = 10000 if len(feats_real) > max_real: idx = np.random.RandomState(42).permutation(len(feats_real))[:max_real] feats_real_sub = feats_real[idx] else: feats_real_sub = feats_real # Compute pairwise distances # For precision: for each generated sample, check if it's in the support of real data # For recall: for each real sample, check if it's in the support of generated data # Get k-th nearest neighbor distance in real data (manifold radius) dist_real = pairwise_distances(feats_real_sub, feats_real_sub) np.fill_diagonal(dist_real, np.inf) real_nn_dist = np.partition(dist_real, k-1, axis=1)[:, k-1] # Precision: fraction of generated samples falling within real manifold dist_gen_to_real = pairwise_distances(feats_gen, feats_real_sub) gen_min_dist = dist_gen_to_real.min(axis=1) # A generated sample is "precise" if its nearest real neighbor is within that neighbor's manifold nearest_real_idx = dist_gen_to_real.argmin(axis=1) precision = float(np.mean(gen_min_dist <= real_nn_dist[nearest_real_idx])) # Recall: fraction of real samples with a generated sample nearby dist_real_to_gen = pairwise_distances(feats_real_sub, feats_gen) # Get k-th nearest neighbor distance in generated data if len(feats_gen) >= k: dist_gen = pairwise_distances(feats_gen, feats_gen) np.fill_diagonal(dist_gen, np.inf) gen_nn_dist = np.partition(dist_gen, k-1, axis=1)[:, k-1] else: gen_nn_dist = np.full(len(feats_gen), np.inf) real_min_dist = dist_real_to_gen.min(axis=1) nearest_gen_idx = dist_real_to_gen.argmin(axis=1) recall = float(np.mean(real_min_dist <= gen_nn_dist[nearest_gen_idx])) return precision, recall def evaluate_class(gen_dir, real_dir, device, batch_size=64): """Evaluate a single class.""" gen_ds = ResizedImageDataset(gen_dir, size=299) real_ds = ResizedImageDataset(real_dir, size=299) if len(gen_ds) == 0: return None feats_gen = extract_features(gen_ds, device, batch_size) feats_real = extract_features(real_ds, device, batch_size) # FID mu_gen, sigma_gen = feats_gen.mean(0), np.cov(feats_gen, rowvar=False) mu_real, sigma_real = feats_real.mean(0), np.cov(feats_real, rowvar=False) fid = compute_fid(mu_gen, sigma_gen, mu_real, sigma_real) # Precision & Recall precision, recall = compute_precision_recall(feats_gen, feats_real) return {'fid': round(fid, 4), 'precision': round(precision, 4), 'recall': round(recall, 4), 'n_gen': len(gen_ds), 'n_real': len(real_ds)} def main(): parser = argparse.ArgumentParser() parser.add_argument('--gen-dir', type=str, required=True) parser.add_argument('--real-dir', type=str, required=True) parser.add_argument('--output', type=str, required=True) parser.add_argument('--batch-size', type=int, default=64) parser.add_argument('--device', type=str, default='cuda') args = parser.parse_args() device = torch.device(args.device) classes = sorted([d.name for d in Path(args.real_dir).iterdir() if d.is_dir()]) gen_base = Path(args.gen_dir) # Find CFG scale directories cfg_dirs = sorted([d.name for d in gen_base.iterdir() if d.is_dir() and d.name.startswith('cfg_')]) results = {} for cfg_dir in cfg_dirs: cfg_scale = cfg_dir.replace('cfg_', '') print(f"\n{'='*60}") print(f"CFG Scale = {cfg_scale}") print(f"{'='*60}") cfg_results = {} for cls_name in classes: gen_cls_dir = gen_base / cfg_dir / cls_name real_cls_dir = Path(args.real_dir) / cls_name if not gen_cls_dir.exists(): print(f" {cls_name}: SKIPPED (no generated images)") continue n_real = len(list(real_cls_dir.iterdir())) n_gen = len(list(gen_cls_dir.glob('*.png'))) warn = f" [WARNING: only {n_real} real images]" if n_real < 200 else "" print(f" {cls_name}: {n_gen} gen vs {n_real} real{warn}") try: metrics = evaluate_class(gen_cls_dir, real_cls_dir, device, args.batch_size) if metrics: cfg_results[cls_name] = metrics print(f" FID={metrics['fid']:.2f} Prec={metrics['precision']:.4f} Rec={metrics['recall']:.4f}") except Exception as e: print(f" ERROR: {e}") cfg_results[cls_name] = {'error': str(e)} results[f'cfg_{cfg_scale}'] = cfg_results # Compute average (excluding errors) valid = [v for v in cfg_results.values() if 'fid' in v] if valid: avg_fid = np.mean([v['fid'] for v in valid]) avg_prec = np.mean([v['precision'] for v in valid]) avg_rec = np.mean([v['recall'] for v in valid]) print(f"\n AVERAGE: FID={avg_fid:.2f} Prec={avg_prec:.4f} Rec={avg_rec:.4f}") results[f'cfg_{cfg_scale}']['_average'] = { 'fid': round(float(avg_fid), 4), 'precision': round(float(avg_prec), 4), 'recall': round(float(avg_rec), 4) } # Save results os.makedirs(os.path.dirname(args.output), exist_ok=True) with open(args.output, 'w') as f: json.dump(results, f, indent=2) print(f"\nResults saved to {args.output}") if __name__ == '__main__': main()