eval_code/eval.py

import json
import random
import os
from pathlib import Path
import torch
from PIL import Image
import numpy as np
import torchvision.transforms as transforms
from scipy import linalg
import scipy
import torch.nn.functional as F
import torch.nn as nn
from torch.utils.data import Dataset, DataLoader
import pickle
import warnings
warnings.filterwarnings('ignore')

from metric import *

"""
Image Quality Evaluation with Caching

This module provides functions to evaluate FID (Fréchet Inception Distance) and 
IS (Inception Score) for generated images. It includes intelligent caching to 
save computation time on repeated evaluations.

Cache Structure:
- output_dir/eval_cache/
  ├── real_features.npy          # Cached real image features for FID
  ├── real_features_hash.txt     # Hash of real image directory
  ├── 1k_features.npy           # Cached features for 1K images
  ├── 1k_predictions.npy        # Cached predictions for 1K images
  ├── 1k_folder_hash.txt        # Hash of 1K image folder
  ├── 2k_features.npy           # Cached features for 2K images
  ├── 2k_predictions.npy        # Cached predictions for 2K images
  ├── 2k_folder_hash.txt        # Hash of 2K image folder
  ├── 4k_features.npy           # Cached features for 4K images
  ├── 4k_predictions.npy        # Cached predictions for 4K images
  └── 4k_folder_hash.txt        # Hash of 4K image folder

The cache automatically detects changes in image folders and only recomputes
features when necessary, significantly speeding up repeated evaluations.
"""

def process_json_file(json_file_path, global_path, output_dir="output"):
    """
    Read a JSON file, sample 1000 lines, and save text and image paths separately.
    
    Args:
        json_file_path (str): Path to the input JSON file
        global_path (str): Global path to prepend to image_path
        output_dir (str): Directory to save output files
    """
    
    # Create output directory if it doesn't exist
    Path(output_dir).mkdir(parents=True, exist_ok=True)
    
    # Read the JSON file
    print(f"Reading JSON file: {json_file_path}")
    with open(json_file_path, 'r', encoding='utf-8') as f:
        data = json.load(f)
    
    # Convert to list if it's not already
    if not isinstance(data, list):
        data = [data]
    
    # Sample 1000 lines (or all if less than 1000)
    sample_size = min(1000, len(data))
    sampled_data = random.sample(data, sample_size)
    
    print(f"Sampled {sample_size} lines from {len(data)} total lines")
    su
    # Process the data
    image_paths = []
    texts = []
    
    for item in sampled_data:
        # Extract fields
        image_path = item.get('image_path', '')
        text = item.get('text', '')
        
        # Combine image_path with global path
        image_link = os.path.join(global_path, image_path) if image_path else ''
        
        image_paths.append(image_link)
        texts.append(text)
    
    # Save text samples
    text_file = os.path.join(output_dir, 'texts.txt')
    with open(text_file, 'w', encoding='utf-8') as f:
        for text in texts:
            f.write(text + '\n')
    
    # Save image paths
    image_file = os.path.join(output_dir, 'image_paths.txt')
    with open(image_file, 'w', encoding='utf-8') as f:
        for path in image_paths:
            f.write(path + '\n')
    
    print(f"Text samples saved to: {text_file}")
    print(f"Image paths saved to: {image_file}")
    print(f"Total processed items: {len(texts)}")

def clean_fid_resize(output_size=(299, 299)):
    s1, s2 = output_size
    def resize_single_channel(x_np):
        img = Image.fromarray(x_np.astype(np.float32), mode='F')
        img = img.resize(output_size, resample=Image.Resampling.BICUBIC)
        return np.asarray(img).clip(0, 255).reshape(s2, s1, 1)
    def func(x):
        x = [resize_single_channel(x[:, :, idx]) for idx in range(3)]
        # x = np.concatenate(x, axis=2).astype(np.float32)
        x = np.concatenate(x, axis=2).astype(np.uint8)
        return x
    return func

class ImageDataset(Dataset):
    """Dataset for loading images from a directory."""
    def __init__(self, image_dir, transform=None, use_clean_fid=False):
        self.image_dir = image_dir
        self.image_files = [f for f in os.listdir(image_dir) if f.lower().endswith(('.png', '.jpg', '.jpeg'))]
        self.image_files.sort()
        if use_clean_fid:
            self.transform = transforms.ToTensor()
            self.resize_fn = clean_fid_resize(output_size=(299, 299))
        else:
            self.transform = transforms.Compose([
                transforms.Resize((299, 299)),
                transforms.ToTensor(),
            ])
        self.use_clean_fid = use_clean_fid
    
    def __len__(self):
        return len(self.image_files)
    
    def __getitem__(self, idx):
        img_path = os.path.join(self.image_dir, self.image_files[idx])
        image = Image.open(img_path).convert('RGB')
        if self.use_clean_fid:
            image_np = np.array(image)
            image_np = self.resize_fn(image_np)
            image = self.transform(image_np)
        else:
            image = self.transform(image)
        return image

