Update app.py

app.py

@@ -1,10 +1,5 @@
-import os
-import sys
 import json
-import traceback
-import logging
-from typing import Tuple, Any, Dict, List
-
+import cv2
 import numpy as np
 import gradio as gr
 import onnxruntime
@@ -12,252 +7,120 @@ from PIL import Image
 from torchvision import transforms
 import pandas as pd
 
-# ------------------------------------------------------------------------------
-# Logging setup
-# ------------------------------------------------------------------------------
-LOG_LEVEL = os.getenv("LOG_LEVEL", "DEBUG").upper()
-logging.basicConfig(
-    level=getattr(logging, LOG_LEVEL, logging.DEBUG),
-    format="%(asctime)s | %(levelname)s | %(name)s | %(message)s",
-    stream=sys.stdout,
-)
-log = logging.getLogger("app")
-
-def log_exception(prefix: str) -> str:
-    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}\nSee server logs for stack trace."
-
-# ------------------------------------------------------------------------------
-# Environment and package info
-# ------------------------------------------------------------------------------
-def log_env_info():
-    log.info("Python: %s", sys.version)
-    log.info("Platform: %s", sys.platform)
-    try:
-        import gradio
-        import fastapi
-        import starlette
-        import onnx
-        import torch
-        log.info("gradio=%s fastapi=%s starlette=%s onnx=%s torch=%s",
-                 getattr(gradio, '__version__', '?'),
-                 getattr(fastapi, '__version__', '?'),
-                 getattr(starlette, '__version__', '?'),
-                 getattr(onnx, '__version__', '?'),
-                 getattr(torch, '__version__', '?'))
-    except Exception:
-        log.warning("Could not log all package versions", exc_info=True)
-
-log_env_info()
-
-# ------------------------------------------------------------------------------
-# Model and metadata loading
-# ------------------------------------------------------------------------------
-MODEL_PATH = os.getenv("MODEL_PATH", "model_new_new_final.onnx")
-JSON_PATH = os.getenv("JSON_PATH", "dat.json")
-
-def load_metadata(json_path: str) -> Tuple[List[str], Dict[str, Any]]:
-    with open(json_path, 'r', encoding='utf-8') as f:
-        meta = json.load(f)
-    # Ensure deterministic order: keep file order if Py3.7+ or optionally use a stored labels list
-    keys = list(meta.keys())
-    log.info("Loaded metadata: %d classes from %s", len(keys), json_path)
-    return keys, meta
-
-def load_session(model_path: str) -> onnxruntime.InferenceSession:
-    so = onnxruntime.SessionOptions()
-    so.log_severity_level = 0  # Verbose ORT logs if needed
-    providers = ["CPUExecutionProvider"]
-    sess = onnxruntime.InferenceSession(model_path, sess_options=so, providers=providers)
-    # Log IO details
-    inputs = sess.get_inputs()
-    outputs = sess.get_outputs()
-    for i, inp in enumerate(inputs):
-        log.info("ONNX Input[%d]: name=%s shape=%s type=%s", i, inp.name, inp.shape, inp.type)
-    for i, out in enumerate(outputs):
-        log.info("ONNX Output[%d]: name=%s shape=%s type=%s", i, out.name, out.shape, out.type)
-    return sess
-
-# Load once at startup with protective logging
-try:
-    KEYS, META = load_metadata(JSON_PATH)
-except Exception:
-    msg = log_exception(f"Failed to load metadata JSON at {JSON_PATH}")
-    # Fallbacks to keep app launching
-    KEYS, META = [], {}
-    META["_startup_error"] = msg
+# Cargar el modelo ONNX
+ort_session = onnxruntime.InferenceSession("model_new_new_final.onnx")
 
-try:
-    ORT = load_session(MODEL_PATH)
-except Exception:
-    msg = log_exception(f"Failed to load ONNX model at {MODEL_PATH}")
-    ORT = None
+# Abrir archivo JSON
+with open('dat.json') as f:
+    data = json.load(f)
 
