Update app.py

app.py

@@ -20,7 +20,16 @@ logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(
 logger = logging.getLogger(__name__)
 
 # Import aesthetic predictor function
-from aesthetic_predictor_v2_5 import convert_v2_5_from_siglip
+# 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
@@ -66,9 +75,23 @@ class AestheticShadowModel(BaseModel):
         try:
             results = self.model(images)
             scores = []
-            for result in results:
-                hq_score = next((p['score'] for p in result if p['label'] == 'hq'), 0)
-                scores.append(float(np.clip(hq_score * 10.0, 0.0, 10.0)))
+            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}")
@@ -86,16 +109,31 @@ class WaifuScorerModel(BaseModel):
         try:
             import clip
             
-            # Load MLP model
             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()
             
-            # Load CLIP model
             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
@@ -130,12 +168,11 @@ class WaifuScorerModel(BaseModel):
             return [None] * len(images)
         
         try:
-            # Process images
             image_tensors = torch.cat([self.preprocess(img).unsqueeze(0) for img in images])
             image_tensors = image_tensors.to(self.device)
             
-            # Extract features and predict
             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)
             
@@ -151,25 +188,40 @@ class AestheticPredictorV25Model(BaseModel):
     def __init__(self):
         super().__init__("Aesthetic V2.5")
         logger.info(f"Loading {self.name} model...")
-        self.model, self.preprocessor = convert_v2_5_from_siglip(
-            low_cpu_mem_usage=True,
-            trust_remote_code=True,
-        )
-        if self.device == 'cuda':
-            self.model = self.model.to(torch.bfloat16).cuda()
-    
+        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
+            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
             
-            scores = self.model(pixel_values).logits.squeeze().float().cpu().numpy()
-            if scores.ndim == 0:
-                scores = np.array([scores])
+            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:
@@ -182,41 +234,63 @@ class AnimeAestheticModel(BaseModel):
     def __init__(self):
         super().__init__("Anime Score")
         logger.info(f"Loading {self.name} model...")
-        model_path = hf_hub_download(repo_id="skytnt/anime-aesthetic", filename="model.onnx")
-        self.session = rt.InferenceSession(model_path, providers=['CPUExecutionProvider'])
-    
+        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)
         scores = []
         for img in images:
             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: {e}")
+                logger.error(f"Error in {self.name} for single image processing: {e}")
                 scores.append(None)
         return scores
     
     def _process_single_image(self, img: Image.Image) -> float:
         """Process a single image through the model"""
-        img_np = np.array(img).astype(np.float32) / 255.0
-        size = 768
+        # 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
+
+
+        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.
+
         h, w = img_np.shape[:2]
         
-        # Calculate new dimensions
         if h > w:
             new_h, new_w = size, int(size * w / h)
         else:
             new_h, new_w = int(size * h / w), size
         
-        # Resize and center
-        resized = cv2.resize(img_np, (new_w, new_h))
-        canvas = np.zeros((size, size, 3), dtype=np.float32)
+        resized_img = cv2.resize(img_np, (new_w, new_h), interpolation=cv2.INTER_AREA) # Use INTER_AREA for shrinking
+        
+        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
-        canvas[pad_h:pad_h+new_h, pad_w:pad_w+new_w] = resized
         
-        # Prepare input
-        input_tensor = np.transpose(canvas, (2, 0, 1))[np.newaxis, :]
+        canvas[pad_h:pad_h+new_h, pad_w:pad_w+new_w, :] = resized_img
+        
+        input_tensor = np.transpose(canvas, (2, 0, 1))[np.newaxis, :].astype(np.float32)
         return self.session.run(None, {"img": input_tensor})[0].item()
 
 
@@ -238,10 +312,18 @@ class ImageEvaluator:
         
         for key, model_class in model_classes:
             try:
-                self.models[key] = model_class()
-                logger.info(f"Successfully loaded {key}")
+                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 load {key}: {e}")
+                logger.error(f"Failed to initialize {key}: {e}")
     
     async def evaluate_images(
         self, 
@@ -252,99 +334,137 @@ class ImageEvaluator:
     ) -> Tuple[List[EvaluationResult], List[str]]:
         """Evaluate images with selected models"""
         logs = []
-        results = []
+        current_results = [] # Use a local list for current evaluation
         
-        # Load images
-        images = []
-        valid_paths = []
-        for path in file_paths:
+        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.append(img)
-                valid_paths.append(path)
+                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}")
         