class ImagePatchDataset(Dataset):
    """Dataset for loading images from a directory.
        For each image, we will return 10 random patches (1024x1024)"""
    def __init__(self, image_dir, num_patches=10):
        self.image_dir = image_dir
        self.image_files = [f for f in os.listdir(image_dir) if f.lower().endswith(('.png', '.jpg', '.jpeg'))]
        self.image_files.sort()
        self.num_patches = num_patches
        self.transform = transforms.Compose([
                transforms.RandomCrop((1024, 1024)),
                transforms.Resize((299, 299)),
                transforms.ToTensor(),
        ])

    
    def __len__(self):
        return len(self.image_files)
    
    def __getitem__(self, idx):
        img_path = os.path.join(self.image_dir, self.image_files[idx])
        image = Image.open(img_path).convert('RGB')
        output = []
        for _ in range(self.num_patches):
            output.append(self.transform(image))
        image = torch.stack(output)
        return image

class ImagePathDataset(Dataset):
    """Dataset for loading images from a list of file paths."""
    def __init__(self, image_paths, use_clean_fid=False):
        self.image_paths = image_paths
        if use_clean_fid:
            self.transform = transforms.ToTensor()
            self.resize_fn = clean_fid_resize(output_size=(299, 299))
        else:
            self.transform = transforms.Compose([
                transforms.Resize((299, 299)),
                transforms.ToTensor(),
            ])
        self.use_clean_fid = use_clean_fid
    
    def __len__(self):
        return len(self.image_paths)
    
    def __getitem__(self, idx):
        img_path = self.image_paths[idx]
        try:
            image = Image.open(img_path).convert('RGB')
            if self.use_clean_fid:
                image_np = np.array(image)
                image_np = self.resize_fn(image_np)
                image = self.transform(image_np)
            else:
                image = self.transform(image)
            return image
        except Exception as e:
            print(f"Error loading image {img_path}: {str(e)}")
            # Return a black image as fallback
            if self.transform:
                return self.transform(Image.new('RGB', (299, 299), (0, 0, 0)))
            return Image.new('RGB', (299, 299), (0, 0, 0))

def get_folder_hash(folder_path):
    """
    Generate a hash of folder contents to detect changes.
    
    Args:
        folder_path (str): Path to the folder
        
    Returns:
        str: MD5 hash of folder contents
    """
    import hashlib
    import os
    
    hash_md5 = hashlib.md5()
    
    # Get all image files in the folder
    image_files = []
    for file in os.listdir(folder_path):
        if file.lower().endswith(('.png', '.jpg', '.jpeg')):
            image_files.append(file)
    
    # Sort files for consistent hashing
    image_files.sort()
    
    # Hash the list of files and their modification times
    for file in image_files:
        file_path = os.path.join(folder_path, file)
        # Include filename and modification time in hash
        file_info = f"{file}:{os.path.getmtime(file_path)}"
        hash_md5.update(file_info.encode())
    
    return hash_md5.hexdigest()

def clear_evaluation_cache(output_dir):
    """
    Clear the evaluation cache for a given output directory.
    
    Args:
        output_dir (str): Directory containing the cache to clear
    """
    cache_dir = os.path.join(output_dir, 'eval_cache')
    if os.path.exists(cache_dir):
        import shutil
        shutil.rmtree(cache_dir)
        print(f"Cleared evaluation cache: {cache_dir}")
    else:
        print(f"No cache found at: {cache_dir}")

