import os import torch import torch.nn as nn import torch.nn.functional as F import numpy as np import scipy from torchvision.models import inception_v3 from tqdm import tqdm ######### MODEL CLASS ########## class InceptionFeatureExtractor(nn.Module): """Modified InceptionV3 for extracting features for FID and IS computation""" def __init__(self, resize_input=True, normalize_input=True, return_features="both"): super().__init__() # Load pretrained InceptionV3 inception = inception_v3(pretrained=True, transform_input=False) inception.eval() # Remove the final classification layer # We'll extract features from different layers for FID vs IS self.resize_input = resize_input self.normalize_input = normalize_input # Copy all layers except the final fc layer self.Conv2d_1a_3x3 = inception.Conv2d_1a_3x3 self.Conv2d_2a_3x3 = inception.Conv2d_2a_3x3 self.Conv2d_2b_3x3 = inception.Conv2d_2b_3x3 self.maxpool1 = inception.maxpool1 self.Conv2d_3b_1x1 = inception.Conv2d_3b_1x1 self.Conv2d_4a_3x3 = inception.Conv2d_4a_3x3 self.maxpool2 = inception.maxpool2 self.Mixed_5b = inception.Mixed_5b self.Mixed_5c = inception.Mixed_5c self.Mixed_5d = inception.Mixed_5d self.Mixed_6a = inception.Mixed_6a self.Mixed_6b = inception.Mixed_6b self.Mixed_6c = inception.Mixed_6c self.Mixed_6d = inception.Mixed_6d self.Mixed_6e = inception.Mixed_6e self.Mixed_7a = inception.Mixed_7a self.Mixed_7b = inception.Mixed_7b self.Mixed_7c = inception.Mixed_7c self.avgpool = inception.avgpool self.dropout = inception.dropout if return_features == "is": self.fc = inception.fc # Keep for IS score self.return_features = return_features def get_features(self, x): """ Args: x: Input tensor of shape (N, 3, H, W) return_features: 'fid', 'is', or 'both' Returns: If 'fid': features for FID computation (N, 2048) If 'is': logits for IS computation (N, 1000) If 'both': tuple (fid_features, is_logits) """ if self.resize_input: x = F.interpolate(x, size=(299, 299), mode='bilinear', align_corners=False) if self.normalize_input: # Normalize to [-1, 1] range expected by InceptionV3 x = (x - 0.5) * 2.0 # Forward pass through the network x = self.Conv2d_1a_3x3(x) x = self.Conv2d_2a_3x3(x) x = self.Conv2d_2b_3x3(x) x = self.maxpool1(x) x = self.Conv2d_3b_1x1(x) x = self.Conv2d_4a_3x3(x) x = self.maxpool2(x) x = self.Mixed_5b(x) x = self.Mixed_5c(x) x = self.Mixed_5d(x) x = self.Mixed_6a(x) x = self.Mixed_6b(x) x = self.Mixed_6c(x) x = self.Mixed_6d(x) x = self.Mixed_6e(x) x = self.Mixed_7a(x) x = self.Mixed_7b(x) x = self.Mixed_7c(x) # Global average pooling x = self.avgpool(x) x = self.dropout(x) x = torch.flatten(x, 1) # This is our 2048-dimensional feature for FID fid_features = x.clone() if self.return_features == 'fid': return fid_features # Forward through final layer for IS x = self.fc(x) is_logits = x if self.return_features == 'is': return is_logits else: # return_features == 'both' return fid_features, is_logits def get_predictions(self, x): """ Args: x: Input tensor of shape (N, 3, H, W) return_features: 'fid', 'is', or 'both' Returns: If 'fid': features for FID computation (N, 2048) If 'is': logits for IS computation (N, 1000) If 'both': tuple (fid_features, is_logits) """ if self.resize_input: x = F.interpolate(x, size=(299, 299), mode='bilinear', align_corners=False) if self.normalize_input: # Normalize to [-1, 1] range expected by InceptionV3 x = (x - 0.5) * 2.0 # Forward pass through the network x = self.Conv2d_1a_3x3(x) x = self.Conv2d_2a_3x3(x) x = self.Conv2d_2b_3x3(x) x = self.maxpool1(x) x = self.Conv2d_3b_1x1(x) x = self.Conv2d_4a_3x3(x) x = self.maxpool2(x) x = self.Mixed_5b(x) x = self.Mixed_5c(x) x = self.Mixed_5d(x) x = self.Mixed_6a(x) x = self.Mixed_6b(x) x = self.Mixed_6c(x) x = self.Mixed_6d(x) x = self.Mixed_6e(x) x = self.Mixed_7a(x) x = self.Mixed_7b(x) x = self.Mixed_7c(x) # Global average pooling x = self.avgpool(x) x = self.dropout(x) x = torch.flatten(x, 1) # This is our 2048-dimensional feature for FID fid_features = x.clone() if self.return_features == 'fid': return fid_features # Forward through final layer for IS x = self.fc(x) is_logits = x if self.return_features == 'is': return F.softmax(is_logits, dim=1) else: # return_features == 'both' return fid_features, is_logits class FIDInceptionModel(torch.nn.Module): """Inception model for FID calculation.""" def __init__(self, device='cuda'): super(FIDInceptionModel, self).__init__() self.device = device self.model = inception_v3(pretrained=True, transform_input=False) self.model.fc = torch.nn.Identity() # Remove final classification layer self.model.avgpool = torch.nn.Identity() # Remove average pooling self.model.eval() self.model.to(device) def get_features(self, images): """Extract features from images.""" with torch.no_grad(): features = self.model(images) breakpoint() return features class ISInceptionModel(torch.nn.Module): """Inception model for Inception Score calculation.""" def __init__(self, device='cuda'): super(ISInceptionModel, self).__init__() self.device = device self.model = inception_v3(pretrained=True, transform_input=False) self.model.eval() self.model.to(device) def get_predictions(self, images): """Get class predictions from images.""" with torch.no_grad(): predictions = F.softmax(self.model(images), dim=1) return predictions def get_features(self, images): """Get raw logits from images (for chunked processing compatibility).""" with torch.no_grad(): logits = self.model(images) return logits ########## FID and IS calculation functions ########## def calculate_fid(features_real, features_fake): """ Calculate FID score between real and fake image features using GPU acceleration. Args: features_real: Features from real images (torch.Tensor) features_fake: Features from fake images (torch.Tensor) Returns: FID score """ # Ensure inputs are on GPU and in torch if isinstance(features_real, np.ndarray): features_real = torch.from_numpy(features_real).cuda() if isinstance(features_fake, np.ndarray): features_fake = torch.from_numpy(features_fake).cuda() mu_real = torch.mean(features_real, dim=0) mu_fake = torch.mean(features_fake, dim=0) # Calculate covariance matrices features_real_centered = features_real - mu_real.unsqueeze(0) features_fake_centered = features_fake - mu_fake.unsqueeze(0) sigma_real = (features_real_centered.T @ features_real_centered) / (features_real.size(0) - 1) sigma_fake = (features_fake_centered.T @ features_fake_centered) / (features_fake.size(0) - 1) m1, m2 = mu_real.cpu().numpy(), mu_fake.cpu().numpy() c1, c2 = sigma_real.cpu().numpy(), sigma_fake.cpu().numpy() diff = m1 - m2 offset = np.eye(c1.shape[0]) * 1e-6 # prevent semi-PSD covmean, _ = scipy.linalg.sqrtm((c1 + offset) @ (c2 + offset), disp=False) # numeric error might give slight imaginary part if np.iscomplexobj(covmean): if not np.allclose(np.diagonal(covmean).imag, 0, atol=1e-3): m = np.max(np.abs(covmean.imag)) raise ValueError('Imaginary component {}'.format(m)) covmean = covmean.real tr_covmean = np.trace(covmean) return diff.dot(diff) + np.trace(c1) + np.trace(c2) - 2 * tr_covmean def calculate_inception_score(predictions, splits=10): """ Calculate Inception Score. Args: predictions: Class predictions from inception model splits: Number of splits for calculation Returns: Mean and std of inception score """ # Convert to numpy if isinstance(predictions, torch.Tensor): predictions = predictions.cpu().numpy() # Split predictions into groups split_size = len(predictions) // splits scores = [] for i in range(splits): start_idx = i * split_size end_idx = start_idx + split_size split_preds = predictions[start_idx:end_idx] # Calculate mean prediction for this split mean_pred = np.mean(split_preds, axis=0) # Calculate KL divergence kl_div = np.sum(split_preds * np.log(split_preds / mean_pred), axis=1) score = np.exp(np.mean(kl_div)) scores.append(score) return np.mean(scores), np.std(scores) ########## Memory management functions ########## def clear_memory(): """Clear both GPU and CPU memory.""" import gc # Clear GPU memory if torch.cuda.is_available(): torch.cuda.empty_cache() torch.cuda.synchronize() # Clear CPU memory gc.collect() def get_memory_usage(): """Get current memory usage for both GPU and CPU.""" import psutil # CPU memory cpu_memory = psutil.virtual_memory() cpu_used_gb = cpu_memory.used / (1024**3) cpu_total_gb = cpu_memory.total / (1024**3) # GPU memory gpu_used_gb = 0 gpu_total_gb = 0 if torch.cuda.is_available(): gpu_used_gb = torch.cuda.memory_allocated() / (1024**3) gpu_total_gb = torch.cuda.get_device_properties(0).total_memory / (1024**3) return { 'cpu_used_gb': cpu_used_gb, 'cpu_total_gb': cpu_total_gb, 'cpu_percent': cpu_memory.percent, 'gpu_used_gb': gpu_used_gb, 'gpu_total_gb': gpu_total_gb, 'gpu_percent': (gpu_used_gb / gpu_total_gb * 100) if gpu_total_gb > 0 else 0 } def print_memory_usage(label=""): """Print current memory usage.""" memory = get_memory_usage() print(f"{label} Memory Usage:") print(f" CPU: {memory['cpu_used_gb']:.1f}/{memory['cpu_total_gb']:.1f} GB ({memory['cpu_percent']:.1f}%)") if torch.cuda.is_available(): print(f" GPU: {memory['gpu_used_gb']:.1f}/{memory['gpu_total_gb']:.1f} GB ({memory['gpu_percent']:.1f}%)") def force_memory_cleanup(): """Force aggressive memory cleanup.""" import gc print("Performing aggressive memory cleanup...") # Clear GPU memory if torch.cuda.is_available(): torch.cuda.empty_cache() torch.cuda.synchronize() # Reset peak memory stats torch.cuda.reset_peak_memory_stats() # Force garbage collection multiple times for i in range(3): gc.collect() print_memory_usage("After cleanup") ########## Extract Feature Utils Functions ########## def extract_features_chunked(model, dataset, device, batch_size=32, chunk_size=5000, cache_dir=None, cache_prefix=""): """ Extract features from a large dataset by processing it in chunks. Args: model: The model to extract features from dataset: The dataset to process device: Device to use batch_size: Batch size for processing chunk_size: Number of samples per chunk cache_dir: Directory to save chunked features cache_prefix: Prefix for cache files Returns: Concatenated features from all chunks """ assert model.get_features is not None, "Model must have a get_features method" features = [] total_samples = len(dataset) num_chunks = (total_samples + chunk_size - 1) // chunk_size print(f"Processing {total_samples} samples in {num_chunks} chunks of size {chunk_size}") print_memory_usage("Initial") for chunk_idx in range(num_chunks): start_idx = chunk_idx * chunk_size end_idx = min((chunk_idx + 1) * chunk_size, total_samples) # Check if chunk is cached if cache_dir: chunk_cache_path = os.path.join(cache_dir, f"{cache_prefix}_chunk_{chunk_idx:03d}.npy") else: chunk_cache_path = None if chunk_cache_path and os.path.exists(chunk_cache_path): print(f"Loading chunk {chunk_idx + 1}/{num_chunks} from cache...") chunk_features = np.load(chunk_cache_path) features.append(chunk_features) continue print(f"Processing chunk {chunk_idx + 1}/{num_chunks} (samples {start_idx}-{end_idx})...") # Create subset for this chunk from torch.utils.data import Subset chunk_dataset = Subset(dataset, range(start_idx, end_idx)) chunk_dataloader = DataLoader(chunk_dataset, batch_size=batch_size, shuffle=False, num_workers=2) # Extract features for this chunk chunk_features = [] model.eval() with torch.no_grad(): for batch_idx, batch in enumerate(tqdm(chunk_dataloader, desc=f"Chunk {chunk_idx + 1}", leave=False)): batch = batch.to(device) batch_features = model.get_features(batch) # Convert to numpy and move to CPU immediately to free GPU memory batch_features_np = batch_features.cpu().numpy() chunk_features.append(batch_features_np) # Clear memory periodically (every 5 batches) if batch_idx % 5 == 0: clear_memory() # Delete batch tensors to free memory immediately del batch, batch_features chunk_features = np.concatenate(chunk_features, axis=0) # Save chunk to cache if chunk_cache_path: np.save(chunk_cache_path, chunk_features) print(f"Saved chunk {chunk_idx + 1} features to cache") features.append(chunk_features) # Clear memory after each chunk clear_memory() # Delete chunk dataloader to free memory del chunk_dataloader, chunk_dataset # Print memory usage after chunk print_memory_usage(f"After chunk {chunk_idx + 1}") return np.concatenate(features, axis=0) def extract_features(model, dataloader, device, max_samples=None): """Extract features from images using the given model.""" features = [] model.eval() sample_count = 0 with torch.no_grad(): for batch_idx, batch in enumerate(tqdm(dataloader, desc="Extracting features")): batch = batch.to(device) batch_features = model.get_features(batch) # Convert to numpy and move to CPU immediately to free GPU memory batch_features_np = batch_features.cpu().numpy() features.append(batch_features_np) sample_count += batch_features_np.shape[0] # Clear memory periodically (every 10 batches) if batch_idx % 10 == 0: clear_memory() # Delete batch tensors to free memory immediately del batch, batch_features # Limit number of samples if specified if max_samples and sample_count >= max_samples: print(f"Reached maximum sample limit: {max_samples}") break # Final memory clear clear_memory() return np.concatenate(features, axis=0) def get_predictions(model, dataloader, device, max_samples=None): """Get predictions from images using the given model.""" predictions = [] model.eval() sample_count = 0 with torch.no_grad(): for batch_idx, batch in enumerate(tqdm(dataloader, desc="Getting predictions")): batch = batch.to(device) batch_predictions = model.get_predictions(batch) # Convert to numpy and move to CPU immediately to free GPU memory batch_predictions_np = batch_predictions.cpu().numpy() predictions.append(batch_predictions_np) sample_count += batch_predictions_np.shape[0] # Clear memory periodically (every 10 batches) if batch_idx % 10 == 0: clear_memory() # Delete batch tensors to free memory immediately del batch, batch_predictions # Limit number of samples if specified if max_samples and sample_count >= max_samples: print(f"Reached maximum sample limit: {max_samples}") break # Final memory clear clear_memory() return np.concatenate(predictions, axis=0)