-        if not images:
+        if not images_data:
             logs.append("No valid images to process")
-            return results, logs
-        
-        logs.append(f"Loaded {len(images)} images")
+            return current_results, logs
         
-        # Process in batches
-        total_batches = (len(images) + batch_size - 1) // batch_size
+        logs.append(f"Loaded {len(images_data)} images")
         
-        for batch_idx in range(0, len(images), batch_size):
-            batch_images = images[batch_idx:batch_idx + batch_size]
-            batch_paths = valid_paths[batch_idx:batch_idx + batch_size]
-            
-            # Evaluate with each selected model
-            batch_results = {}
-            for model_key in selected_models:
-                if model_key in self.models:
-                    scores = await self.models[model_key].evaluate_batch(batch_images)
-                    batch_results[model_key] = scores
-                    logs.append(f"Processed batch {batch_idx//batch_size + 1}/{total_batches} with {self.models[model_key].name}")
+        # 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}...")
             
-            # Create results
-            for i, (path, img) in enumerate(zip(batch_paths, batch_images)):
-                result = EvaluationResult(
-                    file_name=Path(path).name,
-                    image_path=path
-                )
+            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]
                 
-                for model_key in selected_models:
-                    if model_key in batch_results:
-                        result.scores[model_key] = batch_results[model_key][i]
+                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
                 
-                result.calculate_final_score(selected_models)
-                results.append(result)
-            
-            # Update progress
-            if progress_callback:
-                progress = (batch_idx + batch_size) / len(images) * 100
-                progress_callback(min(progress, 100))
+                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}")
         
-        self.results = results
-        return results, logs
+        # Calculate final scores for all results
+        for result in current_results:
+            result.calculate_final_score(active_selected_models)
+            
+        logs.append("Evaluation complete.")
+        self.results = current_results # Update the main results list
+        return current_results, logs
     
-    def get_results_dataframe(self, selected_models: List[str]) -> pd.DataFrame:
-        """Convert results to pandas DataFrame"""
+    def get_results_dataframe(self, selected_models_keys: List[str]) -> pd.DataFrame:
         if not self.results:
             return pd.DataFrame()
         
         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,
-                'Image': result.image_path,
+                # 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
             }
             
-            # Add model scores
-            for model_key in selected_models:
-                if model_key in self.models:
-                    score = result.scores.get(model_key)
-                    row[self.models[model_key].name] = f"{score:.4f}" if score is not None else "N/A"
+            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"
             
             row['Final Score'] = f"{result.final_score:.4f}" if result.final_score is not None else "N/A"
             data.append(row)
         
-        return pd.DataFrame(data)
+        # 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
 
 
 def create_interface():
     """Create the Gradio interface"""
     evaluator = ImageEvaluator()
     
-    # Model options for checkbox
     model_options = [
-        ("Aesthetic Shadow", "aesthetic_shadow"),
-        ("Waifu Scorer", "waifu_scorer"),
-        ("Aesthetic V2.5", "aesthetic_predictor_v2_5"),
-        ("Anime Score", "anime_aesthetic")
+        (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
         
@@ -361,158 +481,187 @@ def create_interface():
                 )
                 
                 model_checkboxes = gr.CheckboxGroup(
-                    choices=[label for label, _ in model_options],
-                    value=[label for label, _ in model_options],
+                    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"
+                    info="Choose which models to use for evaluation. Models that failed to load will not be available."
                 )
                 
-                with gr.Row():
-                    batch_size = gr.Slider(
-                        minimum=1,
-                        maximum=64,
-                        value=8,
-                        step=1,
-                        label="Batch Size",
-                        info="Number of images to process at once"
-                    )
+                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."
+                )
                 
                 with gr.Row():
                     evaluate_btn = gr.Button("🚀 Evaluate Images", variant="primary", scale=2)
                     clear_btn = gr.Button("🗑️ Clear", variant="secondary", scale=1)
             
-            with gr.Column(scale=2):
-                progress = gr.Progress()
-                logs = gr.Textbox(
+            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=10,
-                    autoscroll=True
+                    max_lines=20, # Allow more lines
+                    autoscroll=True,
+                    interactive=False
                 )
                 
