code/OCT_RAE_main/src/evaluate_quality.py

"""
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()