-# ------------------------------------------------------------------------------
-# Preprocessing
-# ------------------------------------------------------------------------------
-MEAN = [0.7611, 0.5869, 0.5923]
-STD = [0.1266, 0.1487, 0.1619]
+keys = list(data)
 
-TFMS = transforms.Compose([
-    transforms.Resize((100, 100)),
-    transforms.ToTensor(),
-    transforms.Normalize(mean=MEAN, std=STD),
-])
-
-def preprocess(img: Image.Image) -> np.ndarray:
-    if img is None:
-        raise ValueError("No image provided")
-    log.debug("Input image: mode=%s size=%s", img.mode, img.size)
-    img = img.convert("RGB")
-    t = TFMS(img).unsqueeze(0).numpy().astype(np.float32)  # (1,C,H,W)
-    log.debug("Tensor shape=%s dtype=%s min=%.4f max=%.4f mean=%.4f std=%.4f",
-              t.shape, t.dtype, float(t.min()), float(t.max()),
-              float(t.mean()), float(t.std()))
-    return t
-
-# ------------------------------------------------------------------------------
-# Postprocessing and helpers
-# ------------------------------------------------------------------------------
-def probabilities_to_ints(probabilities: np.ndarray, total_sum: int = 100) -> np.ndarray:
-    probs = np.asarray(probabilities).astype(np.float64)
-    if probs.ndim != 1:
-        raise ValueError(f"Expected 1D probs, got shape {probs.shape}")
-    if not np.isfinite(probs).all():
-        raise ValueError("Non-finite values in probabilities")
-    positives = np.maximum(probs, 0)
-    total = positives.sum()
-    scaled = np.zeros_like(positives)
-    if total > 0:
-        scaled = positives / 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(positives))] += diff
-    return rounded
-
-def safe_lookup(disease_name: str, meta: Dict[str, Any]) -> Tuple[str, str, str, str]:
-    info = meta.get(disease_name, {})
-    desc = info.get('description', '')
-    symp = info.get('symptoms', '')
-    causes = info.get('causes', '')
-    treat = info.get('treatment-1', '') or info.get('treatment', '')
-    return desc, symp, causes, treat
-
-def infer(tensor: np.ndarray) -> np.ndarray:
-    if ORT is None:
-        raise RuntimeError("ONNX session not initialized. Check model load errors in logs.")
-    # Validate input against model input signature
-    model_input = ORT.get_inputs()[0]
-    if model_input.type not in ("tensor(float)", "tensor(float16)"):
-        log.warning("Model expects %s but provided float32; ORT may cast automatically.", model_input.type)
-    feed_name = model_input.name
-    log.debug("Feeding input: name=%s shape=%s dtype=%s", feed_name, tensor.shape, tensor.dtype)
-    out_list = ORT.run(None, {feed_name: tensor})
-    if not out_list:
-        raise RuntimeError("ONNX returned no outputs")
-    logits = out_list
-    log.debug("ONNX outputs: %d tensors", len(out_list))
-    for i, o in enumerate(out_list):
-        # Defensive stats
-        try:
-            min_v = float(np.nanmin(o))
-            max_v = float(np.nanmax(o))
-            mean_v = float(np.nanmean(o))
-            log.debug("Output[%d]: shape=%s dtype=%s min=%.4f max=%.4f mean=%.4f",
-                      i, getattr(o, 'shape', '?'), getattr(o, 'dtype', '?'), min_v, max_v, mean_v)
-        except Exception:
-            log.debug("Output[%d]: non-numpy type %s", i, type(o))
-    if isinstance(logits, list):
-        logits = np.asarray(logits)
-    logits = np.array(logits)
-    if logits.ndim == 2:
-        logits = logits[0]
-    elif logits.ndim != 1:
-        raise ValueError(f"Unexpected logits shape: {logits.shape}")
-    if not np.isfinite(logits).all():
-        raise ValueError("Logits contain non-finite values")
-    return logits.astype(np.float32)
-
-# ------------------------------------------------------------------------------
-# Gradio Predict wrapper with robust error reporting
-# ------------------------------------------------------------------------------
-def predict_ui(image: Image.Image):
-    try:
-        # Startup errors surfaced in UI
-        if "_startup_error" in META:
-            raise RuntimeError(META["_startup_error"])
-        if not KEYS:
-            raise RuntimeError("Class list is empty. Verify dat.json content.")
-        x = preprocess(image)
-        logits = infer(x)
-        if len(logits) != len(KEYS):
-            raise ValueError(f"Logits length ({len(logits)}) != number of classes ({len(KEYS)}). "
-                             "Ensure label order matches model output.")
-        pred_idx = int(np.argmax(logits))
-        pred_name = KEYS[pred_idx]
-        log.info("Prediction: idx=%d name=%s score=%.4f", pred_idx, pred_name, float(logits[pred_idx]))
-        desc, symp, causes, treat = safe_lookup(pred_name, META)
-        probs_int = probabilities_to_ints(logits)
-        df = pd.DataFrame({"item": KEYS, "probability": probs_int.astype(int)})
-        # Return without error
-        return pred_name, desc, symp, causes, treat, df, ""
-    except Exception as e:
-        # Log and return placeholders plus an error message textbox
-        err = log_exception("Inference failed")
-        # Provide minimal but valid outputs so the UI doesn't crash
-        empty_df = pd.DataFrame({"item": KEYS if KEYS else ["N/A"], "probability": [0]*(len(KEYS) if KEYS else 1)})
-        return "Error", "", "", "", "", empty_df, err
-
-# ------------------------------------------------------------------------------
-# Gradio UI
-# ------------------------------------------------------------------------------
-bar_output = gr.BarPlot(
-    x="item",
-    y="probability",
-    y_title="Probabilidad",
-    x_title="Nombre de la Enfermedad",
-    title="Distribucion de Probabilidad",
-    tooltip=["item", "probability"],
-    vertical=False
+# DataFrame de ejemplo
+simple = pd.DataFrame(
+    {
+        "item": keys,
+        "probability": [0] * len(keys)
+    }
 )
 
-with gr.Blocks(title="Clasificacion de Enfermedades de la Piel") as demo:
-    gr.Markdown(
-        "Este espacio se ha desarrollado como parte de una tesis para la Universidad Central de Venezuela "
-        "con el proposito de realizar diagnosticos precisos sobre una variedad de lesiones cutaneas. "
-        "Su objetivo es ayudar en la identificacion temprana y precisa de condiciones dermatologicas, incluyendo:\n\n"
-        "1) Queratosis Actinica \n\n"
-        "2) Carcinoma Basocelular \n\n"
-        "3) Dermatofibroma \n\n"
-        "4) Melanoma \n\n"
-        "5) Nevus \n\n"
-        "6) Queratosis Pigmentada Benigna \n\n"
-        "7) Queratosis Seborreica \n\n"
-        "8) Carcinoma de Celulas Escamosas \n\n"
-        "9) Lesion Vascular \n\n"
-    )
-
-    with gr.Row():
-        img_in = 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 = bar_output
-    err_box = gr.Textbox(label="Errores", interactive=False)
-
-    btn = gr.Button("Predecir")
-    btn.click(
-        fn=predict_ui,
-        inputs=[img_in],
-        outputs=[out_name, out_desc, out_symp, out_causes, out_treat, bar, err_box]
+def Predict(image):
+    # Preprocesar la imagen
+    img = cv2.resize(image, (100, 100))
+
+    # Convertir el arreglo NumPy de vuelta a una imagen PIL
+    image = Image.fromarray(image)
+    
+    # Preprocesar la imagen
+    img = image.resize((100, 100))
+
+    # Definir transformaciones
+    test_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])
+    ])
+    
+    # Aplicar transformaciones
+    input_image = test_tfms(img).unsqueeze(0).numpy()  # Agregar dimension de lote y convertir a arreglo numpy
+
+    # Preparar tensor de entrada
+    input_name = ort_session.get_inputs()[0].name
+    input_dict = {input_name: input_image}
+
+    # Ejecutar inferencia
+    output = ort_session.run(None, input_dict)
+
+    # Obtener el indice de la clase predicha
+    prediction_idx = np.argmax(output)
+
+    # Recuperar informacion del JSON basada en la clase predicha
+    disease_name = keys[prediction_idx]
+    description = data[disease_name]['description']
+    symptoms = data[disease_name]['symptoms']
+    causes = data[disease_name]['causes']
+    treatment = data[disease_name]['treatment-1']
+
+    # Obtener probabilidades para cada clase y convertirlas a enteros
+    probabilities = output[0]
+    ints_probabilities = probabilities_to_ints(probabilities)
+
+    # Actualizar la probabilidad en el DataFrame
+    simple["probability"] = ints_probabilities[0]
+
+    # Crear grafico de barras para las probabilidades
+    bar_plot = gr.BarPlot(
+        value=simple,
+        x="item",
+        y="probability",
+        y_title="Probabilidad",
+        x_title="Nombre de la Enfermedad",
+        title="Distribucion de Probabilidad",
+        tooltip=["item", "probability"],
+        vertical = False
     )
 
