update project structure

app.py

@@ -1,216 +1,102 @@
-import json
-import numpy as np
-import gradio as gr
-import onnxruntime as ort
-from PIL import Image
-from torchvision import transforms
-import pandas as pd
-import time
-import os
-
-# ----------------------------
-# Model + metadata
-# ----------------------------
-ORT_PROVIDERS = ["CPUExecutionProvider"]  # add "CUDAExecutionProvider" if available
-ort_session = ort.InferenceSession("NFNetL0-0.961.onnx", providers=ORT_PROVIDERS)
-
-with open("data.json", "r", encoding="utf-8") as f:
-    data = json.load(f)
-CLASSES = list(data)  # ordered list of class names
-
-def empty_df():
-    return pd.DataFrame({"item": CLASSES, "probability": [0] * len(CLASSES)})
-
-# ----------------------------
-# Utils
-# ----------------------------
-def probabilities_to_ints(probabilities, total_sum=100):
-    probabilities = np.array(probabilities)
-    positive_values = np.maximum(probabilities, 0)
-    total_positive = positive_values.sum()
-    if total_positive == 0:
-        return np.zeros_like(probabilities, dtype=int)
-    scaled = positive_values / total_positive * total_sum
-    rounded = np.round(scaled).astype(int)
-    diff = total_sum - rounded.sum()
-    if diff != 0:
-        max_idx = int(np.argmax(positive_values))
-        rounded = rounded.flatten()
-        rounded[max_idx] += diff
-        rounded = rounded.reshape(scaled.shape)
-    return rounded
-
-MEAN = [0.7611, 0.5869, 0.5923]
-STD = [0.1266, 0.1487, 0.1619]
-TFMS = transforms.Compose([
-    transforms.Resize((100, 100)),
-    transforms.ToTensor(),
-    transforms.Normalize(mean=MEAN, std=STD),
-])
-
-def preprocess(pil_img: Image.Image):
-    return TFMS(pil_img).unsqueeze(0).numpy()
-
-# ----------------------------
-# Inference function
-# ----------------------------
-def predict(image):
-    # Handle clicks with no image gracefully
-    if image is None:
-        return ("Cargue una imagen y presione Analizar.", "", "", "", "", "", empty_df(), "")
-    if isinstance(image, Image.Image):
-        pil = image.convert("RGB")
-    else:
-        try:
-            pil = Image.fromarray(image).convert("RGB")
-        except Exception:
-            return ("Imagen inválida", "", "", "", "", "", empty_df(), "")
-
-    t0 = time.time()
-    input_tensor = preprocess(pil)
-    input_name = ort_session.get_inputs()[0].name
-    output = ort_session.run(None, {input_name: input_tensor})
-
-    logits = output[0].squeeze()
-    pred_idx = int(np.argmax(logits))
-    pred_name = CLASSES[pred_idx]
-
-    # Softmax probabilities
-    exp = np.exp(logits - np.max(logits))
-    probs = exp / exp.sum()
-    conf_text = f"{float(probs[pred_idx]) * 100:.1f}%"
-
-    ints = probabilities_to_ints(probs * 100.0, total_sum=100)
-    df = pd.DataFrame({"item": CLASSES, "probability": ints.astype(int)}).sort_values(
-        "probability", ascending=True
-    )
-
-    details = data[pred_name]
-    descripcion = details.get("description", "")
-    sintomas = details.get("symptoms", "")
-    causas = details.get("causes", "")
-    tratamiento = details.get("treatment-1", "")
-
-    latency_ms = int((time.time() - t0) * 1000)
-    return (pred_name, conf_text, descripcion, sintomas, causas, tratamiento, df, f"{latency_ms} ms")
-
-# ----------------------------
-# Theme (compatible across Gradio versions)
-# ----------------------------
-try:
-    theme = gr.themes.Soft(primary_hue="rose", secondary_hue="slate")
-except Exception:
-    theme = None  # fallback to default theme
-
-# CSS polish; tint bars via CSS for Gradio 4.27
-CUSTOM_CSS = """
-.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 (Gradio 4.27) */
-.vega-embed .mark-rect, .vega-embed .mark-bar, .vega-embed .role-mark rect { fill: #ef4444 !important; }
 """
+MelanoScope AI - Enterprise-ready Skin Lesion Classification Application
 
