Update app.py

app.py

@@ -1,667 +1,407 @@
 import os
-import asyncio
-from typing import List, Dict, Optional, Tuple, Any
-from dataclasses import dataclass, field
+import gc
+from abc import ABC, abstractmethod
 from pathlib import Path
-import logging
+from typing import List, Dict, Any, Type
 
 import cv2
+import gradio as gr
 import numpy as np
+import pandas as pd
 import torch
 import onnxruntime as rt
 from PIL import Image
-import gradio as gr
-from transformers import pipeline
 from huggingface_hub import hf_hub_download
-import pandas as pd
-
-# Configure logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-logger = logging.getLogger(__name__)
-
-# Import aesthetic predictor function
-# Ensure 'aesthetic_predictor_v2_5.py' is in the same directory or accessible in PYTHONPATH
-# from aesthetic_predictor_v2_5 import convert_v2_5_from_siglip
-# Placeholder for the import if the file is missing, to allow syntax checking
-def convert_v2_5_from_siglip(low_cpu_mem_usage=True, trust_remote_code=True):
-    # This is a placeholder. Replace with actual import and ensure the function exists.
-    logger.warning("Using placeholder for convert_v2_5_from_siglip. Ensure the actual implementation is available.")
-    # Mocking a model and preprocessor structure
-    mock_model = torch.nn.Sequential(torch.nn.Linear(10,1)) # Dummy model
-    mock_preprocessor = lambda images, return_tensors: {"pixel_values": torch.randn(len(images), 3, 224, 224)} # Dummy preprocessor
-    return mock_model, mock_preprocessor
-
-
-@dataclass
-class EvaluationResult:
-    """Data class for storing image evaluation results"""
-    file_name: str
-    image_path: str
-    scores: Dict[str, Optional[float]] = field(default_factory=dict)
-    final_score: Optional[float] = None
-    
-    def calculate_final_score(self, selected_models: List[str]) -> None:
-        """Calculate the average score from selected models"""
-        valid_scores = [
-            score for model, score in self.scores.items() 
-            if model in selected_models and score is not None
-        ]
-        self.final_score = np.mean(valid_scores) if valid_scores else None
-
-
-class BaseModel:
-    """Base class for all evaluation models"""
-    def __init__(self, name: str):
-        self.name = name
-        self.device = 'cuda' if torch.cuda.is_available() else 'cpu'
-        
-    async def evaluate_batch(self, images: List[Image.Image]) -> List[Optional[float]]:
-        """Evaluate a batch of images"""
-        raise NotImplementedError
-
-
-class AestheticShadowModel(BaseModel):
-    """Aesthetic Shadow V2 model implementation"""
-    def __init__(self):
-        super().__init__("Aesthetic Shadow")
-        logger.info(f"Loading {self.name} model...")
-        self.model = pipeline(
-            "image-classification", 
-            model="NeoChen1024/aesthetic-shadow-v2-backup",
-            device=0 if self.device == 'cuda' else -1
-        )
-    
-    async def evaluate_batch(self, images: List[Image.Image]) -> List[Optional[float]]:
-        try:
-            results = self.model(images)
-            scores = []
-            for result_set in results: # self.model(images) returns a list of lists of dicts if multiple images
-                if not isinstance(result_set, list): # If single image, it returns a list of dicts
-                    result_set = [result_set]
-                
-                # Correctly handle varying structures from the pipeline
-                hq_score = 0
-                # The pipeline might return a list of dicts for each image, or just a list of dicts for a single image
-                # For multiple images, results is List[List[Dict]]
-                # For a single image, results is List[Dict] - pipeline might batch internally
-                # The provided code expects `results` to be a list of predictions, where each prediction is a list of class scores.
-                current_image_predictions = result_set
-                if isinstance(result_set, list) and len(result_set) > 0 and isinstance(result_set[0], list) and len(images) == 1:
-                    # Handle cases where pipeline wraps single image result in an extra list
-                    current_image_predictions = result_set[0]
-
-                hq_score_found = next((p['score'] for p in current_image_predictions if p['label'] == 'hq'), 0)
-                scores.append(float(np.clip(hq_score_found * 10.0, 0.0, 10.0)))
-            return scores
-        except Exception as e:
-            logger.error(f"Error in {self.name}: {e}")
-            return [None] * len(images)
-
-
-class WaifuScorerModel(BaseModel):
-    """Waifu Scorer V3 model implementation"""
-    def __init__(self):
-        super().__init__("Waifu Scorer")
-        logger.info(f"Loading {self.name} model...")
-        self._load_model()
-    
-    def _load_model(self):
-        try:
-            import clip
-            
-            self.mlp = self._create_mlp()
-            model_path = hf_hub_download("Eugeoter/waifu-scorer-v3", "model.pth")
-            state_dict = torch.load(model_path, map_location=self.device)
-
-            # --- FIX for state_dict key mismatch ---
-            # Check if keys are prefixed (e.g., "layers.0.weight") and adjust
-            if any(key.startswith("layers.") for key in state_dict.keys()):
-                new_state_dict = {}
-                for k, v in state_dict.items():
-                    if k.startswith("layers."):
-                        new_state_dict[k[len("layers."):]] = v
-                    else:
-                        # Keep other keys if any (though error suggests all relevant keys were prefixed)
-                        new_state_dict[k] = v 
-                state_dict = new_state_dict
-            # --- END FIX ---
-
-            self.mlp.load_state_dict(state_dict)
-            self.mlp.to(self.device).eval()
-            
-            self.clip_model, self.preprocess = clip.load("ViT-L/14", device=self.device)
-            self.available = True
-        except ImportError:
-            logger.error(f"Failed to load {self.name}: PyPI package 'clip' (openai-clip) not found. Please install it.")
-            self.available = False
-        except Exception as e:
-            logger.error(f"Failed to load {self.name}: {e}")
-            self.available = False
-    
-    def _create_mlp(self) -> torch.nn.Module:
-        """Create the MLP architecture"""
-        return torch.nn.Sequential(
-            torch.nn.Linear(768, 2048),
-            torch.nn.ReLU(),
-            torch.nn.BatchNorm1d(2048),
-            torch.nn.Dropout(0.3),
-            torch.nn.Linear(2048, 512),
-            torch.nn.ReLU(),
-            torch.nn.BatchNorm1d(512),
-            torch.nn.Dropout(0.3),
-            torch.nn.Linear(512, 256),
-            torch.nn.ReLU(),
-            torch.nn.BatchNorm1d(256),
-            torch.nn.Dropout(0.2),
-            torch.nn.Linear(256, 128),
-            torch.nn.ReLU(),
-            torch.nn.BatchNorm1d(128),
-            torch.nn.Dropout(0.1),
-            torch.nn.Linear(128, 32),
-            torch.nn.ReLU(),
-            torch.nn.Linear(32, 1)
+from transformers import pipeline, Pipeline
+from tqdm import tqdm
+
+# Suppress a specific PIL warning about image size
+Image.MAX_IMAGE_PIXELS = None
+
+# --- Configuration ---
+CACHE_DIR = "./hf_cache"
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+DTYPE = torch.bfloat16 if torch.cuda.is_available() and torch.cuda.get_device_capability()[0] >= 8 else torch.float32
+
+print(f"Using device: {DEVICE} with dtype: {DTYPE}")
+
+# ==================================================================================
+# 1. MODEL ABSTRACTION: A unified interface for all scorers.
+# ==================================================================================
+
+class AestheticScorer(ABC):
+    """Abstract base class for all aesthetic scoring models."""
+
+    def __init__(self, model_name: str, repo_id: str, filename: str = None):
+        self.model_name = model_name
+        self.repo_id = repo_id
+        self.filename = filename
+        self._model = None
+        print(f"Initializing scorer: {self.model_name}")
+
+    @property
+    def model(self):
+        """Lazy-loads the model on first access."""
+        if self._model is None:
+            print(f"Loading model for '{self.model_name}'...")
+            self._model = self.load_model()
+            print(f"'{self.model_name}' model loaded.")
+        return self._model
+
+    def _download_model(self) -> str:
+        """Downloads the model file from Hugging Face Hub."""
+        return hf_hub_download(repo_id=self.repo_id, filename=self.filename, cache_dir=CACHE_DIR)
+
+    @abstractmethod
+    def load_model(self) -> Any:
+        """Loads the model and any necessary preprocessors."""
+        pass
+
+    @abstractmethod
+    def score_batch(self, image_batch: List[Image.Image]) -> List[float]:
+        """Scores a batch of images and returns a list of floats."""
+        pass
+
+    def release_model(self):
+        """Releases model from memory."""
+        if self._model is not None:
+            print(f"Releasing model: {self.model_name}")
+            del self._model
+            self._model = None
+            gc.collect()
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+
+class PipelineScorer(AestheticScorer):
+    """Scorer for models compatible with Hugging Face pipelines."""
+
+    def load_model(self) -> Pipeline:
+        """Loads a pipeline model."""
+        return pipeline(
+            "image-classification",
+            model=self.repo_id,
+            device=DEVICE,
         )
-    
-    @torch.no_grad()
-    async def evaluate_batch(self, images: List[Image.Image]) -> List[Optional[float]]:
-        if not self.available:
-            return [None] * len(images)
-        
-        try:
-            image_tensors = torch.cat([self.preprocess(img).unsqueeze(0) for img in images])
-            image_tensors = image_tensors.to(self.device)
-            
-            features = self.clip_model.encode_image(image_tensors)
-            features = features.float() # Ensure features are float32 for MLP
-            features = features / features.norm(dim=-1, keepdim=True)
-            predictions = self.mlp(features)
-            
-            scores = predictions.clamp(0, 10).cpu().numpy().flatten().tolist()
-            return scores
-        except Exception as e:
-            logger.error(f"Error in {self.name}: {e}")
-            return [None] * len(images)
-
-
-class AestheticPredictorV25Model(BaseModel):
-    """Aesthetic Predictor V2.5 model implementation"""
-    def __init__(self):
-        super().__init__("Aesthetic V2.5")
-        logger.info(f"Loading {self.name} model...")
-        try:
-            self.model, self.preprocessor = convert_v2_5_from_siglip(
-                low_cpu_mem_usage=True,
-                trust_remote_code=True, # Be cautious with trust_remote_code=True
-            )
-            if self.device == 'cuda':
-                self.model = self.model.to(torch.bfloat16).cuda()
-            self.available = True
-        except Exception as e:
-            logger.error(f"Failed to load {self.name}: {e}. Ensure 'aesthetic_predictor_v2_5.py' is correct and dependencies are installed.")
-            self.available = False
-            self.model, self.preprocessor = None, None
-
 
     @torch.no_grad()
-    async def evaluate_batch(self, images: List[Image.Image]) -> List[Optional[float]]:
-        if not self.available:
-            return [None] * len(images)
-        try:
-            images_rgb = [img.convert("RGB") for img in images]
-            pixel_values = self.preprocessor(images=images_rgb, return_tensors="pt")["pixel_values"] # Access pixel_values key
-            
-            if self.device == 'cuda':
-                pixel_values = pixel_values.to(torch.bfloat16).cuda()
-            else:
-                pixel_values = pixel_values.float() # Ensure correct dtype for CPU
-            
-            logits = self.model(pixel_values).logits # Get logits if model output is a dataclass/dict
-            # If model directly returns logits tensor:
-            # logits = self.model(pixel_values)
-
-            scores = logits.squeeze().float().cpu().numpy()
-            if scores.ndim == 0: # Handle single image case
-                scores = np.array([scores.item()]) # Use .item() for scalar tensor
-            
-            return [float(np.clip(s, 0.0, 10.0)) for s in scores]
-        except Exception as e:
-            logger.error(f"Error in {self.name}: {e}")
-            return [None] * len(images)
-
-
-class AnimeAestheticModel(BaseModel):
-    """Anime Aesthetic model implementation"""
-    def __init__(self):
-        super().__init__("Anime Score")
-        logger.info(f"Loading {self.name} model...")
-        try:
-            model_path = hf_hub_download(repo_id="skytnt/anime-aesthetic", filename="model.onnx")
-            self.session = rt.InferenceSession(model_path, providers=['CPUExecutionProvider'])
-            self.available = True
-        except Exception as e:
-            logger.error(f"Failed to load {self.name}: {e}")
-            self.available = False
-            self.session = None
-
-    async def evaluate_batch(self, images: List[Image.Image]) -> List[Optional[float]]:
-        if not self.available:
-            return [None] * len(images)
+    def score_batch(self, image_batch: List[Image.Image]) -> List[float]:
+        """Scores a batch using the pipeline and extracts the 'hq' score."""
+        results = self.model(image_batch)
         scores = []
-        for img in images:
+        for res in results:
             try:
-                score = self._process_single_image(img)
-                scores.append(float(np.clip(score * 10.0, 0.0, 10.0)))
-            except Exception as e:
-                logger.error(f"Error in {self.name} for single image processing: {e}")
-                scores.append(None)
+                # Find the score for the 'hq' (high quality) label
+                hq_score = next(item['score'] for item in res if item['label'] == 'hq')
+                scores.append(round(hq_score * 10.0, 4))
+            except (StopIteration, TypeError):
+                scores.append(0.0)
         return scores
-    
-    def _process_single_image(self, img: Image.Image) -> float:
-        """Process a single image through the model"""
-        # Ensure image is RGB
-        img_rgb = img.convert("RGB")
-        img_np = np.array(img_rgb).astype(np.float32) / 255.0
-        
-        # Original model expects BGR, but most image ops are RGB.
-        # If ONNX model was trained on BGR, conversion might be needed.
-        # Assuming model takes RGB based on common practices unless specified.
-        # If it expects BGR: img_np = cv2.cvtColor(np.array(img.convert("RGB")), cv2.COLOR_RGB2BGR).astype(np.float32) / 255.0
 
+class ONNXScorer(AestheticScorer):
+    """Scorer for ONNX-based models."""
 
-        size = 224 # Typical size for many aesthetic models, 768 is very large for direct input.
-                   # The original notebook for skytnt/anime-aesthetic uses 224x224.
-                   # Let's assume 224 unless documentation says 768.
-                   # The error log doesn't specify input size issues, but 768 is unusually large for this type of ONNX model.
-                   # Sticking to original code's 768 for now, but this is a potential point of error if model expects 224.
+    def load_model(self) -> rt.InferenceSession:
+        """Loads an ONNX inference session."""
+        model_path = self._download_model()
+        return rt.InferenceSession(model_path, providers=['CUDAExecutionProvider' if DEVICE == 'cuda' else 'CPUExecutionProvider'])
 
+    def _preprocess(self, img: Image.Image) -> np.ndarray:
+        """Preprocesses a single image for the Anime Aesthetic model."""
+        img_np = np.array(img.convert("RGB")).astype(np.float32) / 255.0
+        s = 768
         h, w = img_np.shape[:2]
-        
         if h > w:
-            new_h, new_w = size, int(size * w / h)
+            new_h, new_w = s, int(s * w / h)
         else:
-            new_h, new_w = int(size * h / w), size
+            new_h, new_w = int(s * h / w), s
         
-        resized_img = cv2.resize(img_np, (new_w, new_h), interpolation=cv2.INTER_AREA) # Use INTER_AREA for shrinking
+        resized = cv2.resize(img_np, (new_w, new_h), interpolation=cv2.INTER_AREA)
+        canvas = np.zeros((s, s, 3), dtype=np.float32)
+        pad_h, pad_w = (s - new_h) // 2, (s - new_w) // 2
+        canvas[pad_h:pad_h + new_h, pad_w:pad_w + new_w] = resized
         
-        canvas = np.ones((size, size, 3), dtype=np.float32) * 0.5 # Pad with gray, or use black (0)
-        
-        pad_h = (size - new_h) // 2
-        pad_w = (size - new_w) // 2
+        return np.transpose(canvas, (2, 0, 1))[np.newaxis, :]
+
+    def score_batch(self, image_batch: List[Image.Image]) -> List[float]:
+        """Scores images one by one as this model doesn't support batching."""
+        scores = []
+        for img in image_batch:
+            try:
+                input_tensor = self._preprocess(img)
+                pred = self.model.run(None, {"img": input_tensor})[0].item()
+                scores.append(round(pred * 10.0, 4))
+            except Exception:
+                scores.append(0.0)
+        return scores
+
+class CLIPMLPScorer(AestheticScorer):
+    """Scorer for models using a CLIP backbone and an MLP head."""
+
+    class MLP(torch.nn.Module):
+        def __init__(self, input_size: int):
+            super().__init__()
+            self.layers = torch.nn.Sequential(
+                torch.nn.Linear(input_size, 1024),
+                torch.nn.ReLU(),
+                torch.nn.Dropout(0.2),
+                torch.nn.Linear(1024, 128),
+                torch.nn.ReLU(),
+                torch.nn.Dropout(0.2),
+                torch.nn.Linear(128, 64),
+                torch.nn.ReLU(),
+                torch.nn.Linear(64, 16),
+                torch.nn.ReLU(),
+                torch.nn.Linear(16, 1),
+            )
+        def forward(self, x):
+            return self.layers(x)
+
+    def load_model(self) -> Dict[str, Any]:
+        """Loads both the CLIP model and the custom MLP head."""
+        import clip # Lazy import
         
-        canvas[pad_h:pad_h+new_h, pad_w:pad_w+new_w, :] = resized_img
+        model_path = self._download_model()
         
-        input_tensor = np.transpose(canvas, (2, 0, 1))[np.newaxis, :].astype(np.float32)
-        return self.session.run(None, {"img": input_tensor})[0].item()
+        mlp = self.MLP(input_size=768) # ViT-L/14 has 768 features
+        state_dict = torch.load(model_path, map_location=DEVICE)
+        mlp.load_state_dict(state_dict)
+        mlp.to(device=DEVICE, dtype=DTYPE)
+        mlp.eval()
 
+        clip_model, preprocess = clip.load("ViT-L/14", device=DEVICE)
+        
+        return {"mlp": mlp, "clip": clip_model, "preprocess": preprocess}
 
-class ImageEvaluator:
-    """Main class for managing image evaluation"""
-    def __init__(self):
-        self.models: Dict[str, BaseModel] = {}
-        self._initialize_models()
-        self.results: List[EvaluationResult] = []
+    @torch.no_grad()
+    def score_batch(self, image_batch: List[Image.Image]) -> List[float]:
+        """Scores a batch using CLIP features and the MLP head."""
+        preprocess = self.model['preprocess']
+        image_tensors = torch.cat([preprocess(img).unsqueeze(0) for img in image_batch]).to(DEVICE)
         
-    def _initialize_models(self):
-        """Initialize all evaluation models"""
-        model_classes = [
-            ("aesthetic_shadow", AestheticShadowModel),
-            ("waifu_scorer", WaifuScorerModel),
-            ("aesthetic_predictor_v2_5", AestheticPredictorV25Model),
-            ("anime_aesthetic", AnimeAestheticModel),
-        ]
+        image_features = self.model['clip'].encode_image(image_tensors)
+        image_features /= image_features.norm(dim=-1, keepdim=True)
         
-        for key, model_class in model_classes:
-            try:
-                model_instance = model_class()
-                # Store only if model is available (loaded successfully)
-                if hasattr(model_instance, 'available') and model_instance.available:
-                    self.models[key] = model_instance
-                    logger.info(f"Successfully loaded and initialized {model_instance.name} ({key})")
-                elif not hasattr(model_instance, 'available'): # For models without explicit 'available' flag
-                    self.models[key] = model_instance
-                    logger.info(f"Successfully loaded and initialized {model_instance.name} ({key}) (availability not explicitly tracked)")
-                else:
-                    logger.warning(f"{model_instance.name} ({key}) was not loaded successfully and will be skipped.")
-            except Exception as e:
-                logger.error(f"Failed to initialize {key}: {e}")
-    
-    async def evaluate_images(
-        self, 
-        file_paths: List[str], 
-        selected_models: List[str],
-        batch_size: int = 8,
-        progress_callback = None
-    ) -> Tuple[List[EvaluationResult], List[str]]:
-        """Evaluate images with selected models"""
-        logs = []
-        current_results = [] # Use a local list for current evaluation
+        # Pass features through MLP
+        predictions = self.model['mlp'](image_features.to(DTYPE)).squeeze(-1)
+        scores = predictions.float().cpu().numpy()
         
-        images_data = [] # Store tuples of (image, original_path)
-        for path_obj in file_paths: # file_paths are UploadFile objects from Gradio
-            path = path_obj.name # .name gives the temporary file path
-            try:
-                img = Image.open(path).convert("RGB")
-                images_data.append({"image": img, "path": path, "name": Path(path).name})
-            except Exception as e:
-                logs.append(f"Failed to load {Path(path).name}: {e}")
+        return [round(float(s), 4) for s in scores]
+
+# --- Model Registry ---
+MODEL_REGISTRY: Dict[str, Type[AestheticScorer]] = {
+    "Aesthetic Shadow V2": PipelineScorer(
+        "Aesthetic Shadow V2", "shadowlilac/aesthetic-shadow-v2"
+    ),
+    "Waifu Scorer V2": CLIPMLPScorer(
+        "Waifu Scorer V2", "skytnt/waifu-aesthetic-scorer", "model.pth"
+    ),
+    "Anime Scorer": ONNXScorer(
+        "Anime Scorer", "skytnt/anime-aesthetic", "model.onnx"
+    )
+}
+
+# In-memory cache for loaded model instances
+_loaded_models_cache: Dict[str, AestheticScorer] = {}
+
+
+# ==================================================================================
+# 2. CORE PROCESSING LOGIC
+# ==================================================================================
+
+def get_scorers(model_names: List[str]) -> List[AestheticScorer]:
+    """Retrieves and caches scorer instances based on selected names."""
+    # Release models that are no longer selected
+    for name, scorer in list(_loaded_models_cache.items()):
+        if name not in model_names:
+            scorer.release_model()
+            del _loaded_models_cache[name]
+
+    # Load newly selected models
+    scorers = []
+    for name in model_names:
+        if name in _loaded_models_cache:
+            scorers.append(_loaded_models_cache[name])
+        elif name in MODEL_REGISTRY:
+            scorer = MODEL_REGISTRY[name]
+            _loaded_models_cache[name] = scorer
+            scorers.append(scorer)
+    return scorers
+    
+def evaluate_images(
+    files: List[gr.File],
+    selected_model_names: List[str],
+    batch_size: int,
+    progress: gr.Progress = gr.Progress(track_tqdm=True),
+) -> pd.DataFrame:
+    """
+    Main function to process images, run them through selected models,
+    and return results as a Pandas DataFrame.
+    """
+    if not files:
+        gr.Warning("No images uploaded. Please upload files to evaluate.")
+        return pd.DataFrame()
         
-        if not images_data:
-            logs.append("No valid images to process")
-            return current_results, logs
+    if not selected_model_names:
+        gr.Warning("No models selected. Please select at least one model.")
+        return pd.DataFrame()
+
+    try:
+        image_paths = [Path(f.name) for f in files]
+        all_results = []
+        scorers = get_scorers(selected_model_names)
         
-        logs.append(f"Loaded {len(images_data)} images")
+        # Use a single tqdm instance for progress tracking
+        pbar = tqdm(total=len(image_paths), desc="Processing images")
         
-        # Filter selected_models to only include those that were successfully initialized
-        active_selected_models = [m_key for m_key in selected_models if m_key in self.models]
-        if len(active_selected_models) != len(selected_models):
-            disabled_models = set(selected_models) - set(active_selected_models)
-            logs.append(f"Warning: The following models were selected but are not available: {', '.join(disabled_models)}")
-
-
-        # Initialize results for all images first
-        for data in images_data:
-            result = EvaluationResult(
-                file_name=data["name"],
-                image_path=data["path"] # Store original path for display if needed
-            )
-            current_results.append(result)
-
-        total_images = len(images_data)
-        processed_count = 0
-
-        for model_key in active_selected_models:
-            model_instance = self.models[model_key]
-            logs.append(f"Processing with {model_instance.name}...")
+        for i in range(0, len(image_paths), batch_size):
+            batch_paths = image_paths[i : i + batch_size]
+            
+            # Load images for the current batch
+            try:
+                batch_images = [Image.open(p).convert("RGB") for p in batch_paths]
+            except Exception as e:
+                gr.Warning(f"Skipping a batch due to an error loading an image: {e}")
+                pbar.update(len(batch_paths))
+                continue
+
+            # Get scores from all selected models for the batch
+            batch_scores: Dict[str, List[float]] = {}
+            for scorer in scorers:
+                batch_scores[scorer.model_name] = scorer.score_batch(batch_images)
             
-            for i in range(0, total_images, batch_size):
-                batch_data = images_data[i:i + batch_size]
-                batch_images_pil = [d["image"] for d in batch_data]
+            # Collate results for the batch
+            for j, path in enumerate(batch_paths):
+                result_row = {"Image": Image.open(path), "Filename": path.name}
                 
-                try:
-                    scores = await model_instance.evaluate_batch(batch_images_pil)
-                    for k, score in enumerate(scores):
-                        # Find the corresponding EvaluationResult object
-                        # This assumes current_results is ordered the same as images_data
-                        current_results[i+k].scores[model_key] = score 
-                except Exception as e:
-                    logger.error(f"Error evaluating batch with {model_instance.name}: {e}")
-                    for k in range(len(batch_images_pil)):
-                        current_results[i+k].scores[model_key] = None
+                scores_for_avg = []
+                for scorer in scorers:
+                    score = batch_scores[scorer.model_name][j]
+                    result_row[scorer.model_name] = score
+                    scores_for_avg.append(score)
                 
-                processed_count += len(batch_images_pil)
-                if progress_callback:
-                    # Progress based on overall images processed per model, then average over models
-                    # This logic might need refinement for a smoother progress bar experience
-                    current_model_idx = active_selected_models.index(model_key)
-                    overall_progress = ((current_model_idx / len(active_selected_models)) + \
-                                       ((i + len(batch_data)) / total_images) / len(active_selected_models)) * 100
-                    progress_callback(min(overall_progress, 100), f"Model: {model_instance.name}, Batch {i//batch_size + 1}")
-        
-        # Calculate final scores for all results
-        for result in current_results:
-            result.calculate_final_score(active_selected_models)
+                # Calculate average score
+                if scores_for_avg:
+                    result_row["Average Score"] = round(np.mean(scores_for_avg), 4)
+                else:
+                    result_row["Average Score"] = 0.0
+                
+                all_results.append(result_row)
             
-        logs.append("Evaluation complete.")
-        self.results = current_results # Update the main results list
-        return current_results, logs
-    
-    def get_results_dataframe(self, selected_models_keys: List[str]) -> pd.DataFrame:
-        if not self.results:
-            return pd.DataFrame()
+            pbar.update(len(batch_paths))
+
+        pbar.close()
         
-        data = []
-        # Ensure selected_models_keys only contains keys of successfully loaded models
-        valid_selected_models_keys = [key for key in selected_models_keys if key in self.models]
-
-        for result in self.results:
-            row = {
-                'File Name': result.file_name,
-                # For Gradio display, we might want to show the image itself
-                # 'Image': result.image_path, # This will show the temp path
-                'Image': gr.Image(result.image_path, type="pil", height=100, width=100) # Display thumbnail
-            }
-            
-            for model_key in valid_selected_models_keys:
-                model_name = self.models[model_key].name
-                score = result.scores.get(model_key)
-                row[model_name] = f"{score:.4f}" if score is not None else "N/A"
+        if not all_results:
+            gr.Warning("Processing completed, but no results were generated.")
+            return pd.DataFrame()
             
-            row['Final Score'] = f"{result.final_score:.4f}" if result.final_score is not None else "N/A"
-            data.append(row)
+        return pd.DataFrame(all_results)
         
-        # Define column order
-        column_order = ['File Name', 'Image'] + \
-                       [self.models[key].name for key in valid_selected_models_keys if key in self.models] + \
-                       ['Final Score']
-        
-        df = pd.DataFrame(data)
-        if not df.empty:
-            df = df[column_order] # Reorder columns
-        return df
+    except Exception as e:
+        gr.Error(f"A critical error occurred: {e}")
+        # Clean up in case of failure
+        for scorer in _loaded_models_cache.values():
+            scorer.release_model()
+        _loaded_models_cache.clear()
+        return pd.DataFrame()
+
 
+# ==================================================================================
+# 3. GRADIO USER INTERFACE
+# ==================================================================================
 
-def create_interface():
-    """Create the Gradio interface"""
-    evaluator = ImageEvaluator()
+def create_ui() -> gr.Blocks:
+    """Creates and configures the Gradio web interface."""
     
-    model_options = [
-        (model.name, key) for key, model in evaluator.models.items()
-    ]
-    # If some models failed to load, model_options will be shorter.
-    # Provide default selected models based on successfully loaded ones.
-    default_selected_model_labels = [name for name, key in model_options]
-
-
-    with gr.Blocks(theme=gr.themes.Soft(), title="Image Evaluation Tool") as demo:
-        # NOTE on Gradio TypeError:
-        # The traceback "TypeError: argument of type 'bool' is not iterable" during Gradio startup
-        # (specifically in `gradio_client/utils.py` while processing component schemas)
-        # often indicates an incompatibility with the Gradio version being used or a bug
-        # in how Gradio generates schemas for certain component configurations.
-        # The most common recommendation is to:
-        # 1. Ensure your Gradio library is up-to-date: `pip install --upgrade gradio`
-        # 2. If the error persists, try simplifying complex component configurations or
-        #    testing with a known stable version of Gradio.
-        # The code below follows standard Gradio practices, so the error is likely
-        # environment-related if it persists after the WaifuScorer fix.
-
-        gr.Markdown("""
-        # 🎨 Advanced Image Evaluation Tool
-        
-        Evaluate images using state-of-the-art aesthetic and quality prediction models.
-        Upload your images and select the models you want to use for evaluation.
-        """)
-        
+    all_model_names = list(MODEL_REGISTRY.keys())
+    
+    # Define headers and datatypes for the results table
+    dataframe_headers = ["Image", "Filename"] + all_model_names + ["Average Score"]
+    dataframe_datatypes = ["image", "str"] + ["number"] * (len(all_model_names) + 1)
+    
+    with gr.Blocks(theme=gr.themes.Soft(), title="Image Aesthetic Scorer") as demo:
+        gr.Markdown(
+            """
+            # 🖼️ Modern Image Aesthetic Scorer
+            Upload your images, select the scoring models, and click 'Evaluate'.
+            The results table supports **interactive sorting** (click on headers) and can be **downloaded as a CSV**.
+            """
+        )
+
         with gr.Row():
             with gr.Column(scale=1):
-                input_files = gr.File(
+                gr.Markdown("### ⚙️ Settings")
+                input_files = gr.Files(
                     label="Upload Images",
                     file_count="multiple",
-                    file_types=["image"]
-                )
-                
-                model_checkboxes = gr.CheckboxGroup(
-                    choices=[label for label, _ in model_options], # Use labels for choices
-                    value=default_selected_model_labels, # Default to all loaded models
-                    label="Select Models",
-                    info="Choose which models to use for evaluation. Models that failed to load will not be available."
-                )
-                
-                batch_size_slider = gr.Slider( # Renamed to avoid conflict with batch_size variable name
-                    minimum=1,
-                    maximum=32, # Max 64 might be too high for some GPUs
-                    value=8,
-                    step=1,
-                    label="Batch Size",
-                    info="Number of images to process at once per model."
+                    file_types=["image"],
                 )
                 
+                with gr.Accordion("Advanced Configuration", open=False):
+                    model_checkboxes = gr.CheckboxGroup(
+                        choices=all_model_names,
+                        value=all_model_names,
+                        label="Scoring Models",
+                        info="Choose which models to use for evaluation.",
+                    )
+                    batch_size_slider = gr.Slider(
+                        minimum=1,
+                        maximum=64,
+                        value=8,
+                        step=1,
+                        label="Batch Size",
+                        info="Adjust based on your VRAM. Higher is faster.",
+                    )
+
                 with gr.Row():
-                    evaluate_btn = gr.Button("🚀 Evaluate Images", variant="primary", scale=2)
-                    clear_btn = gr.Button("🗑️ Clear", variant="secondary", scale=1)
+                    process_button = gr.Button("🚀 Evaluate Images", variant="primary")
+                    clear_button = gr.Button("🧹 Clear All")
             
-            with gr.Column(scale=3): # Increased scale for results
-                # Using gr.Textbox for logs, as gr.Progress is now a status tracker
-                logs_display = gr.Textbox( 
-                    label="Processing Logs",
-                    lines=10,
-                    max_lines=20, # Allow more lines
-                    autoscroll=True,
-                    interactive=False
+            with gr.Column(scale=3):
+                gr.Markdown("### 📊 Results")
+                results_dataframe = gr.DataFrame(
+                    headers=dataframe_headers,
+                    datatype=dataframe_datatypes,
+                    label="Evaluation Scores",
+                    interactive=True,
+                    # Enable the download button directly on the component
                 )
-                
-                # Using gr.Label for progress status updates
-                progress_status = gr.Label(label="Progress")
-
-                results_df_display = gr.Dataframe(
-                    label="Evaluation Results",
-                    interactive=False,
-                    wrap=True,
-                    # Define column types for better display, especially for images
-                    # headers=['File Name', 'Image'] + default_selected_model_labels + ['Final Score'],
-                    # col_count=(len(default_selected_model_labels) + 3, "fixed"),
-                    # datatype=['str', 'image'] + ['number'] * (len(default_selected_model_labels) + 1)
-                )
-                
-                download_button = gr.Button("📥 Download Results (CSV)", variant="secondary") # Changed from gr.Button to potentially use gr.DownloadButton later
-                # download_file_output = gr.File(label="Download CSV", visible=False, interactive=False)
-                # Using gr.File for download output triggered by a regular button
-                download_file_output_component = gr.File(label="Download", visible=False)
-
+                # This is a cleaner way to show the download button
+                results_dataframe.style(height=800, show_download_button=True)
 
-        # State for storing full EvaluationResult objects if needed for more complex interactions
-        # For this setup, regenerating DataFrame from evaluator.results is generally sufficient
-        # results_state = gr.State([]) # If storing raw results is complex, simplify or manage carefully
-
-        async def run_evaluation(files, selected_model_labels, current_batch_size, progress=gr.Progress(track_tqdm=True)):
-            if not files:
-                return "Please upload images first.", pd.DataFrame(), [], "No files uploaded."
-            
-            # Convert display labels back to model keys
-            selected_model_keys = [key for label, key in model_options if label in selected_model_labels]
-            
-            if not selected_model_keys:
-                return "Please select at least one model.", pd.DataFrame(), [], "No models selected."
 
-            # file_paths = [f.name for f in files] # .name gives temp path of UploadFile
-            
-            # Progress callback
-            # def update_progress_display(value, desc="Processing..."):
-            #    progress(value / 100, desc=f"{desc} {value:.0f}%")
-            #    return f"{desc} {value:.0f}%" # For gr.Label
-
-            # Use gr.Progress context for automatic updates with iterators
-            # However, for manual updates with batching, direct calls are fine.
-            # We'll update logs_display and progress_status manually.
-            
-            progress_updates = []
-            def progress_callback_for_eval(p_value, p_desc):
-                progress(p_value / 100, desc=p_desc) # Update the main progress component
-                # logs_display.value += f"\n{p_desc} - {p_value:.0f}%" # This will make logs messy
-                progress_updates.append(f"{p_desc} - {p_value:.0f}%")
-
-
-            # Evaluate images
-            processed_results, log_messages = await evaluator.evaluate_images(
-                files, # Pass the list of UploadFile objects directly
-                selected_model_keys,
-                int(current_batch_size), # Ensure batch_size is int
-                progress_callback_for_eval # Pass the callback
-            )
-            
-            df = evaluator.get_results_dataframe(selected_model_keys)
-            log_text = "\n".join(log_messages + progress_updates)
-            
-            final_status = "Evaluation complete." if processed_results else "Evaluation failed or no results."
-            progress(1.0, desc=final_status) # Mark progress as complete
-
-            return log_text, df, final_status # Removed results_state for simplicity
-
-        def handle_model_selection_change(selected_model_labels_updated):
-            # Called when checkbox group changes. evaluator.results should already be populated.
-            if not evaluator.results:
-                return pd.DataFrame() # No results to re-filter/re-calculate
-
-            selected_model_keys_updated = [key for label, key in model_options if label in selected_model_labels_updated]
-            
-            # Recalculate final scores for all existing results based on new selection
-            for res_obj in evaluator.results:
-                res_obj.calculate_final_score(selected_model_keys_updated)
-            
-            return evaluator.get_results_dataframe(selected_model_keys_updated)
-
-        def clear_all_outputs():
-            evaluator.results = [] # Clear stored results in the evaluator
-            return "", pd.DataFrame(), "Cleared.", None # Log, DataFrame, Progress Status, Download File
-
-        def generate_csv_for_download(selected_model_labels_for_csv):
-            if not evaluator.results:
-                gr.Warning("No results to download.")
-                return None
-
-            selected_model_keys_for_csv = [key for label, key in model_options if label in selected_model_labels_for_csv]
-            
-            # Get DataFrame, but exclude the gr.Image column for CSV
-            df_for_csv = evaluator.get_results_dataframe(selected_model_keys_for_csv).copy()
-            if 'Image' in df_for_csv.columns:
-                df_for_csv.drop(columns=['Image'], inplace=True)
-            
-            if df_for_csv.empty:
-                gr.Warning("No data to download based on current selection.")
-                return None
-
-            import tempfile
-            with tempfile.NamedTemporaryFile(mode='w+', delete=False, suffix='.csv', encoding='utf-8') as tmp_file:
-                df_for_csv.to_csv(tmp_file.name, index=False)
-                return tmp_file.name
-        
-        evaluate_btn.click(
-            fn=run_evaluation,
+        # --- Event Handlers ---
+        process_button.click(
+            fn=evaluate_images,
             inputs=[input_files, model_checkboxes, batch_size_slider],
-            outputs=[logs_display, results_df_display, progress_status] # Removed results_state
-        )
-        
-        model_checkboxes.change(
-            fn=handle_model_selection_change,
-            inputs=[model_checkboxes],
-            outputs=[results_df_display]
-        )
-        
-        clear_btn.click(
-            fn=clear_all_outputs,
-            outputs=[logs_display, results_df_display, progress_status, download_file_output_component]
+            outputs=[results_dataframe],
+            concurrency_limit=1 # Only one evaluation at a time
         )
-        
-        download_button.click(
-            fn=generate_csv_for_download,
-            inputs=[model_checkboxes],
-            outputs=[download_file_output_component]
+
+        def clear_outputs():
+            # Release all models from memory when clearing
+            for scorer in _loaded_models_cache.values():
+                scorer.release_model()
+            _loaded_models_cache.clear()
+            gr.Info("Cleared results and released models from memory.")
+            # Return an empty DataFrame to clear the table
+            return pd.DataFrame()
+
+        clear_button.click(
+            fn=clear_outputs,
+            inputs=[],
+            outputs=[results_dataframe],
         )
         
-        gr.Markdown("""
-        ### 📝 Notes
-        - **Model Selection**: Choose which models to use for evaluation. The final score is the average of the selected models. Models that failed to load during startup will not be listed or will be ignored.
-        - **Batch Size**: Adjust based on your system's VRAM and RAM. Smaller batches use less memory but may be slower overall.
-        - **Results Table**: Displays scores from selected models and the final average. Images are shown as thumbnails.
-        - **Download**: Export results (excluding image thumbnails) as a CSV file for further analysis.
-        
-        ### 🎯 Score Interpretation (General Guide)
-        - **7-10**: High quality/aesthetic appeal
-        - **5-7**: Medium quality
-        - **0-5**: Lower quality
-        _(Note: Score ranges and interpretations can vary between models.)_
-        """)
-    
     return demo
 
+# ==================================================================================
+# 4. APPLICATION ENTRY POINT
+# ==================================================================================
 
 if __name__ == "__main__":
-    # Ensure 'aesthetic_predictor_v2_5.py' exists and 'openai-clip' is installed for WaifuScorer
-    # Example: pip install openai-clip transformers==4.30.2 onnxruntime gradio pandas Pillow opencv-python
-    # Check specific model requirements.
+    # Ensure cache directory exists
+    os.makedirs(CACHE_DIR, exist_ok=True)
     
-    # Create and launch the interface
-    app_interface = create_interface()
-    # Adding .queue() is good for handling multiple users or long-running tasks.
-    # Set debug=True for more detailed Gradio errors during development.
-    app_interface.queue().launch(debug=True)
+    app = create_ui()
+    app.queue().launch(share=False)