update code comments and language

app.py

@@ -1,18 +1,14 @@
 """
-MelanoScope AI - Enterprise-ready Skin Lesion Classification Application
-
-A production-ready deep learning application for dermatoscopic image analysis
-using ONNX Runtime and Gradio for web interface deployment.
+MelanoScope AI - Skin Lesion Classification Application
 
+Enterprise-ready deep learning application for dermatoscopic image analysis.
 Author: Daniel Cavadia
 Institution: Universidad Central de Venezuela
-Version: 1.0
 """
 import logging
 import sys
 from pathlib import Path
 
-# Add src to Python path
 sys.path.insert(0, str(Path(__file__).parent / "src"))
 
 from src.config.settings import LogConfig, AppConfig, EnvConfig
@@ -22,46 +18,19 @@ from src.ui.components import MelanoScopeUI
 def setup_logging() -> None:
     """Configure application logging."""
     log_level = getattr(logging, LogConfig.LOG_LEVEL.upper(), logging.INFO)
-    
-    logging.basicConfig(
-        level=log_level,
-        format=LogConfig.LOG_FORMAT,
-        handlers=[
-            logging.StreamHandler(sys.stdout),
-        ]
-    )
-    
-    # Add file handler in production
-    if not EnvConfig.DEBUG:
-        try:
-            file_handler = logging.FileHandler(LogConfig.LOG_FILE)
-            file_handler.setFormatter(logging.Formatter(LogConfig.LOG_FORMAT))
-            logging.getLogger().addHandler(file_handler)
-        except Exception as e:
-            logging.warning(f"Could not create log file handler: {e}")
+    logging.basicConfig(level=log_level, format=LogConfig.LOG_FORMAT, handlers=[logging.StreamHandler(sys.stdout)])
 
 def create_application():
-    """
-    Create and configure the MelanoScope AI application.
-    
-    Returns:
-        Configured Gradio interface
-    """
+    """Create and configure the application."""
     logger = logging.getLogger(__name__)
     
     try:
         logger.info(f"Initializing {AppConfig.TITLE} v{AppConfig.VERSION}")
         
-        # Initialize model
-        logger.info("Loading model and medical data...")
         model = MelanoScopeModel()
-        
-        # Log model information
         model_info = model.get_model_info()
         logger.info(f"Model loaded with {model_info['num_classes']} classes")
         
-        # Initialize UI
-        logger.info("Creating user interface...")
         ui = MelanoScopeUI(model, model.classes)
         interface = ui.create_interface()
         
@@ -69,29 +38,21 @@ def create_application():
         return interface
         
     except Exception as e:
-        logger.error(f"Failed to initialize application: {e}")
-        raise RuntimeError(f"Application initialization failed: {e}")
+        logger.error(f"Application initialization failed: {e}")
+        raise RuntimeError(f"Initialization failed: {e}")
 
 def main():
-    """Main entry point for the application."""
-    # Set up logging
+    """Main entry point."""
     setup_logging()
     logger = logging.getLogger(__name__)
     
     try:
-        # Create application
         app = create_application()
-        
-        # Launch application
         logger.info("Launching MelanoScope AI interface...")
         app.launch(
             server_name="0.0.0.0" if not EnvConfig.DEBUG else "127.0.0.1",
-            server_port=7860,
-            share=False,
-            debug=EnvConfig.DEBUG,
-            show_error=EnvConfig.DEBUG
+            server_port=7860, share=False, debug=EnvConfig.DEBUG, show_error=EnvConfig.DEBUG
         )
-        
     except KeyboardInterrupt:
         logger.info("Application shutdown requested")
     except Exception as e:

src/config/settings.py

@@ -1,81 +1,52 @@
-"""
-Configuration settings for MelanoScope AI application.
-Centralizes all constants and configuration parameters.
-"""
+"""Configuration settings for MelanoScope AI application."""
 import os
-from typing import List, Dict, Any
+from typing import List
 from pathlib import Path
 
-# Project paths
 PROJECT_ROOT = Path(__file__).parent.parent.parent
 DATA_FILE = PROJECT_ROOT / "data.json"
 MODEL_FILE = PROJECT_ROOT / "NFNetL0-0.961.onnx"
 EXAMPLES_DIR = PROJECT_ROOT / "examples"
 
-# Model configuration
 class ModelConfig:
-    """Model-related configuration parameters."""
-    
-    # ONNX Runtime providers (in order of preference)
+    """Model configuration parameters."""
     ORT_PROVIDERS: List[str] = ["CPUExecutionProvider"]
-    
-    # Image preprocessing parameters
     IMAGE_SIZE: tuple[int, int] = (100, 100)
     NORMALIZATION_MEAN: List[float] = [0.7611, 0.5869, 0.5923]
     NORMALIZATION_STD: List[float] = [0.1266, 0.1487, 0.1619]
-    
-    # Inference parameters
-    PROBABILITY_PRECISION: int = 1  # Decimal places for confidence display
-    PROBABILITY_SUM: int = 100  # Total sum for probability distribution
+    PROBABILITY_PRECISION: int = 1
+    PROBABILITY_SUM: int = 100
 