-# ----------------------------
-# UI
-# ----------------------------
-with gr.Blocks(theme=theme, css=CUSTOM_CSS) as demo:
-    with gr.Row():
-        with gr.Column(scale=6):
-            gr.Markdown(
-                """
-                <div class="header">
-                  <h1 style="margin:0;">Clasificación de Enfermedades de la Piel</h1>
-                  <span class="badge">Demo • No diagnóstico médico</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.
-                </p>
-                """
-            )
-        with gr.Column(scale=1, min_width=140):
-            try:
-                dark_toggle = gr.ThemeMode(label="Modo", value="system")
-            except Exception:
-                gr.Markdown("")
-
-    with gr.Row(equal_height=True):
-        # Left column: input + actions
-        with gr.Column(scale=5):
-            image = gr.Image(type="numpy", label="Imagen de la lesión", height=420, sources=["upload", "clipboard"])
-            with gr.Row():
-                analyze_btn = gr.Button("Analizar", variant="primary")  # Always enabled
-                clear_btn = gr.Button("Limpiar")
-            example_paths = [
-                "examples/ak.jpg",
-                "examples/bcc.jpg",
-                "examples/df.jpg",
-                "examples/melanoma.jpg",
-                "examples/nevus.jpg",
-            ]
-            example_paths = [p for p in example_paths if os.path.exists(p)]
-            if example_paths:
-                gr.Examples(examples=example_paths, inputs=image, label="Ejemplos rápidos")
-            latency = gr.Label(label="Latencia aproximada")
-
-        # Right column: results
-        with gr.Column(scale=5):
-            with gr.Group():
-                with gr.Row():
-                    nombre = gr.Label(label="Predicción principal", elem_classes=["pred-card"])
-                    confianza = gr.Label(label="Confianza")
-                # Default BarPlot; CSS applies color
-                prob_plot = gr.BarPlot(
-                    value=empty_df(),
-                    x="item",
-                    y="probability",
-                    title="Distribución de probabilidad (Top‑k)",
-                    x_title="Clase",
-                    y_title="Probabilidad",
-                    vertical=False,
-                    tooltip=["item", "probability"],
-                    width=520,
-                    height=320,
-                )
-            with gr.Tabs():
-                with gr.TabItem("Detalles"):
-                    with gr.Accordion("Descripción", open=True):
-                        descripcion = gr.Textbox(lines=4, interactive=False)
-                    with gr.Accordion("Síntomas", open=False):
-                        sintomas = gr.Textbox(lines=4, interactive=False)
-                    with gr.Accordion("Causas", open=False):
-                        causas = gr.Textbox(lines=4, interactive=False)
-                    with gr.Accordion("Tratamiento", open=False):
-                        tratamiento = gr.Textbox(lines=4, interactive=False)
-                with gr.TabItem("Acerca del modelo"):
-                    gr.Markdown(
-                        "- Arquitectura: CNN exportado a ONNX.<br>"
-                        "- Entrenamiento: dataset dermatoscópico (ver documentación).<br>"
-                        "- Nota: Esta herramienta es solo con fines educativos y no reemplaza una evaluación médica."
-                    )
+A production-ready deep learning application for dermatoscopic image analysis
+using ONNX Runtime and Gradio for web interface deployment.
 
-    gr.Markdown("<div class='footer'>Versión del modelo: 1.0 • Última actualización: 2025‑08 • Universidad Central de Venezuela</div>")
-
-    # ----------------------------
-    # Wiring: original-like behavior
-    # ----------------------------
-    outputs = [nombre, confianza, descripcion, sintomas, causas, tratamiento, prob_plot, latency]
-
-    # Analyze click runs prediction; predict() handles None safely
-    analyze_btn.click(fn=predict, inputs=[image], outputs=outputs, show_progress="full")
-
-    # Clear resets input and outputs - Fixed version
-    def clear_all():
-        # Return values for: image, nombre, confianza, descripcion, sintomas, causas, tratamiento, prob_plot, latency
-        return (None, "", "", "", "", "", "", empty_df(), "")
-
-    clear_btn.click(
-        fn=clear_all, 
-        inputs=[], 
-        outputs=[image, nombre, confianza, descripcion, sintomas, causas, tratamiento, prob_plot, latency]
+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
+from src.core.model import MelanoScopeModel
+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}")
+
+def create_application():
+    """
+    Create and configure the MelanoScope AI application.
+    
+    Returns:
+        Configured Gradio interface
+    """
+    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()
+        
+        logger.info("Application initialized successfully")
+        return interface
+        
+    except Exception as e:
+        logger.error(f"Failed to initialize application: {e}")
+        raise RuntimeError(f"Application initialization failed: {e}")
+
+def main():
+    """Main entry point for the application."""
+    # Set up logging
+    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
+        )
+        
+    except KeyboardInterrupt:
+        logger.info("Application shutdown requested")
+    except Exception as e:
+        logger.error(f"Application failed: {e}")
+        sys.exit(1)
 
 if __name__ == "__main__":
