Update app.py

app.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 import json
 import numpy as np
 import gradio as gr
@@ -12,99 +11,98 @@ import os
 # ----------------------------
 # Model + metadata
 # ----------------------------
-ORT_PROVIDERS = ["CPUExecutionProvider"]  # add "CUDAExecutionProvider" if available [1]
-ort_session = ort.InferenceSession("model_new_new_final.onnx", providers=ORT_PROVIDERS)  # [1]
+ORT_PROVIDERS = ["CPUExecutionProvider"]  # add "CUDAExecutionProvider" if available
+ort_session = ort.InferenceSession("model_new_new_final.onnx", providers=ORT_PROVIDERS)
 
 with open("dat.json", "r", encoding="utf-8") as f:
-    data = json.load(f)  # [1]
-CLASSES = list(data)  # ordered list of class names [1]
+    data = json.load(f)
+CLASSES = list(data)  # ordered list of class names
 
 def empty_df():
-    # FIX: build zeros list via  * len(CLASSES) instead of a starred expression in dict value [1]
-    return pd.DataFrame({"item": CLASSES, "probability": [0] * len(CLASSES)})  # [3]
+    return pd.DataFrame({"item": CLASSES, "probability": [0] * len(CLASSES)})
 
 # ----------------------------
 # Utils
 # ----------------------------
 def probabilities_to_ints(probabilities, total_sum=100):
-    probabilities = np.array(probabilities)  # [1]
-    positive_values = np.maximum(probabilities, 0)  # [1]
-    total_positive = positive_values.sum()  # [1]
+    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)  # [1]
-    scaled = positive_values / total_positive * total_sum  # [1]
-    rounded = np.round(scaled).astype(int)  # [1]
-    diff = total_sum - rounded.sum()  # [1]
+        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))  # [1]
-        rounded = rounded.flatten()  # [1]
-        rounded[max_idx] += diff  # [1]
-        rounded = rounded.reshape(scaled.shape)  # [1]
-    return rounded  # [1]
-
-MEAN = [0.7611, 0.5869, 0.5923]  # [1]
-STD = [0.1266, 0.1487, 0.1619]  # [1]
+        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),
-])  # [1]
+])
 
 def preprocess(pil_img: Image.Image):
-    return TFMS(pil_img).unsqueeze(0).numpy()  # [1]
+    return TFMS(pil_img).unsqueeze(0).numpy()
 
 # ----------------------------
 # Inference function
 # ----------------------------
 def predict(image):
-    # Handle clicks with no image gracefully [1]
+    # Handle clicks with no image gracefully
     if image is None:
-        return ("Cargue una imagen y presione Analizar.", "", "", "", "", "", empty_df(), "")  # [1][3]
+        return ("Cargue una imagen y presione Analizar.", "", "", "", "", "", empty_df(), "")
     if isinstance(image, Image.Image):
-        pil = image.convert("RGB")  # [1]
+        pil = image.convert("RGB")
     else:
         try:
-            pil = Image.fromarray(image).convert("RGB")  # [1]
+            pil = Image.fromarray(image).convert("RGB")
         except Exception:
-            return ("Imagen inválida", "", "", "", "", "", empty_df(), "")  # [1][3]
+            return ("Imagen inválida", "", "", "", "", "", empty_df(), "")
 
-    t0 = time.time()  # [1]
-    input_tensor = preprocess(pil)  # [1]
-    input_name = ort_session.get_inputs().name  # [1]
-    output = ort_session.run(None, {input_name: input_tensor})  # [1]
+    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.squeeze()  # [1]
-    pred_idx = int(np.argmax(logits))  # [1]
-    pred_name = CLASSES[pred_idx]  # [1]
+    logits = output[0].squeeze()
+    pred_idx = int(np.argmax(logits))
+    pred_name = CLASSES[pred_idx]
 
-    # Softmax probabilities [1]
-    exp = np.exp(logits - np.max(logits))  # [1]
-    probs = exp / exp.sum()  # [1]
-    conf_text = f"{float(probs[pred_idx]) * 100:.1f}%"  # [1]
+    # 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)  # [1]
+    ints = probabilities_to_ints(probs * 100.0, total_sum=100)
     df = pd.DataFrame({"item": CLASSES, "probability": ints.astype(int)}).sort_values(
         "probability", ascending=True
-    )  # [3]
+    )
 
-    details = data[pred_name]  # [1]
-    descripcion = details.get("description", "")  # [1]
-    sintomas = details.get("symptoms", "")  # [1]
-    causas = details.get("causes", "")  # [1]
-    tratamiento = details.get("treatment-1", "")  # [1]
+    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)  # [1]
-    return (pred_name, conf_text, descripcion, sintomas, causas, tratamiento, df, f"{latency_ms} ms")  # [3][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")  # [4]
+    theme = gr.themes.Soft(primary_hue="rose", secondary_hue="slate")
 except Exception:
-    theme = None  # fallback to default theme [4]
+    theme = None  # fallback to default theme
 
-# CSS polish; tint bars via CSS for Gradio 4.27 [4]
+# 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;}
@@ -113,7 +111,7 @@ CUSTOM_CSS = """
 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; }
-"""  # [4][3]
+"""
 
 # ----------------------------
 # UI
@@ -131,39 +129,39 @@ with gr.Blocks(theme=theme, css=CUSTOM_CSS) as demo:
                   Sube una imagen dermatoscópica para ver la clase predicha, la confianza y la distribución de probabilidades.
                 </p>
                 """
-            )  # [4]
+            )
         with gr.Column(scale=1, min_width=140):
             try:
-                dark_toggle = gr.ThemeMode(label="Modo", value="system")  # optional UI affordance [4]
+                dark_toggle = gr.ThemeMode(label="Modo", value="system")
             except Exception:
-                gr.Markdown("")  # [4]
+                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"])  # [1]
+            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 [1]
-                clear_btn = gr.Button("Limpiar")  # [2]
+                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",
-            ]  # [1]
-            example_paths = [p for p in example_paths if os.path.exists(p)]  # [1]
+            ]
+            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")  # [1]
-            latency = gr.Label(label="Latencia aproximada")  # [1]
+                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"])  # [1]
-                    confianza = gr.Label(label="Confianza")  # [1]
-                # Default BarPlot; CSS applies color [3]
+                    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",
@@ -175,54 +173,39 @@ with gr.Blocks(theme=theme, css=CUSTOM_CSS) as demo:
                     tooltip=["item", "probability"],
                     width=520,
                     height=320,
-                )  # [3]
+                )
             with gr.Tabs():
                 with gr.TabItem("Detalles"):
                     with gr.Accordion("Descripción", open=True):
-                        descripcion = gr.Textbox(lines=4, interactive=False)  # [1]
+                        descripcion = gr.Textbox(lines=4, interactive=False)
                     with gr.Accordion("Síntomas", open=False):
-                        sintomas = gr.Textbox(lines=4, interactive=False)  # [1]
+                        sintomas = gr.Textbox(lines=4, interactive=False)
                     with gr.Accordion("Causas", open=False):
-                        causas = gr.Textbox(lines=4, interactive=False)  # [1]
+                        causas = gr.Textbox(lines=4, interactive=False)
                     with gr.Accordion("Tratamiento", open=False):
-                        tratamiento = gr.Textbox(lines=4, interactive=False)  # [1]
+                        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."
-                    )  # [4]
+                    )
 
-    gr.Markdown("<div class='footer'>Versión del modelo: 1.0 • Última actualización: 2025‑08 • Universidad Central de Venezuela</div>")  # [4]
+    gr.Markdown("<div class='footer'>Versión del modelo: 1.0 • Última actualización: 2025‑08 • Universidad Central de Venezuela</div>")
 
     # ----------------------------
-    # Wiring
+    # Wiring: original-like behavior
     # ----------------------------
-    outputs = [nombre, confianza, descripcion, sintomas, causas, tratamiento, prob_plot, latency]  # [1]
+    outputs = [nombre, confianza, descripcion, sintomas, causas, tratamiento, prob_plot, latency]
 
-    # Analyze click runs prediction; predict() handles None safely [1]
-    analyze_btn.click(fn=predict, inputs=[image], outputs=outputs, show_progress="full")  # [1]
+    # 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 using explicit updates for compatibility [1][2]
+    # Clear resets input and outputs
     def clear_all():
-        return (
-            gr.Image.update(value=None),          # image [2]
-            gr.Label.update(value=""),            # nombre [2]
-            gr.Label.update(value=""),            # confianza [2]
-            gr.Textbox.update(value=""),          # descripcion [2]
-            gr.Textbox.update(value=""),          # sintomas [2]
-            gr.Textbox.update(value=""),          # causas [2]
-            gr.Textbox.update(value=""),          # tratamiento [2]
-            gr.BarPlot.update(value=empty_df()),  # prob_plot expects a DataFrame [3]
-            gr.Label.update(value=""),            # latency [2]
-        )  # [1]
-
-    clear_btn.click(
-        fn=clear_all,
-        inputs=[],
-        outputs=[image, nombre, confianza, descripcion, sintomas, causas, tratamiento, prob_plot, latency],
-        show_progress="hidden"
-    )  # [1][2]
+        return (None, "", "", "", "", "", empty_df(), "")
+
+    clear_btn.click(fn=clear_all, inputs=None, outputs=[image] + outputs)
 
 if __name__ == "__main__":
-    demo.launch()  # [1]
+    demo.launch()