-# UI configuration
 class UIConfig:
-    """User interface configuration parameters."""
-    
-    # Theme settings
+    """UI configuration parameters."""
     THEME_PRIMARY_HUE: str = "rose"
     THEME_SECONDARY_HUE: str = "slate"
-    
-    # Component dimensions
     IMAGE_HEIGHT: int = 420
     PLOT_WIDTH: int = 520
     PLOT_HEIGHT: int = 320
     TEXTBOX_LINES: int = 4
-    
-    # Layout settings
     LEFT_COLUMN_SCALE: int = 5
     RIGHT_COLUMN_SCALE: int = 5
-    THEME_TOGGLE_MIN_WIDTH: int = 140
 
-# Application metadata
 class AppConfig:
-    """Application metadata and information."""
-    
-    TITLE: str = "MelanoScope AI - Clasificación de Enfermedades de la Piel"
+    """Application metadata."""
+    TITLE: str = "MelanoScope AI - Skin Lesion Classification"
     VERSION: str = "1.0"
-    LAST_UPDATE: str = "2025-08"
+    LAST_UPDATE: str = "2025-09"
     INSTITUTION: str = "Universidad Central de Venezuela"
-    DISCLAIMER: str = "Demo • No diagnóstico médico"
-    
-    # Medical disclaimer
+    DISCLAIMER: str = "Demo • Not for medical diagnosis"
     MEDICAL_DISCLAIMER: str = (
-        "Esta herramienta es solo con fines educativos y no reemplaza "
-        "una evaluación médica."
+        "This tool is for educational purposes only and does not replace "
+        "professional medical evaluation."
     )
 
-# Logging configuration
 class LogConfig:
-    """Logging configuration parameters."""
-    
+    """Logging configuration."""
     LOG_LEVEL: str = os.getenv("LOG_LEVEL", "INFO")
-    LOG_FORMAT: str = (
-        "%(asctime)s | %(name)s | %(levelname)s | %(message)s"
-    )
+    LOG_FORMAT: str = "%(asctime)s | %(name)s | %(levelname)s | %(message)s"
     LOG_FILE: str = "melanoscope.log"
 
-# Environment settings
 class EnvConfig:
-    """Environment-specific configuration."""
-    
+    """Environment settings."""
     DEBUG: bool = os.getenv("DEBUG", "False").lower() == "true"
     ENVIRONMENT: str = os.getenv("ENVIRONMENT", "production")

src/core/model.py

@@ -1,128 +1,81 @@
-"""
-Model inference module for MelanoScope AI.
-Handles ONNX model loading and inference operations.
-"""
+"""Model inference for MelanoScope AI."""
 import json
 import logging
 import time
 from typing import Dict, Any, List, Optional, Tuple
-from pathlib import Path
 import numpy as np
 import onnxruntime as ort
-from PIL import Image
-
 from ..config.settings import ModelConfig, DATA_FILE, MODEL_FILE
 from .preprocessing import ImagePreprocessor
 from .utils import probabilities_to_ints, format_confidence
 
-# Configure logger
 logger = logging.getLogger(__name__)
 
 class MelanoScopeModel:
-    """
-    MelanoScope AI model for skin lesion classification.
-    
-    Handles model loading, inference, and result processing.
-    """
+    """MelanoScope AI model for skin lesion classification."""
     
     def __init__(self):
-        """Initialize the model and load medical condition data."""
         self.preprocessor = ImagePreprocessor()
         self.session: Optional[ort.InferenceSession] = None
         self.classes: List[str] = []
         self.medical_data: Dict[str, Any] = {}
         
-        # Load model and data
         self._load_model()
         self._load_medical_data()
-        
-        logger.info(f"MelanoScopeModel initialized with {len(self.classes)} classes")
+        logger.info(f"Model initialized with {len(self.classes)} classes")
     
     def _load_model(self) -> None:
-        """Load the ONNX model for inference."""
+        """Load ONNX model."""
         try:
             if not MODEL_FILE.exists():
                 raise FileNotFoundError(f"Model file not found: {MODEL_FILE}")
             
-            self.session = ort.InferenceSession(
-                str(MODEL_FILE), 
-                providers=ModelConfig.ORT_PROVIDERS
-            )
-            
-            # Log model information
-            input_info = self.session.get_inputs()[0]
-            logger.info(f"Model loaded successfully")
-            logger.debug(f"Input shape: {input_info.shape}, Input type: {input_info.type}")
+            self.session = ort.InferenceSession(str(MODEL_FILE), providers=ModelConfig.ORT_PROVIDERS)
+            logger.info("Model loaded successfully")
             
         except Exception as e:
             logger.error(f"Failed to load model: {e}")
             raise RuntimeError(f"Model loading failed: {e}")
     
     def _load_medical_data(self) -> None:
-        """Load medical condition data and class names."""
+        """Load medical condition data."""
         try:
-            if not DATA_FILE.exists():
-                raise FileNotFoundError(f"Data file not found: {DATA_FILE}")
-            
             with open(DATA_FILE, "r", encoding="utf-8") as f:
                 self.medical_data = json.load(f)
             
             self.classes = list(self.medical_data.keys())