-    demo.launch()
+    main()

src/__init__.py

@@ -0,0 +1,21 @@
+"""
+MelanoScope AI - Enterprise Skin Lesion Classification System
+
+A production-ready deep learning application for dermatoscopic analysis.
+"""
+
+__version__ = "1.0.0"
+__author__ = "Daniel Cavadia"
+__institution__ = "Universidad Central de Venezuela"
+
+from .core.model import MelanoScopeModel
+from .ui.components import MelanoScopeUI
+from .config.settings import ModelConfig, UIConfig, AppConfig
+
+__all__ = [
+    "MelanoScopeModel",
+    "MelanoScopeUI", 
+    "ModelConfig",
+    "UIConfig",
+    "AppConfig"
+]

src/config/__init__.py

@@ -0,0 +1,11 @@
+"""Configuration module for MelanoScope AI."""
+
+from .settings import ModelConfig, UIConfig, AppConfig, LogConfig, EnvConfig
+
+__all__ = [
+    "ModelConfig",
+    "UIConfig", 
+    "AppConfig",
+    "LogConfig",
+    "EnvConfig"
+]

src/config/settings.py

@@ -0,0 +1,81 @@
+"""
+Configuration settings for MelanoScope AI application.
+Centralizes all constants and configuration parameters.
+"""
+import os
+from typing import List, Dict, Any
+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)
+    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
+
+# UI configuration
+class UIConfig:
+    """User interface configuration parameters."""
+    
+    # Theme settings
+    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"
+    VERSION: str = "1.0"
+    LAST_UPDATE: str = "2025-08"
+    INSTITUTION: str = "Universidad Central de Venezuela"
+    DISCLAIMER: str = "Demo • No diagnóstico médico"
+    
+    # Medical disclaimer
+    MEDICAL_DISCLAIMER: str = (
+        "Esta herramienta es solo con fines educativos y no reemplaza "
+        "una evaluación médica."
+    )
+
+# Logging configuration
+class LogConfig:
+    """Logging configuration parameters."""
+    
+    LOG_LEVEL: str = os.getenv("LOG_LEVEL", "INFO")
+    LOG_FORMAT: str = (
+        "%(asctime)s | %(name)s | %(levelname)s | %(message)s"
+    )
+    LOG_FILE: str = "melanoscope.log"
+
+# Environment settings
+class EnvConfig:
+    """Environment-specific configuration."""
+    
+    DEBUG: bool = os.getenv("DEBUG", "False").lower() == "true"
+    ENVIRONMENT: str = os.getenv("ENVIRONMENT", "production")

src/core/__init__.py

@@ -0,0 +1,13 @@
+"""Core functionality for MelanoScope AI."""
+
+from .model import MelanoScopeModel
+from .preprocessing import ImagePreprocessor
+from .utils import probabilities_to_ints, create_empty_dataframe, format_confidence
+
+__all__ = [
+    "MelanoScopeModel",
+    "ImagePreprocessor",
+    "probabilities_to_ints",
+    "create_empty_dataframe", 
+    "format_confidence"
+]

src/core/model.py

@@ -0,0 +1,252 @@
+"""
+Model inference module for MelanoScope AI.
+Handles ONNX model loading and inference operations.
+"""
+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.
+    """
+    
+    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")
+    
+    def _load_model(self) -> None:
+        """Load the ONNX model for inference."""
+        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}")
+            
+        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."""
+        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")
+            
+        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
+        if image_input is None:
+            logger.warning("Received None image input")
+            return self._create_empty_result("Cargue una imagen y presione Analizar.")
+        
+        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")
+            
+            # Run inference
+            prediction_result = self._run_inference(input_tensor)
+            if prediction_result is None:
+                return self._create_empty_result("Error en la inferencia")
+            
+            # 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
+            )
+            
+        except Exception as e:
+            logger.error(f"Prediction failed: {e}")
+            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)
+        """
+        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
+            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:
+            logger.error(f"Inference failed: {e}")
+            return None
+    
+    def _create_probability_dataframe(self, probabilities: np.ndarray) -> Any:
+        """Create a sorted probability dataframe for visualization."""
+        try:
+            import pandas as pd
+            
+            df = 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
+            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": ""}
+    
+    def _create_empty_result(self, message: str) -> Tuple[str, str, str, str, str, str, Any, str]:
+        """Create an empty result tuple 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