-                results_df = gr.Dataframe(
+                # 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
+                    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_btn = gr.Button("📥 Download Results (CSV)", variant="secondary")
-                download_file = gr.File(visible=False)
-        
-        # State for storing results
-        results_state = gr.State([])
-        
-        async def process_images(files, selected_model_labels, batch_size, progress=gr.Progress()):
-            """Process uploaded images"""
+                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)
+
+
+        # 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(), []
+                return "Please upload images first.", pd.DataFrame(), [], "No files uploaded."
             
-            # Convert labels to keys
-            selected_models = [key for label, key in model_options if label in selected_model_labels]
+            # Convert display labels back to model keys
+            selected_model_keys = [key for label, key in model_options if label in selected_model_labels]
             
-            # Get file paths
-            file_paths = [f.name for f in files]
+            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(value):
-                progress(value / 100, desc=f"Processing images... {value:.0f}%")
+            # 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
-            results, logs = await evaluator.evaluate_images(
-                file_paths,
-                selected_models,
-                batch_size,
-                update_progress
+            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
             )
             
-            # Create DataFrame
-            df = evaluator.get_results_dataframe(selected_models)
-            
-            # Format logs
-            log_text = "\n".join(logs[-10:])  # Show last 10 logs
-            
-            return log_text, df, results
-        
-        def update_results_on_model_change(selected_model_labels, results):
-            """Update results when model selection changes"""
-            if not results:
-                return pd.DataFrame()
-            
-            # Convert labels to keys
-            selected_models = [key for label, key in model_options if label in selected_model_labels]
+            df = evaluator.get_results_dataframe(selected_model_keys)
+            log_text = "\n".join(log_messages + progress_updates)
             
-            # Recalculate final scores
-            for result in results:
-                result.calculate_final_score(selected_models)
+            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]
             
-            # Update evaluator results
-            evaluator.results = results
+            # 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)
             
-            # Create updated DataFrame
-            return evaluator.get_results_dataframe(selected_models)
-        
-        def clear_interface():
-            """Clear all results"""
-            return "", pd.DataFrame(), [], None
-        
-        def prepare_download(selected_model_labels, results):
-            """Prepare CSV file for download"""
-            if not results:
+            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]
             
-            # Convert labels to keys
-            selected_models = [key for label, key in model_options if label in selected_model_labels]
-            
-            # Get DataFrame
-            df = evaluator.get_results_dataframe(selected_models)
+            # 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)
             
-            # Save to temporary file
+            if df_for_csv.empty:
+                gr.Warning("No data to download based on current selection.")
+                return None
+
             import tempfile
-            with tempfile.NamedTemporaryFile(mode='w', suffix='.csv', delete=False) as f:
-                df.to_csv(f, index=False)
-                return f.name
+            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
         
-        # Event handlers
         evaluate_btn.click(
-            fn=process_images,
-            inputs=[input_files, model_checkboxes, batch_size],
-            outputs=[logs, results_df, results_state]
+            fn=run_evaluation,
+            inputs=[input_files, model_checkboxes, batch_size_slider],
+            outputs=[logs_display, results_df_display, progress_status] # Removed results_state
         )
         
         model_checkboxes.change(
-            fn=update_results_on_model_change,
-            inputs=[model_checkboxes, results_state],
-            outputs=[results_df]
+            fn=handle_model_selection_change,
+            inputs=[model_checkboxes],
+            outputs=[results_df_display]
         )
         
         clear_btn.click(
-            fn=clear_interface,
-            outputs=[logs, results_df, results_state, download_file]
+            fn=clear_all_outputs,
+            outputs=[logs_display, results_df_display, progress_status, download_file_output_component]
         )
         
-        download_btn.click(
-            fn=prepare_download,
-            inputs=[model_checkboxes, results_state],
-            outputs=[download_file]
+        download_button.click(
+            fn=generate_csv_for_download,
+            inputs=[model_checkboxes],
+            outputs=[download_file_output_component]
         )
         
         gr.Markdown("""
         ### 📝 Notes
-        - **Model Selection**: Choose which models to use for evaluation. Final score is the average of selected models.
-        - **Batch Size**: Adjust based on your GPU memory. Larger batches process faster.
-        - **Results Table**: Click column headers to sort. The table updates automatically when models are selected/deselected.
-        - **Download**: Export results as CSV for further analysis.
+        - **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
+        ### 🎯 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
 
 
 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.
+    
     # Create and launch the interface
-    demo = create_interface()
-    demo.queue().launch()
+    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)