-            logger.info(f"Loaded medical data for {len(self.classes)} conditions")
+            logger.info(f"Loaded data for {len(self.classes)} conditions")
             
         except Exception as e:
             logger.error(f"Failed to load medical data: {e}")
             raise RuntimeError(f"Medical data loading failed: {e}")
     
     def predict(self, image_input: Any) -> Tuple[str, str, str, str, str, str, Any, str]:
-        """
-        Perform inference on input image.
-        
-        Args:
-            image_input: Input image (PIL Image, numpy array, or None)
-            
-        Returns:
-            Tuple containing (prediction, confidence, description, symptoms, 
-                           causes, treatment, probability_df, latency)
-        """
-        # Handle empty input
+        """Perform inference on input image."""
         if image_input is None:
-            logger.warning("Received None image input")
-            return self._create_empty_result("Cargue una imagen y presione Analizar.")
+            return self._create_empty_result("Please upload an image and click Analyze.")
         
         try:
-            # Start timing
             start_time = time.time()
             
-            # Preprocess image
             input_tensor = self.preprocessor.preprocess(image_input)
             if input_tensor is None:
-                return self._create_empty_result("Imagen inválida")
+                return self._create_empty_result("Invalid image")
             
-            # Run inference
             prediction_result = self._run_inference(input_tensor)
             if prediction_result is None:
-                return self._create_empty_result("Error en la inferencia")
+                return self._create_empty_result("Inference error")
             
-            # Process results
             pred_name, confidence, prob_df = prediction_result
             medical_info = self._get_medical_info(pred_name)
             
-            # Calculate latency
             latency_ms = int((time.time() - start_time) * 1000)
-            latency_str = f"{latency_ms} ms"
-            
-            logger.info(f"Prediction completed: {pred_name} ({confidence}) in {latency_ms}ms")
             
             return (
-                pred_name,
-                confidence,
-                medical_info["description"],
-                medical_info["symptoms"],
-                medical_info["causes"],
-                medical_info["treatment"],
-                prob_df,
-                latency_str
+                pred_name, confidence,
+                medical_info["description"], medical_info["symptoms"],
+                medical_info["causes"], medical_info["treatment"],
+                prob_df, f"{latency_ms} ms"
             )
             
         except Exception as e:
@@ -130,42 +83,23 @@ class MelanoScopeModel:
             return self._create_empty_result(f"Error: {str(e)}")
     
     def _run_inference(self, input_tensor: np.ndarray) -> Optional[Tuple[str, str, Any]]:
-        """
-        Run model inference on preprocessed input.
-        
-        Args:
-            input_tensor: Preprocessed image tensor
-            
-        Returns:
-            Tuple of (prediction_name, confidence_string, probability_dataframe)
-        """
+        """Run model inference."""
         try:
-            if self.session is None:
-                raise RuntimeError("Model not loaded")
-            
-            # Get input name
             input_name = self.session.get_inputs()[0].name
-            
-            # Run inference
             output = self.session.run(None, {input_name: input_tensor})
             logits = output[0].squeeze()
             
-            # Get prediction
             pred_idx = int(np.argmax(logits))
             pred_name = self.classes[pred_idx]
             
-            # Calculate softmax probabilities
+            # Softmax probabilities
             exp_logits = np.exp(logits - np.max(logits))
             probabilities = exp_logits / exp_logits.sum()
             
-            # Format confidence
             confidence = format_confidence(probabilities[pred_idx])
-            
-            # Create probability dataframe
             prob_ints = probabilities_to_ints(probabilities * 100.0)
             prob_df = self._create_probability_dataframe(prob_ints)
             
-            logger.debug(f"Inference completed: {pred_name} with confidence {confidence}")
             return pred_name, confidence, prob_df
             
         except Exception as e:
@@ -173,80 +107,33 @@ class MelanoScopeModel:
             return None
     
     def _create_probability_dataframe(self, probabilities: np.ndarray) -> Any:
-        """Create a sorted probability dataframe for visualization."""
+        """Create sorted probability dataframe."""
         try:
             import pandas as pd