@@ -0,0 +1,108 @@
+"""
+Image preprocessing module for MelanoScope AI.
+Handles image transformations and normalization.
+"""
+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
+    
+    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
+        """
+        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:
+            logger.error(f"Error preprocessing image: {e}")
+            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
+        """
+        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
+                
+        except Exception as e:
+            logger.error(f"Error converting image to PIL format: {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

@@ -0,0 +1,116 @@
+"""
+Utility functions for MelanoScope AI.
+Contains helper functions and probability calculations.
+"""
+import logging
+from typing import List, Dict, Any, Union
+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
+    """
+    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
+        diff = total_sum - rounded.sum()
+        if diff != 0:
+            max_idx = int(np.argmax(positive_values))
+            rounded = rounded.flatten()
+            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}")
+        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)
+    })
+
+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
+    """
+    try:
+        percentage = probability * 100
+        return f"{percentage:.{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/__init__.py

@@ -0,0 +1,10 @@
+"""User interface components for MelanoScope AI."""
+
+from .components import MelanoScopeUI
+from .styles import create_theme, get_custom_css
+
+__all__ = [
+    "MelanoScopeUI",
+    "create_theme",
+    "get_custom_css"
+]

src/ui/components.py

@@ -0,0 +1,255 @@
+"""
+UI components for MelanoScope AI.
+Contains Gradio interface component definitions.
+"""
+import os
+import logging
+from typing import List, Any, Optional
+import gradio as gr
+
+from ..config.settings import UIConfig, EXAMPLES_DIR
+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."""
+    
+    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")
+    
+    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()
+            
+            logger.info("Interface created successfully")
+            return interface
+            
+        except Exception as e:
+            logger.error(f"Failed to create interface: {e}")
+            raise
+    
+    def _create_header(self) -> None:
+        """Create the header section with title and theme toggle."""
+        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")
+                except Exception:
+                    gr.Markdown("")  # Fallback for older Gradio versions
+    
+    def _create_input_column(self) -> None:
+        """Create the left column with image input 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",
+                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")
+            
+            # Examples section
+            self._create_examples_section()
+            
+            # Latency display
+            self.latency_output = gr.Label(label="Latencia aproximada")
+    
+    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}")
+    
+    def _create_results_column(self) -> None:
+        """Create the right column with results and information."""
+        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."""
+        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")
+            
+            # 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,
+            )
+    
+    def _create_information_tabs(self) -> None:
+        """Create the tabbed information section."""
+        with gr.Tabs():
+            # Medical details tab
+            with gr.TabItem("Detalles"):
+                self._create_medical_details()
+            
+            # Model information tab
+            with gr.TabItem("Acerca del modelo"):
+                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
+            )
+    
+    def _create_footer(self) -> None:
+        """Create the 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
+    
+    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, "")

src/ui/styles.py

@@ -0,0 +1,133 @@
+"""
+UI styling and theming for MelanoScope AI.
+Contains CSS styles and theme configurations.
+"""
+from typing import Optional
+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
+    """
+    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;
+    }
+    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);
+    }
+    """
+
+def create_theme():
+    """
+    Create and return the application theme.
+    
+    Returns:
+        Gradio theme object or None if creation fails
+    """
+    try:
+        import gradio as gr
+        
+        theme = 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}")
+        return None
+
+def get_header_html() -> str:
+    """
+    Get HTML for the application header.
+    
+    Returns:
+        HTML string for the header section
+    """
+    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.
+    </p>
+    """
+
+def get_footer_html() -> str:
+    """
+    Get HTML for the application footer.
+    
+    Returns:
+        HTML string for the footer section
+    """
+    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"{AppConfig.INSTITUTION}"
+        f"</div>"
+    )
+
+def get_model_info_html() -> str:
+    """
+    Get HTML for the model information tab.
+    
+    Returns:
+        HTML string describing the model
+    """
+    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}"
+    )