Update app.py

app.py

@@ -1,5 +1,4 @@
 import json
-import cv2
 import numpy as np
 import gradio as gr
 import onnxruntime
@@ -7,120 +6,91 @@ from PIL import Image
 from torchvision import transforms
 import pandas as pd
 
-# Cargar el modelo ONNX
-ort_session = onnxruntime.InferenceSession("model_new_new_final.onnx")
+# Load model
+ort_session = onnxruntime.InferenceSession("model_new_new_final.onnx", providers=["CPUExecutionProvider"])
 
-# Abrir archivo JSON
-with open('dat.json') as f:
+# Load classes + metadata
+with open("dat.json", "r", encoding="utf-8") as f:
     data = json.load(f)
-
-keys = list(data)
-
-# DataFrame de ejemplo
-simple = pd.DataFrame(
-    {
-        "item": keys,
-        "probability": [0] * len(keys)
-    }
-)
-
-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,
+keys = list(data.keys())
+
+# Preprocessing
+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]),
+])
+
+def softmax(x: np.ndarray) -> np.ndarray:
+    x = x - np.max(x)
+    e = np.exp(x)
+    return e / e.sum()
+
+def probabilities_to_ints(probabilities: np.ndarray, total_sum: int = 100) -> np.ndarray:
+    probs = np.asarray(probabilities, dtype=np.float64)
+    if probs.ndim == 2 and probs.shape[0] == 1:
+        probs = probs
+    elif probs.ndim != 1:
+        raise ValueError(f"Unexpected probabilities shape: {probs.shape}")
+    positive = np.maximum(probs, 0)
+    s = positive.sum()
+    if s == 0:
+        return np.zeros_like(positive, dtype=int)
+    scaled = positive / s * total_sum
+    rounded = np.rint(scaled).astype(int)
+    diff = total_sum - int(rounded.sum())
+    if diff != 0:
+        order = np.argsort(-positive)
+        for i in range(abs(diff)):
+            idx = order[i % len(order)]
+            rounded[idx] += 1 if diff > 0 else -1
+    return rounded
+
+def Predict(image: Image.Image):
+    if not isinstance(image, Image.Image):
+        image = Image.fromarray(image)
+    tensor = test_tfms(image).unsqueeze(0).numpy().astype(np.float32)
+    input_name = ort_session.get_inputs().name
+    out = ort_session.run(None, {input_name: tensor})
+    logits = out
+    if logits.ndim == 2 and logits.shape == 1:
+        logits = logits
+    elif logits.ndim != 1:
+        raise ValueError(f"Unexpected model output shape: {logits.shape}")
+    pred_idx = int(np.argmax(logits))
+    probs = softmax(logits)
+    ints = probabilities_to_ints(probs).astype(int)
+    df = pd.DataFrame({"item": [str(k) for k in keys], "probability": [int(x) for x in ints.tolist()]})
+    disease_name = keys[pred_idx]
+    meta = data.get(disease_name, {})
+    description = meta.get("description", "N/A")
+    symptoms = meta.get("symptoms", "N/A")
+    causes = meta.get("causes", "N/A")
+    treatment = meta.get("treatment-1", meta.get("treatment", "N/A"))
+    return disease_name, description, symptoms, causes, treatment, df
+
+with gr.Blocks(title="Clasificacion de Enfermedades de la Piel") as demo:
+    gr.Markdown(
+        "Este espacio se ha desarrollado..."
+    )
+    inp = gr.Image(type="pil", label="Imagen de la piel")
+    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",
         y_title="Probabilidad",
         x_title="Nombre de la Enfermedad",
         title="Distribucion de Probabilidad",
         tooltip=["item", "probability"],
-        vertical = False
+        vertical=False,
+        label="Probabilidades"
     )
+    btn = gr.Button("Predecir")
+    btn.click(Predict, inputs=inp, outputs=[out_name, out_desc, out_symp, out_causes, out_treat, bar])
 
-    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)
+if __name__ == "__main__":
+    demo.launch(debug=True)