-# Do not set share=True in Spaces
-if __name__ == "__main__":
-    demo.launch(debug=True)
+    return disease_name, description, symptoms, causes, treatment, bar_plot
+
+# Funcion para convertir probabilidades a enteros
+def probabilities_to_ints(probabilities, total_sum=100):
+    # Filtrar los valores negativos
+    positive_values = np.maximum(probabilities, 0)
+    
+    # Encontrar el peso positivo total
+    total_positive_weight = np.sum(positive_values)
+    
+    # Calcular probabilidades escaladas para valores positivos
+    scaled_probabilities = np.zeros_like(probabilities)
+    if total_positive_weight > 0:
+        scaled_probabilities = positive_values / total_positive_weight * total_sum
+    
+    # Redondear las probabilidades escaladas a enteros
+    rounded_probabilities = np.round(scaled_probabilities).astype(int)
+    
+    # Ajustar por errores de redondeo
+    rounding_diff = total_sum - np.sum(rounded_probabilities)
+    if rounding_diff != 0 and np.sum(positive_values) > 0:
+        # Agregar la diferencia de redondeo a la clase con mayor peso positivo
+        max_positive_index = np.argmax(positive_values)
+        flattened_probabilities = rounded_probabilities.flatten()
+        flattened_probabilities[max_positive_index] += rounding_diff
+        rounded_probabilities = np.reshape(flattened_probabilities, rounded_probabilities.shape)
+    
+    return rounded_probabilities
+
+# Definir la interfaz Gradio
+demo = gr.Interface(fn=Predict,
+                    inputs="image",
+                    outputs=[
+                        gr.Textbox(label='Nombre de la Enfermedad', type="text"),
+                        gr.Textbox(label='Descripcion', type="text"),
+                        gr.Textbox(label='Sintomas', type="text"),
+                        gr.Textbox(label='Causas', type="text"),
+                        gr.Textbox(label='Tratamiento', type="text"),
+                        "bar_plot"
+                    ],
+                    title="Clasificacion de Enfermedades de la Piel",
+                    description = 'Este espacio se ha desarrollado como parte de una tesis para la Universidad Central de Venezuela con el proposito de realizar diagnosticos precisos sobre una variedad de lesiones cutaneas. Su objetivo es ayudar en la identificacion temprana y precisa de condiciones dermatologicas, incluyendo:\n\n1)Queratosis Actinica \n\n2)Carcinoma Basocelular \n\n3)Dermatofibroma \n\n4)Melanoma \n\n5)Nevus \n\n6)Queratosis Pigmentada Benigna \n\n7)Queratosis Seborreica \n\n8)Carcinoma de Celulas Escamosas \n\n9)Lesion Vascular \n\n')
+
+demo.launch(debug=True)