| """ |
| 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): |
| |
| 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])) |
|
|
| |
| 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 |
| |
| 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)} |
|
|
| |
| 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}') |
|
|
| |
| 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() |
|
|
