""" Evaluate generation quality v2: more reliable FID, Precision, Recall. - Subsamples real images to match generated count for balanced comparison - Computes both per-class and overall (all classes mixed) metrics """ import argparse, json, os, sys, random 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 from torch_fidelity.utils import create_feature_extractor from scipy import linalg from sklearn.metrics import pairwise_distances class ResizedImageDataset(Dataset): EXTS = {'.png', '.jpg', '.jpeg', '.tif', '.tiff', '.bmp'} def __init__(self, root, size=299, max_images=None, seed=42): self.root = Path(root) self.size = size files = sorted([f for f in self.root.iterdir() if f.suffix.lower() in self.EXTS]) if max_images and len(files) > max_images: rng = random.Random(seed) files = rng.sample(files, max_images) self.files = files 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): return self.transform(Image.open(self.files[idx]).convert('RGB')) def extract_features(dataset, device, batch_size=64): 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) all_feats = [] with torch.no_grad(): for batch in loader: batch_uint8 = (batch * 255).clamp(0, 255).to(torch.uint8).to(device) feats = feat_extractor(batch_uint8) feat = feats[0] if isinstance(feats, tuple) else list(feats.values())[0] all_feats.append(feat.cpu().float()) return torch.cat(all_feats, 0).numpy() def compute_fid(feats1, feats2): mu1, sigma1 = feats1.mean(0), np.cov(feats1, rowvar=False) mu2, sigma2 = feats2.mean(0), np.cov(feats2, rowvar=False) diff = mu1 - mu2 covmean, _ = linalg.sqrtm(sigma1 @ sigma2, disp=False) if np.iscomplexobj(covmean): covmean = covmean.real return float(diff @ diff + np.trace(sigma1 + sigma2 - 2 * covmean)) def compute_precision_recall(feats_gen, feats_real, k=3): # Precision: fraction of gen samples in real manifold dist_real = pairwise_distances(feats_real) np.fill_diagonal(dist_real, np.inf) real_knn = np.partition(dist_real, k-1, axis=1)[:, k-1] dist_g2r = pairwise_distances(feats_gen, feats_real) nearest_real_idx = dist_g2r.argmin(axis=1) gen_min_dist = dist_g2r[np.arange(len(feats_gen)), nearest_real_idx] precision = float(np.mean(gen_min_dist <= real_knn[nearest_real_idx])) # Recall: fraction of real samples in gen manifold dist_gen = pairwise_distances(feats_gen) np.fill_diagonal(dist_gen, np.inf) gen_knn = np.partition(dist_gen, min(k-1, len(feats_gen)-2), axis=1)[:, min(k-1, len(feats_gen)-2)] dist_r2g = pairwise_distances(feats_real, feats_gen) nearest_gen_idx = dist_r2g.argmin(axis=1) real_min_dist = dist_r2g[np.arange(len(feats_real)), nearest_gen_idx] recall = float(np.mean(real_min_dist <= gen_knn[nearest_gen_idx])) return precision, recall def evaluate_class(gen_dir, real_dir, device, batch_size=64, max_real=None): gen_ds = ResizedImageDataset(gen_dir, size=299) n_gen = len(gen_ds) if n_gen == 0: return None # Subsample real to match generated count for balanced FID real_limit = max_real if max_real else n_gen real_ds = ResizedImageDataset(real_dir, size=299, max_images=real_limit) n_real = len(real_ds) feats_gen = extract_features(gen_ds, device, batch_size) feats_real = extract_features(real_ds, device, batch_size) fid = compute_fid(feats_gen, feats_real) prec, rec = compute_precision_recall(feats_gen, feats_real) return {'fid': round(fid, 2), 'precision': round(prec, 4), 'recall': round(rec, 4), 'n_gen': n_gen, 'n_real': n_real} def main(): parser = argparse.ArgumentParser() parser.add_argument('--gen-dir', required=True) parser.add_argument('--real-dir', required=True) parser.add_argument('--output', required=True) parser.add_argument('--batch-size', type=int, default=64) parser.add_argument('--max-real-per-class', type=int, default=None, help='Subsample real images per class (default: match gen count)') parser.add_argument('--device', 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) 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}\nCFG Scale = {cfg_scale}\n{"="*60}') cfg_results = {} all_feats_gen, all_feats_real = [], [] for cls_name in classes: gen_cls = gen_base / cfg_dir / cls_name real_cls = Path(args.real_dir) / cls_name if not gen_cls.exists(): continue n_gen = len(list(gen_cls.glob('*.png'))) n_real_total = len(list(real_cls.iterdir())) max_real = args.max_real_per_class if args.max_real_per_class else n_gen print(f' {cls_name}: {n_gen} gen, {n_real_total} real (sampling {min(max_real, n_real_total)})') try: gen_ds = ResizedImageDataset(gen_cls, size=299) real_ds = ResizedImageDataset(real_cls, size=299, max_images=max_real) fg = extract_features(gen_ds, device, args.batch_size) fr = extract_features(real_ds, device, args.batch_size) fid = compute_fid(fg, fr) prec, rec = compute_precision_recall(fg, fr) cfg_results[cls_name] = {'fid': round(fid, 2), 'precision': round(prec, 4), 'recall': round(rec, 4), 'n_gen': len(gen_ds), 'n_real': len(real_ds)} print(f' FID={fid:.1f} Prec={prec:.4f} Rec={rec:.4f}') all_feats_gen.append(fg) all_feats_real.append(fr) except Exception as e: print(f' ERROR: {e}') cfg_results[cls_name] = {'error': str(e)} # Per-class average valid = [v for v in cfg_results.values() if 'fid' in v] if valid: avg = {k: round(float(np.mean([v[k] for v in valid])), 4) for k in ['fid', 'precision', 'recall']} cfg_results['_class_avg'] = avg print(f'\n Class-Avg: FID={avg["fid"]:.1f} Prec={avg["precision"]:.4f} Rec={avg["recall"]:.4f}') # Overall (all classes mixed) if all_feats_gen: fg_all = np.concatenate(all_feats_gen) fr_all = np.concatenate(all_feats_real) ofid = compute_fid(fg_all, fr_all) oprec, orec = compute_precision_recall(fg_all, fr_all) cfg_results['_overall'] = {'fid': round(ofid, 2), 'precision': round(oprec, 4), 'recall': round(orec, 4), 'n_gen': len(fg_all), 'n_real': len(fr_all)} print(f' Overall: FID={ofid:.1f} Prec={oprec:.4f} Rec={orec:.4f}') results[f'cfg_{cfg_scale}'] = cfg_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()