def check_cache_status(output_dir):
    """
    Check the status of evaluation cache for a given output directory.
    
    Args:
        output_dir (str): Directory containing the cache to check
    """
    cache_dir = os.path.join(output_dir, 'eval_cache')
    if not os.path.exists(cache_dir):
        print(f"No cache directory found at: {cache_dir}")
        return
    
    print(f"Cache directory: {cache_dir}")
    print("Cache contents:")
    
    # List all cache files
    cache_files = [f for f in os.listdir(cache_dir) if f.endswith('.npy')]
    hash_files = [f for f in os.listdir(cache_dir) if f.endswith('.txt')]
    
    if cache_files:
        print("\nFeature files:")
        for file in sorted(cache_files):
            file_path = os.path.join(cache_dir, file)
            size_mb = os.path.getsize(file_path) / (1024 * 1024)
            print(f"  {file}: {size_mb:.1f} MB")
    
    if hash_files:
        print("\nHash files:")
        for file in sorted(hash_files):
            print(f"  {file}")
    
    # Check for chunked cache
    chunk_files = [f for f in cache_files if 'chunk_' in f]
    if chunk_files:
        print(f"\nChunked processing detected: {len(chunk_files)} chunk files")
        chunk_prefixes = set([f.split('_chunk_')[0] for f in chunk_files])
        for prefix in chunk_prefixes:
            prefix_chunks = [f for f in chunk_files if f.startswith(prefix)]
            print(f"  {prefix}: {len(prefix_chunks)} chunks")

def create_image_paths_file(image_dir, output_file, file_extensions=('.png', '.jpg', '.jpeg')):
    """
    Create a text file containing paths to all images in a directory.
    
    Args:
        image_dir (str): Directory containing images
        output_file (str): Path to output text file
        file_extensions (tuple): File extensions to include
    """
    if not os.path.exists(image_dir):
        print(f"Error: Directory '{image_dir}' does not exist!")
        return
    
    image_paths = []
    for root, dirs, files in os.walk(image_dir):
        for file in files:
            if file.lower().endswith(file_extensions):
                full_path = os.path.join(root, file)
                image_paths.append(full_path)
    
    # Sort paths for consistency
    image_paths.sort()
    
    # Write to file
    with open(output_file, 'w', encoding='utf-8') as f:
        for path in image_paths:
            f.write(path + '\n')
    
    print(f"Created image paths file: {output_file}")
    print(f"Total images found: {len(image_paths)}")


