Datasets:

phuckstnk63
/

abcxyz

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


    

	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