-            
-            df = pd.DataFrame({
+            return pd.DataFrame({
                 "item": self.classes,
                 "probability": probabilities.astype(int)
             }).sort_values("probability", ascending=True)
-            
-            return df
-            
         except Exception as e:
-            logger.error(f"Error creating probability dataframe: {e}")
-            # Return empty dataframe as fallback
+            logger.error(f"Error creating dataframe: {e}")
             import pandas as pd
             return pd.DataFrame({"item": self.classes, "probability": [0] * len(self.classes)})
     
     def _get_medical_info(self, condition_name: str) -> Dict[str, str]:
-        """
-        Get medical information for a specific condition.
-        
-        Args:
-            condition_name: Name of the medical condition
-            
-        Returns:
-            Dictionary containing medical information
-        """
-        try:
-            condition_data = self.medical_data.get(condition_name, {})
-            
-            return {
-                "description": condition_data.get("description", ""),
-                "symptoms": condition_data.get("symptoms", ""),
-                "causes": condition_data.get("causes", ""),
-                "treatment": condition_data.get("treatment-1", "")
-            }
-            
-        except Exception as e:
-            logger.error(f"Error getting medical info for {condition_name}: {e}")
-            return {"description": "", "symptoms": "", "causes": "", "treatment": ""}
+        """Get medical information for condition."""
+        condition_data = self.medical_data.get(condition_name, {})
+        return {
+            "description": condition_data.get("description", ""),
+            "symptoms": condition_data.get("symptoms", ""),
+            "causes": condition_data.get("causes", ""),
+            "treatment": condition_data.get("treatment-1", "")
+        }
     
     def _create_empty_result(self, message: str) -> Tuple[str, str, str, str, str, str, Any, str]:
-        """Create an empty result tuple with error message."""
+        """Create empty result with error message."""
         try:
             import pandas as pd
             empty_df = pd.DataFrame({"item": self.classes, "probability": [0] * len(self.classes)})
         except:
             empty_df = None
-            
         return (message, "", "", "", "", "", empty_df, "")
-    
-    def get_model_info(self) -> Dict[str, Any]:
-        """
-        Get information about the loaded model.
-        
-        Returns:
-            Dictionary containing model metadata
-        """
-        info = {
-            "classes": self.classes,
-            "num_classes": len(self.classes),
-            "model_file": str(MODEL_FILE),
-            "providers": ModelConfig.ORT_PROVIDERS
-        }
-        
-        if self.session:
-            try:
-                input_info = self.session.get_inputs()[0]
-                info.update({
-                    "input_shape": input_info.shape,
-                    "input_type": input_info.type,
-                    "input_name": input_info.name
-                })
-            except Exception as e:
-                logger.warning(f"Could not get model input info: {e}")
-        
-        return info

src/core/preprocessing.py

@@ -1,71 +1,39 @@
-"""
-Image preprocessing module for MelanoScope AI.
-Handles image transformations and normalization.
-"""
+"""Image preprocessing for MelanoScope AI."""
 import logging
 from typing import Union, Optional
 import numpy as np
 from PIL import Image
 from torchvision import transforms
-
 from ..config.settings import ModelConfig
 
-# Configure logger
 logger = logging.getLogger(__name__)
 
 class ImagePreprocessor:
     """Handles image preprocessing for model inference."""
     
     def __init__(self):
-        """Initialize the preprocessor with configured transforms."""
         self.transforms = self._create_transform_pipeline()
         logger.info("ImagePreprocessor initialized")
     
     def _create_transform_pipeline(self) -> transforms.Compose:
-        """
-        Create the image transformation pipeline.
-        
-        Returns:
-            Composed torchvision transforms
-        """
-        try:
-            transform_pipeline = transforms.Compose([
-                transforms.Resize(ModelConfig.IMAGE_SIZE),
-                transforms.ToTensor(),
-                transforms.Normalize(
-                    mean=ModelConfig.NORMALIZATION_MEAN,
-                    std=ModelConfig.NORMALIZATION_STD
-                ),
-            ])
-            logger.debug("Transform pipeline created successfully")
-            return transform_pipeline
-        except Exception as e:
-            logger.error(f"Error creating transform pipeline: {e}")
-            raise
+        """Create image transformation pipeline."""
+        return transforms.Compose([
+            transforms.Resize(ModelConfig.IMAGE_SIZE),
+            transforms.ToTensor(),
+            transforms.Normalize(
+                mean=ModelConfig.NORMALIZATION_MEAN,
+                std=ModelConfig.NORMALIZATION_STD
+            ),
+        ])
     
     def preprocess(self, image_input: Union[Image.Image, np.ndarray]) -> Optional[np.ndarray]:
-        """
-        Preprocess image for model inference.
-        
-        Args:
-            image_input: PIL Image or numpy array
-            
-        Returns:
-            Preprocessed image tensor as numpy array, or None if preprocessing fails
-            
-        Raises:
-            ValueError: If image input is invalid
-        """
+        """Preprocess image for model inference."""
         try:
-            # Convert input to PIL Image
             pil_image = self._convert_to_pil(image_input)
             if pil_image is None:
                 return None
             
-            # Apply transforms and add batch dimension
             tensor = self.transforms(pil_image).unsqueeze(0).numpy()
-            
-            logger.debug(f"Image preprocessed to shape: {tensor.shape}")
             return tensor
             
         except Exception as e:
@@ -73,36 +41,12 @@ class ImagePreprocessor:
             return None
     
     def _convert_to_pil(self, image_input: Union[Image.Image, np.ndarray]) -> Optional[Image.Image]:
-        """
-        Convert various image formats to PIL Image.
-        
-        Args:
-            image_input: Image in PIL or numpy format
-            
-        Returns:
-            PIL Image in RGB mode, or None if conversion fails
-        """
+        """Convert image input to PIL Image in RGB mode."""
         try:
             if isinstance(image_input, Image.Image):
                 return image_input.convert("RGB")
             else:
-                # Assume numpy array
-                pil_image = Image.fromarray(image_input).convert("RGB")
-                return pil_image
-                
+                return Image.fromarray(image_input).convert("RGB")
         except Exception as e:
-            logger.error(f"Error converting image to PIL format: {e}")
+            logger.error(f"Error converting to PIL: {e}")
             return None
-    
-    def get_transform_info(self) -> dict:
-        """
-        Get information about the preprocessing transforms.
-        
-        Returns:
-            Dictionary containing transform parameters
-        """
-        return {
-            "image_size": ModelConfig.IMAGE_SIZE,
-            "normalization_mean": ModelConfig.NORMALIZATION_MEAN,
-            "normalization_std": ModelConfig.NORMALIZATION_STD
-        }

src/core/utils.py

@@ -1,50 +1,26 @@
-"""
-Utility functions for MelanoScope AI.
-Contains helper functions and probability calculations.
-"""
+"""Utility functions for MelanoScope AI."""
 import logging
-from typing import List, Dict, Any, Union
+from typing import List, Any
 import numpy as np
 import pandas as pd
-
 from ..config.settings import ModelConfig
 
-# Configure logger
 logger = logging.getLogger(__name__)
 
-def probabilities_to_ints(
-    probabilities: np.ndarray, 
-    total_sum: int = ModelConfig.PROBABILITY_SUM
-) -> np.ndarray:
-    """
-    Convert probability array to integer percentages that sum to total_sum.
-    
-    Args:
-        probabilities: Array of probability values
-        total_sum: Target sum for the integer percentages
-        
-    Returns:
-        Array of integers that sum to total_sum
-        
-    Raises:
-        ValueError: If probabilities contain invalid values
-    """
+def probabilities_to_ints(probabilities: np.ndarray, total_sum: int = ModelConfig.PROBABILITY_SUM) -> np.ndarray:
+    """Convert probabilities to integers that sum to total_sum."""
     try:
         probabilities = np.array(probabilities)
-        
-        # Ensure non-negative values
         positive_values = np.maximum(probabilities, 0)
         total_positive = positive_values.sum()
         
         if total_positive == 0:
-            logger.warning("All probabilities are zero or negative")
             return np.zeros_like(probabilities, dtype=int)
         
-        # Scale to target sum
         scaled = positive_values / total_positive * total_sum
         rounded = np.round(scaled).astype(int)
         
-        # Adjust for rounding errors
+        # Fix rounding errors
         diff = total_sum - rounded.sum()
         if diff != 0:
             max_idx = int(np.argmax(positive_values))
@@ -52,65 +28,20 @@ def probabilities_to_ints(
             rounded[max_idx] += diff
             rounded = rounded.reshape(scaled.shape)
         
-        logger.debug(f"Converted probabilities to integers summing to {total_sum}")
         return rounded
         
     except Exception as e:
-        logger.error(f"Error converting probabilities to integers: {e}")
+        logger.error(f"Error converting probabilities: {e}")
         raise ValueError(f"Invalid probability values: {e}")
 
 def create_empty_dataframe(classes: List[str]) -> pd.DataFrame:
-    """
-    Create an empty probability dataframe with zero values.
-    
-    Args:
-        classes: List of class names
-        
-    Returns:
-        DataFrame with items and zero probabilities
-    """
-    logger.debug(f"Creating empty dataframe for {len(classes)} classes")
-    return pd.DataFrame({
-        "item": classes, 
-        "probability": [0] * len(classes)
-    })
+    """Create empty probability dataframe."""
+    return pd.DataFrame({"item": classes, "probability": [0] * len(classes)})
 
 def format_confidence(probability: float, precision: int = ModelConfig.PROBABILITY_PRECISION) -> str:
-    """
-    Format probability as percentage string.
-    
-    Args:
-        probability: Probability value between 0 and 1
-        precision: Number of decimal places
-        
-    Returns:
-        Formatted percentage string
-    """
+    """Format probability as percentage string."""
     try:
-        percentage = probability * 100
-        return f"{percentage:.{precision}f}%"
+        return f"{probability * 100:.{precision}f}%"
     except Exception as e:
         logger.error(f"Error formatting confidence: {e}")
         return "0.0%"
-
-def validate_image_input(image: Any) -> bool:
-    """
-    Validate that image input is not None and has valid structure.
-    
-    Args:
-        image: Image input to validate
-        
-    Returns:
-        True if image is valid, False otherwise
-    """
-    if image is None:
-        logger.warning("Image input is None")
-        return False
-    
-    try:
-        # Additional validation could be added here
-        # e.g., check image dimensions, format, etc.
-        return True
-    except Exception as e:
-        logger.error(f"Error validating image input: {e}")
-        return False

src/ui/components.py

@@ -1,255 +1,141 @@
-"""
-UI components for MelanoScope AI.
-Contains Gradio interface component definitions.
-"""
+"""UI components for MelanoScope AI."""
 import os
 import logging
-from typing import List, Any, Optional
+from typing import List
 import gradio as gr
-
-from ..config.settings import UIConfig, EXAMPLES_DIR
+from ..config.settings import UIConfig
 from ..core.utils import create_empty_dataframe
 from .styles import get_custom_css, create_theme, get_header_html, get_footer_html, get_model_info_html
 
 logger = logging.getLogger(__name__)
 
 class MelanoScopeUI:
-    """Handles the user interface components and layout."""
+    """Handles UI components and layout."""
     
     def __init__(self, model_instance, classes: List[str]):
-        """
-        Initialize UI components.
-        
-        Args:
-            model_instance: Initialized model instance for predictions
-            classes: List of class names for empty dataframe
-        """
         self.model = model_instance
         self.classes = classes
         self.theme = create_theme()
         self.css = get_custom_css()
-        
-        logger.info("MelanoScopeUI initialized")
+        logger.info("UI initialized")
     
     def create_interface(self) -> gr.Blocks:
-        """
-        Create the complete Gradio interface.
-        
-        Returns:
-            Configured Gradio Blocks interface
-        """
-        try:
-            with gr.Blocks(theme=self.theme, css=self.css) as interface:
-                # Header section
-                self._create_header()
-                
-                # Main content area
-                with gr.Row(equal_height=True):
-                    # Left column: input and controls
-                    self._create_input_column()
-                    
-                    # Right column: results and information
-                    self._create_results_column()
-                
-                # Footer
-                self._create_footer()
-                
-                # Set up event handlers
-                self._setup_event_handlers()
+        """Create complete Gradio interface."""
+        with gr.Blocks(theme=self.theme, css=self.css) as interface:
+            self._create_header()
             
-            logger.info("Interface created successfully")
-            return interface
+            with gr.Row(equal_height=True):
+                self._create_input_column()
+                self._create_results_column()
             
-        except Exception as e:
-            logger.error(f"Failed to create interface: {e}")
-            raise
+            self._create_footer()
+            self._setup_event_handlers()
+        
+        return interface
     
     def _create_header(self) -> None:
-        """Create the header section with title and theme toggle."""
+        """Create header section."""
         with gr.Row():
             with gr.Column(scale=6):
                 gr.Markdown(get_header_html())
-            
             with gr.Column(scale=1, min_width=UIConfig.THEME_TOGGLE_MIN_WIDTH):
                 try:
-                    self.dark_toggle = gr.ThemeMode(label="Modo", value="system")
+                    self.dark_toggle = gr.ThemeMode(label="Theme", value="system")
                 except Exception:
-                    gr.Markdown("")  # Fallback for older Gradio versions
+                    gr.Markdown("")
     
     def _create_input_column(self) -> None:
-        """Create the left column with image input and controls."""
+        """Create input column with image upload and controls."""
         with gr.Column(scale=UIConfig.LEFT_COLUMN_SCALE):
-            # Image input
             self.image_input = gr.Image(
                 type="numpy",
-                label="Imagen de la lesión",
+                label="Lesion Image",
                 height=UIConfig.IMAGE_HEIGHT,
                 sources=["upload", "clipboard"]
             )
             
-            # Action buttons
             with gr.Row():
-                self.analyze_btn = gr.Button("Analizar", variant="primary")
-                self.clear_btn = gr.Button("Limpiar")
+                self.analyze_btn = gr.Button("Analyze", variant="primary")
+                self.clear_btn = gr.Button("Clear")
             
-            # Examples section
             self._create_examples_section()
-            
-            # Latency display
-            self.latency_output = gr.Label(label="Latencia aproximada")
+            self.latency_output = gr.Label(label="Inference Time")
     
     def _create_examples_section(self) -> None:
-        """Create the examples section if example files exist."""
-        try:
-            example_files = [
-                "examples/ak.jpg",
-                "examples/bcc.jpg", 
-                "examples/df.jpg",
-                "examples/melanoma.jpg",
-                "examples/nevus.jpg",
-            ]
-            
-            # Filter existing files
-            existing_examples = [f for f in example_files if os.path.exists(f)]
-            
-            if existing_examples:
-                gr.Examples(
-                    examples=existing_examples,
-                    inputs=self.image_input,
-                    label="Ejemplos rápidos"
-                )
-                logger.debug(f"Created examples with {len(existing_examples)} files")
-            else:
-                logger.warning("No example files found")
-                
-        except Exception as e:
-            logger.warning(f"Failed to create examples section: {e}")
+        """Create examples section if files exist."""
+        example_files = [
+            "examples/ak.jpg", "examples/bcc.jpg", "examples/df.jpg",
+            "examples/melanoma.jpg", "examples/nevus.jpg"
+        ]
+        
+        existing_examples = [f for f in example_files if os.path.exists(f)]
+        if existing_examples:
+            gr.Examples(examples=existing_examples, inputs=self.image_input, label="Quick Examples")
     
     def _create_results_column(self) -> None:
-        """Create the right column with results and information."""
+        """Create results column with predictions and info."""
         with gr.Column(scale=UIConfig.RIGHT_COLUMN_SCALE):
-            # Prediction results
             self._create_prediction_results()
-            
-            # Information tabs
             self._create_information_tabs()
     
     def _create_prediction_results(self) -> None:
-        """Create the prediction results section."""
+        """Create prediction results section."""
         with gr.Group():
-            # Main prediction and confidence
             with gr.Row():
-                self.prediction_output = gr.Label(
-                    label="Predicción principal",
-                    elem_classes=["pred-card"]
-                )
-                self.confidence_output = gr.Label(label="Confianza")
+                self.prediction_output = gr.Label(label="Primary Prediction", elem_classes=["pred-card"])
+                self.confidence_output = gr.Label(label="Confidence")
             
-            # Probability distribution chart
             self.probability_plot = gr.BarPlot(
                 value=create_empty_dataframe(self.classes),
-                x="item",
-                y="probability",
-                title="Distribución de probabilidad (Top‑k)",
-                x_title="Clase",
-                y_title="Probabilidad",
-                vertical=False,
-                tooltip=["item", "probability"],
-                width=UIConfig.PLOT_WIDTH,
-                height=UIConfig.PLOT_HEIGHT,
+                x="item", y="probability",
+                title="Probability Distribution (Top-k)",
+                x_title="Class", y_title="Probability",
+                vertical=False, tooltip=["item", "probability"],
+                width=UIConfig.PLOT_WIDTH, height=UIConfig.PLOT_HEIGHT,
             )
     
     def _create_information_tabs(self) -> None:
-        """Create the tabbed information section."""
+        """Create information tabs."""
         with gr.Tabs():
-            # Medical details tab
-            with gr.TabItem("Detalles"):
+            with gr.TabItem("Medical Details"):
                 self._create_medical_details()
-            
-            # Model information tab
-            with gr.TabItem("Acerca del modelo"):
+            with gr.TabItem("About Model"):
                 gr.Markdown(get_model_info_html())
     
     def _create_medical_details(self) -> None:
-        """Create the medical details accordions."""
-        with gr.Accordion("Descripción", open=True):
-            self.description_output = gr.Textbox(
-                lines=UIConfig.TEXTBOX_LINES,
-                interactive=False
-            )
-        
-        with gr.Accordion("Síntomas", open=False):
-            self.symptoms_output = gr.Textbox(
-                lines=UIConfig.TEXTBOX_LINES,
-                interactive=False
-            )
-        
-        with gr.Accordion("Causas", open=False):
-            self.causes_output = gr.Textbox(
-                lines=UIConfig.TEXTBOX_LINES,
-                interactive=False
-            )
-        
-        with gr.Accordion("Tratamiento", open=False):
-            self.treatment_output = gr.Textbox(
-                lines=UIConfig.TEXTBOX_LINES,
-                interactive=False
-            )
+        """Create medical details accordions."""
+        with gr.Accordion("Description", open=True):
+            self.description_output = gr.Textbox(lines=UIConfig.TEXTBOX_LINES, interactive=False)
+        with gr.Accordion("Symptoms", open=False):
+            self.symptoms_output = gr.Textbox(lines=UIConfig.TEXTBOX_LINES, interactive=False)
+        with gr.Accordion("Causes", open=False):
+            self.causes_output = gr.Textbox(lines=UIConfig.TEXTBOX_LINES, interactive=False)
+        with gr.Accordion("Treatment", open=False):
+            self.treatment_output = gr.Textbox(lines=UIConfig.TEXTBOX_LINES, interactive=False)
     
     def _create_footer(self) -> None:
-        """Create the footer section."""
+        """Create footer section."""
         gr.Markdown(get_footer_html())
     
     def _setup_event_handlers(self) -> None:
-        """Set up event handlers for interactive components."""
-        try:
-            # Collect all output components
-            outputs = [
-                self.prediction_output,
-                self.confidence_output,
-                self.description_output,
-                self.symptoms_output,
-                self.causes_output,
-                self.treatment_output,
-                self.probability_plot,
-                self.latency_output
-            ]
-            
-            # Analyze button click
-            self.analyze_btn.click(
-                fn=self.model.predict,
-                inputs=[self.image_input],
-                outputs=outputs,
-                show_progress="full"
-            )
-            
-            # Clear button click
-            self.clear_btn.click(
-                fn=self._clear_all,
-                inputs=[],
-                outputs=[self.image_input] + outputs
-            )
-            
-            logger.debug("Event handlers set up successfully")
-            
-        except Exception as e:
-            logger.error(f"Failed to set up event handlers: {e}")
-            raise
+        """Set up event handlers."""
+        outputs = [
+            self.prediction_output, self.confidence_output, self.description_output,
+            self.symptoms_output, self.causes_output, self.treatment_output,
+            self.probability_plot, self.latency_output
+        ]
+        
+        self.analyze_btn.click(
+            fn=self.model.predict, inputs=[self.image_input], 
+            outputs=outputs, show_progress="full"
+        )
+        
+        self.clear_btn.click(
+            fn=self._clear_all, inputs=[], 
+            outputs=[self.image_input] + outputs
+        )
     
     def _clear_all(self) -> tuple:
-        """
-        Clear all inputs and outputs.
-        
-        Returns:
-            Tuple of cleared values for all components
-        """
-        try:
-            empty_df = create_empty_dataframe(self.classes)
-            
-            # Return cleared values for: image, prediction, confidence, description, 
-            # symptoms, causes, treatment, probability_plot, latency
-            return (None, "", "", "", "", "", "", empty_df, "")
-            
-        except Exception as e:
-            logger.error(f"Error clearing interface: {e}")
-            return (None, "", "", "", "", "", "", None, "")
+        """Clear all inputs and outputs."""
+        empty_df = create_empty_dataframe(self.classes)
+        return (None, "", "", "", "", "", "", empty_df, "")

src/ui/styles.py

@@ -1,133 +1,69 @@
-"""
-UI styling and theming for MelanoScope AI.
-Contains CSS styles and theme configurations.
-"""
-from typing import Optional
+"""UI styling and theming for MelanoScope AI."""
 import logging
-
 from ..config.settings import UIConfig
 
 logger = logging.getLogger(__name__)
 
 def get_custom_css() -> str:
-    """
-    Get custom CSS styles for the application.
-    
-    Returns:
-        CSS string for styling the interface
-    """
+    """Get custom CSS styles."""
     return """
-    .header {
-        display: flex; 
-        align-items: center; 
-        gap: 12px;
-    }
-    .badge {
-        font-size: 12px; 
-        padding: 4px 8px; 
-        border-radius: 12px; 
-        background: #f1f5f9; 
-        color: #334155;
-    }
-    .pred-card {
-        font-size: 18px;
-    }
-    .footer {
-        font-size: 12px; 
-        color: #64748b; 
-        text-align: center; 
-        padding: 12px 0;
-    }
+    .header { display: flex; align-items: center; gap: 12px; }
+    .badge { font-size: 12px; padding: 4px 8px; border-radius: 12px; 
+             background: #f1f5f9; color: #334155; }
+    .pred-card { font-size: 18px; }
+    .footer { font-size: 12px; color: #64748b; text-align: center; padding: 12px 0; }
     button, .gradio-container .gr-box, .gradio-container .gr-panel { 
         border-radius: 10px !important; 
     }
-    /* Uniform bar color in Vega-Lite charts */
     .vega-embed .mark-rect, .vega-embed .mark-bar, .vega-embed .role-mark rect { 
         fill: #ef4444 !important; 
     }
-    /* Improve spacing and readability */
-    .gradio-container {
-        font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif;
-    }
-    .gr-button {
-        transition: all 0.2s ease;
-    }
-    .gr-button:hover {
-        transform: translateY(-1px);
-        box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
-    }
+    .gradio-container { font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif; }
+    .gr-button { transition: all 0.2s ease; }
+    .gr-button:hover { transform: translateY(-1px); box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15); }
     """
 
 def create_theme():
-    """
-    Create and return the application theme.
-    
-    Returns:
-        Gradio theme object or None if creation fails
-    """
+    """Create application theme."""
     try:
         import gradio as gr
-        
-        theme = gr.themes.Soft(
+        return gr.themes.Soft(
             primary_hue=UIConfig.THEME_PRIMARY_HUE,
             secondary_hue=UIConfig.THEME_SECONDARY_HUE
         )
-        
-        logger.debug("Theme created successfully")
-        return theme
-        
     except Exception as e:
-        logger.warning(f"Failed to create theme, using default: {e}")
+        logger.warning(f"Theme creation failed, using default: {e}")
         return None
 
 def get_header_html() -> str:
-    """
-    Get HTML for the application header.
-    
-    Returns:
-        HTML string for the header section
-    """
+    """Get HTML for application header."""
     from ..config.settings import AppConfig
-    
     return f"""
     <div class="header">
         <h1 style="margin:0;">{AppConfig.TITLE}</h1>
         <span class="badge">{AppConfig.DISCLAIMER}</span>
     </div>
     <p style="margin-top:6px;">
-        Sube una imagen dermatoscópica para ver la clase predicha, 
-        la confianza y la distribución de probabilidades.
+        Upload a dermatoscopic image to see the predicted class, confidence, and probability distribution.
     </p>
     """
 
 def get_footer_html() -> str:
-    """
-    Get HTML for the application footer.
-    
-    Returns:
-        HTML string for the footer section
-    """
+    """Get HTML for application footer."""
     from ..config.settings import AppConfig
-    
     return (
         f"<div class='footer'>"
-        f"Versión del modelo: {AppConfig.VERSION} • "
-        f"Última actualización: {AppConfig.LAST_UPDATE} • "
+        f"Model version: {AppConfig.VERSION} • "
+        f"Last updated: {AppConfig.LAST_UPDATE} • "
         f"{AppConfig.INSTITUTION}"
         f"</div>"
     )
 
 def get_model_info_html() -> str:
-    """
-    Get HTML for the model information tab.
-    
-    Returns:
-        HTML string describing the model
-    """
+    """Get HTML for model information."""
     from ..config.settings import AppConfig
-    
     return (
-        "- Arquitectura: CNN exportado a ONNX.<br>"
-        "- Entrenamiento: dataset dermatoscópico (ver documentación).<br>"
-        f"- Nota: {AppConfig.MEDICAL_DISCLAIMER}"
+        "- Architecture: CNN exported to ONNX format<br>"
+        "- Training: Dermatoscopic dataset (see documentation)<br>"
+        f"- Note: {AppConfig.MEDICAL_DISCLAIMER}"
     )