def evaluate_image_quality(
    existing_folders, 
    real_image_dir=None, 
    batch_size=32, 
    device='cuda', 
    use_cache=True, 
    chunk_size=5000, 
    use_patch=False,
    real_cache_dir: str = None
):
    """
    Evaluate FID and IS scores for generated images in 1K, 2K, and 4K folders.
    
    Args:
        output_dir (str): Directory containing the generated images
        real_image_dir (str): Directory containing real images for FID comparison, or text file containing image paths
        batch_size (int): Batch size for processing
        device (str): Device to use for computation
        use_cache (bool): Whether to use cached features if available
        chunk_size (int): Number of samples per chunk for large datasets
        
    Returns:
        Dictionary containing evaluation results
    """
    print("Starting image quality evaluation...")
    print_memory_usage("Start of evaluation")
    
    output_dir, _ = os.path.split(existing_folders[0])

    # Create cache directory
    cache_dir = real_cache_dir 
    if cache_dir is not None:
        assert os.path.exists(cache_dir), f"Cache directory {cache_dir} does not exist"
    gen_cache_dir = os.path.join(output_dir, 'eval_cache')
    os.makedirs(gen_cache_dir, exist_ok=True)
    
    # Initialize models
    fid_model = InceptionFeatureExtractor(return_features="fid")
    is_model = InceptionFeatureExtractor(return_features="is")
    fid_model.to(device)
    is_model.to(device)
    
    results = {}
    
    # Load or extract real image features for FID
    real_features = None
    if real_image_dir and os.path.exists(real_image_dir):
        real_features_cache_path = os.path.join(cache_dir, 'real_features.npy')
        real_features_hash_path = os.path.join(cache_dir, 'real_features_hash.txt')
        
        if use_cache and os.path.exists(real_features_cache_path):
            print("Loading cached real image features...")
            real_features = np.load(real_features_cache_path)
            print(f"Loaded {len(real_features)} real image features from cache")
        else:
            print(f"Extracting real image features using chunked processing...")
            
            # Check if real_image_dir is a text file or directory
            if real_image_dir.endswith('.txt'):
                print(f"Reading image paths from text file: {real_image_dir}")
                # Read image paths from text file
                with open(real_image_dir, 'r', encoding='utf-8') as f:
                    image_paths = [line.strip() for line in f.readlines() if line.strip()]
                print(f"Found {len(image_paths)} image paths in text file")
                
                # Create dataset from image paths
                real_dataset = ImagePathDataset(image_paths)
            else:
                # Create dataset for real images from directory
                real_dataset = ImageDataset(real_image_dir)
                total_images = len(real_dataset)
                print(f"Found {total_images} real images in directory")
                if total_images > 50000:
                    indices = torch.randperm(total_images)[:50000]
                    real_dataset = torch.utils.data.Subset(real_dataset, indices)
                    print(f"Subsampled to {len(indices)} images for evaluation")
            
            # Use chunked processing for large datasets
            if len(real_dataset) > chunk_size:
                print(f"Large dataset detected ({len(real_dataset)} images). Using chunked processing with chunk size {chunk_size}.")
                real_features = extract_features_chunked(
                    model=fid_model,
                    dataset=real_dataset,
                    device=device,
                    batch_size=batch_size,
                    chunk_size=chunk_size,
                    cache_dir=cache_dir,
                    cache_prefix="real"
                )
            else:
                # For smaller datasets, use regular processing
                real_dataloader = DataLoader(real_dataset, batch_size=batch_size, shuffle=False, num_workers=2)
                real_features = extract_features(fid_model, real_dataloader, device)
            
            # Save features to cache
            np.save(real_features_cache_path, real_features)
            
            # Save hash of real image directory and chunk size for cache validation
            import hashlib
            cache_info = f"{real_image_dir}\n{chunk_size}\n{len(real_features)}"
            real_dir_hash = hashlib.md5(cache_info.encode()).hexdigest()
            with open(real_features_hash_path, 'w') as f:
                f.write(cache_info + f"\n{real_dir_hash}")
            
            print(f"Saved {len(real_features)} real image features to cache")
    
    # Evaluate each resolution folder
    list_resolution = []
    for folder_path in existing_folders:
        _, current_name = os.path.splitext(folder_path)
        resolution = current_name.split('_')[-1]
        list_resolution.append(resolution)


        
        print(f"\nEvaluating {resolution} images...")
        
        # HARD-CODE to alway recompute Cache paths for this resolution
        gen_features_cache_path = os.path.join(gen_cache_dir, f'{resolution}_features.npy')
        predictions_cache_path = os.path.join(gen_cache_dir, f'{resolution}_predictions.npy')
        folder_hash_path = os.path.join(gen_cache_dir, f'{resolution}_folder_hash.txt')


        # Load generated images
        try:
            if use_patch:
                gen_dataset = ImagePatchDataset(folder_path)
                collate_fn  =  lambda batch: torch.cat(batch, dim=0)
            else:
                # Sample only 731 images from the dataset
                # import random
                _full_dataset = ImageDataset(folder_path)
                gen_dataset = _full_dataset
                # total_images = len(_full_dataset)
                # sample_size = min(731, total_images)
                # if sample_size < total_images:
                #     indices = sorted(random.sample(range(total_images), sample_size))
                #     gen_dataset = torch.utils.data.Subset(_full_dataset, indices)
                # else:
                #     gen_dataset = _full_dataset
                collate_fn = None
            gen_dataloader = DataLoader(gen_dataset, batch_size=batch_size, shuffle=False, num_workers=2, collate_fn=collate_fn)
            
            # Check if we can use cached features
            use_cached_features = False
            if use_cache and os.path.exists(gen_features_cache_path) and os.path.exists(predictions_cache_path):
                # Check if folder content has changed
                current_hash = get_folder_hash(folder_path)
                cached_hash = None
                if os.path.exists(folder_hash_path):
                    with open(folder_hash_path, 'r') as f:
                        cached_hash = f.read().strip()
                
                if current_hash == cached_hash:
                    use_cached_features = True
                    print(f"Using cached features for {resolution}...")
            
            if use_cached_features:
                # Load cached features and predictions
                gen_features = np.load(gen_features_cache_path)
                predictions = np.load(predictions_cache_path)
                print(f"Loaded {len(gen_features)} features and {len(predictions)} predictions from cache")
            else:
                # Extract features and predictions
                print(f"Extracting features for {resolution}...")
                
                # Use chunked processing for large generated datasets
                if len(gen_dataset) > chunk_size:
                    print(f"Large generated dataset detected ({len(gen_dataset)} images). Using chunked processing.")
                    gen_features = extract_features_chunked(
                        model=fid_model,
                        dataset=gen_dataset,
                        device=device,
                        batch_size=batch_size,
                        chunk_size=chunk_size,
                        cache_dir=gen_cache_dir,
                        cache_prefix=f"{resolution}_fid"
                    )
                else:
                    gen_features = extract_features(fid_model, gen_dataloader, device)
                
                print(f"Getting predictions for {resolution}...")
                
                # Use chunked processing for predictions too
                if len(gen_dataset) > chunk_size:
                    predictions = extract_features_chunked(
                        model=is_model,
                        dataset=gen_dataset,
                        device=device,
                        batch_size=batch_size,
                        chunk_size=chunk_size,
                        cache_dir=gen_cache_dir,
                        cache_prefix=f"{resolution}_is"
                    )
                    # Convert features to predictions (for IS model, features are predictions)
                    predictions = F.softmax(torch.from_numpy(predictions), dim=1).numpy()
                else:
                    predictions = get_predictions(is_model, gen_dataloader, device)
                
                
                # Save to cache
                # np.save(gen_features_cache_path, gen_features)
                # np.save(predictions_cache_path, predictions)
                
                # # Save folder hash
                # current_hash = get_folder_hash(folder_path)
                # with open(folder_hash_path, 'w') as f:
                #     f.write(current_hash)
                
                # print(f"Saved {len(gen_features)} features and {len(predictions)} predictions to cache")
            
            # Calculate Inception Score
            print(f"Calculating Inception Score for {resolution}...")
            is_mean, is_std = calculate_inception_score(predictions)
            
            results[f"{resolution}_IS"] = {
                'mean': float(is_mean),
                'std': float(is_std)
            }
            
            print(f"{resolution} Inception Score: {is_mean:.4f} ± {is_std:.4f}")
            
            # Calculate FID if real images are provided
            if real_features is not None:
                print(f"Calculating FID for {resolution}...")
                fid_score = calculate_fid(real_features, gen_features)
                results[f"{resolution}_FID"] = float(fid_score)
                print(f"{resolution} FID Score: {fid_score:.4f}")
            else:
                print(f"Skipping FID calculation for {resolution} (no real images provided)")
                results[f"{resolution}_FID"] = None
                
        except Exception as e:
            print(f"Error evaluating {resolution}: {str(e)}")
            results[f"{resolution}_IS"] = {'mean': None, 'std': None}
            results[f"{resolution}_FID"] = None
    
    # Save results
    results_file = os.path.join(output_dir, 'evaluation_results.json')
    with open(results_file, 'w') as f:
        json.dump(results, f, indent=2)
    
    print(f"\nEvaluation results saved to: {results_file}")
    
    # Print summary
    print("\n" + "="*50)
    print("EVALUATION SUMMARY")
    print("="*50)
    for resolution in list_resolution:
        if f"{resolution}_IS" in results:
            is_result = results[f"{resolution}_IS"]
            if is_result['mean'] is not None:
                print(f"{resolution.upper()}:")
                print(f"  Inception Score: {is_result['mean']:.4f} ± {is_result['std']:.4f}")
                if results[f"{resolution}_FID"] is not None:
                    print(f"  FID Score: {results[f'{resolution}_FID']:.4f}")
                print()
    
    return results
    
