restore faulty interface

app.py

@@ -1,111 +1,211 @@
-import os
-import sys
 import json
-import logging
-import traceback
 import numpy as np
-import pandas as pd
 import gradio as gr
-import onnxruntime
+import onnxruntime as ort
 from PIL import Image
 from torchvision import transforms
+import pandas as pd
+import time
+import os
 
-# Logging
-logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s", stream=sys.stdout)
-log = logging.getLogger("space")
-
-def log_exc(prefix):
-    etype, evalue, tb = sys.exc_info()
-    stack = "".join(traceback.format_exception(etype, evalue, tb))
-    log.error("%s: %s\n%s", prefix, evalue, stack)
-    return f"{prefix}: {evalue}"
+# ----------------------------
+# Model + metadata
+# ----------------------------
+ORT_PROVIDERS = ["CPUExecutionProvider"]  # add "CUDAExecutionProvider" if available
+ort_session = ort.InferenceSession("model_new_new_final.onnx", providers=ORT_PROVIDERS)
 
-# Load metadata
 with open("dat.json", "r", encoding="utf-8") as f:
     data = json.load(f)
-keys = list(data.keys())
-log.info("Loaded %d classes from dat.json", len(keys))
+CLASSES = list(data)  # ordered list of class names
 
-# Load ONNX
-ort = onnxruntime.InferenceSession("model_new_new_final.onnx")
-log.info("ONNX inputs: %s", [(i.name, i.shape, i.type) for i in ort.get_inputs()])
-log.info("ONNX outputs: %s", [(o.name, o.shape, o.type) for o in ort.get_outputs()])
+def empty_df():
+    return pd.DataFrame({"item": CLASSES, "probability": [0] * len(CLASSES)})
 
-# Preprocess
-tfms = transforms.Compose([
+# ----------------------------
+# 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=[0.7611, 0.5869, 0.5923], std=[0.1266, 0.1487, 0.1619]),
+    transforms.Normalize(mean=MEAN, std=STD),
 ])
 
-def probabilities_to_ints(probabilities, total_sum=100):
-    probs = np.asarray(probabilities, dtype=np.float64)
-    probs = np.maximum(probs, 0)
-    total = probs.sum()
-    scaled = np.zeros_like(probs)
-    if total > 0:
-        scaled = probs / total * total_sum
-    rounded = np.round(scaled).astype(int)
-    diff = total_sum - int(rounded.sum())
-    if diff != 0 and total > 0:
-        rounded[int(np.argmax(probs))] += diff
-    return rounded
+def preprocess(pil_img: Image.Image):
+    return TFMS(pil_img).unsqueeze(0).numpy()
 
-def predict(image: Image.Image):
-    try:
-        if image is None:
-            return "Error", "", "", "", "", pd.DataFrame({"item": keys, "probability": *len(keys)}), "No image provided"
+# ----------------------------
+# 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")
-        x = tfms(pil).unsqueeze(0).numpy().astype(np.float32)  # (1,C,H,W)
-        input_name = ort.get_inputs().name
-        outs = ort.run(None, {input_name: x})
-        logits = outs
-        if logits.ndim == 2:
-            scores = logits
-        elif logits.ndim == 1:
-            scores = logits
-        else:
-            raise ValueError(f"Unexpected logits shape: {logits.shape}")
-        if len(scores) != len(keys):
-            raise ValueError(f"Logits length {len(scores)} != classes {len(keys)}")
-        idx = int(np.argmax(scores))
-        name = keys[idx]
-        meta = data.get(name, {})
-        desc = meta.get("description", "")
-        symp = meta.get("symptoms", "")
-        causes = meta.get("causes", "")
-        treat = meta.get("treatment-1", meta.get("treatment", ""))
-        df = pd.DataFrame({"item": keys, "probability": probabilities_to_ints(scores).astype(int)})
-        return name, desc, symp, causes, treat, df, ""
-    except Exception:
-        err = log_exc("Inference failed")
-        df = pd.DataFrame({"item": keys if keys else ["N/A"], "probability": *(len(keys) if keys else 1)})
-        return "Error", "", "", "", "", df, err
-
-with gr.Blocks(title="Clasificacion de Enfermedades de la Piel") as demo:
-    gr.Markdown("Suba una imagen y ejecute la prediccion.")
-    with gr.Row():
-        img = gr.Image(type="pil", label="Imagen")
-        with gr.Column():
-            out_name = gr.Textbox(label="Nombre de la Enfermedad")
-            out_desc = gr.Textbox(label="Descripcion")
-            out_symp = gr.Textbox(label="Sintomas")
-            out_causes = gr.Textbox(label="Causas")
-            out_treat = gr.Textbox(label="Tratamiento")
-    bar = gr.BarPlot(
-        x="item",
-        y="probability",
-        title="Distribucion de Probabilidad",
-        x_title="Nombre de la Enfermedad",
-        y_title="Probabilidad",
-        tooltip=["item", "probability"],
-        vertical=False,
-        label="Probabilidades"
+    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
     )
-    err = gr.Textbox(label="Errores", interactive=False)
-    btn = gr.Button("Predecir")
-    btn.click(fn=predict, inputs=[img], outputs=[out_name, out_desc, out_symp, out_causes, out_treat, bar, err])
+
+    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; }
+"""
+
+# ----------------------------
+# 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."
+                    )
+
+    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
+    def clear_all():
+        return (None, "", "", "", "", "", empty_df(), "")
+
+    clear_btn.click(fn=clear_all, inputs=None, outputs=[image] + outputs)
 
 if __name__ == "__main__":
-    # Spaces handles networking; no share=True
-    demo.launch(debug=True)
+    demo.launch()