def run_evaluation_only(
    output_dir, 
    real_image_dir=None, 
    batch_size=32, 
    device='cuda', 
    use_cache=True, 
    chunk_size=5000, 
    use_patch=False,
    real_cache_dir: str = None
):
    """
    Standalone function to run evaluation only (without image generation).
    
    Args:
        output_dir (str): Directory containing the generated images
        real_image_dir (str): Directory containing real images for FID comparison
        batch_size (int): Batch size for processing
        device (str): Device to use for computation
        use_cache (bool): Whether to use cached features if available
        chunk_size (int): Number of samples per chunk for large datasets
    """
    print("Running image quality evaluation only...")
    
    if not os.path.exists(output_dir):
        print(f"Error: Output directory '{output_dir}' does not exist!")
        return
    
    # Check if any of the image folders exist
    image_folders = []
    for prefix in ['image', 'img']:
        for suffix in ['1k', '2k', '4k', '1024', '2048', '4096']:
            image_folders.append(os.path.join(output_dir, f"{prefix}_{suffix}"))
    existing_folders = [f for f in image_folders if os.path.exists(f)]
    
    if not existing_folders:
        print(f"Error: No image folders found in '{output_dir}'!")
        print(f"Expected folders: {image_folders}")
        return
    
    print(f"Found image folders: {[os.path.basename(f) for f in existing_folders]}")
    
    # Run evaluation
    results = evaluate_image_quality(
        existing_folders=existing_folders,
        real_image_dir=real_image_dir,
        batch_size=batch_size,
        device=device,
        use_cache=use_cache,
        chunk_size=chunk_size,
        use_patch=use_patch,
        real_cache_dir=real_cache_dir
    )
    
    return results