File size: 5,879 Bytes
886e412
 
 
 
e48dd40
 
 
144f1f9
abea708
886e412
e48dd40
 
 
 
 
 
 
 
 
 
886e412
e48dd40
886e412
 
 
 
e48dd40
886e412
e48dd40
886e412
e48dd40
886e412
e48dd40
886e412
e48dd40
886e412
 
 
e48dd40
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
abea708
 
e48dd40
abea708
e48dd40
a93df6f
abea708
e48dd40
abea708
 
 
e48dd40
 
 
886e412
 
e48dd40
 
 
 
 
 
abea708
 
 
e48dd40
abea708
e48dd40
 
 
abea708
e48dd40
 
cde2b94
e48dd40
 
ddce3f9
 
6be90c6
b9bf3c0
ca92a2d
 
 
 
 
 
f085f18
cde2b94
f085f18
ca92a2d
 
 
f085f18
ca92a2d
f085f18
e48dd40
 
 
886e412
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
import gradio as gr
import numpy as np
import cv2
from keras.models import load_model
import tensorflow as tf
from tensorflow import keras

# Cargar el modelo entrenado
model1 = load_model('./isatron_v3.h5')

# Función para encontrar la última capa convolucional
def find_last_conv_layer(model):
    for layer in reversed(model.layers):
        if 'conv' in layer.name:
            return layer.name
    raise ValueError("No se encontró una capa convolucional en el modelo.")

# Obtener el nombre de la última capa convolucional
last_conv_layer_name = find_last_conv_layer(model1)
print("Última capa convolucional:", last_conv_layer_name)

# Definir tamaño de imagen y etiquetas
img_size1 = 150
labels = ['PNEUMONIA', 'NORMAL']

def load_and_preprocess_image1(img):
    # Convertir imagen de Gradio (PIL Image) a array numpy
    img = np.array(img)
    # Convertir de RGB a escala de grises
    img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
    # Redimensionar imagen al tamaño requerido
    img = cv2.resize(img, (img_size1, img_size1))
    # Reformatear imagen para entrada del modelo
    img = img.reshape(-1, img_size1, img_size1, 1)
    # Normalizar imagen
    img = img / 255.0
    return img

def make_gradcam_heatmap(img_array, model, last_conv_layer_name, pred_index=None):
    # Crear un modelo que mapee la imagen de entrada a las activaciones
    # de la última capa convolucional y las predicciones
    grad_model = keras.models.Model(
        [model.inputs], [model.get_layer(last_conv_layer_name).output, model.output]
    )

    # Calcular el gradiente de la clase predicha con respecto a las activaciones
    with tf.GradientTape() as tape:
        last_conv_layer_output, preds = grad_model(img_array)
        if pred_index is None:
            pred_index = np.argmax(preds[0])
        class_channel = preds[:, pred_index]

    # Calcular los gradientes
    grads = tape.gradient(class_channel, last_conv_layer_output)

    # Pooling global de los gradientes
    pooled_grads = tf.reduce_mean(grads, axis=(0, 1, 2))

    # Multiplicar cada canal por su importancia
    last_conv_layer_output = last_conv_layer_output[0]
    heatmap = last_conv_layer_output @ pooled_grads[..., tf.newaxis]
    heatmap = tf.squeeze(heatmap)

    # Normalizar el mapa de calor entre 0 y 1
    heatmap = tf.maximum(heatmap, 0) / tf.reduce_max(heatmap)
    heatmap = heatmap.numpy()
    return heatmap

def overlay_heatmap(heatmap, img, alpha=0.4):
    # Redimensionar mapa de calor al tamaño de la imagen
    heatmap = cv2.resize(heatmap, (img.shape[1], img.shape[0]))
    # Convertir mapa de calor a RGB
    heatmap = np.uint8(255 * heatmap)
    heatmap = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)
    # Convertir imagen a BGR
    img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
    # Aplicar mapa de calor a la imagen original
    overlayed_img = heatmap * alpha + img
    overlayed_img = np.uint8(overlayed_img)
    # Convertir de nuevo a RGB
    overlayed_img = cv2.cvtColor(overlayed_img, cv2.COLOR_BGR2RGB)
    return overlayed_img

def image_classifier1(img):
    # Mantener la imagen original para superponer
    orig_img = np.array(img)
    # Preprocesar la imagen
    img_array = load_and_preprocess_image1(img)
    # Realizar predicción usando model1
    preds = model1.predict(img_array)
    prediction = preds[0][0]  # Suponiendo que el modelo devuelve una probabilidad
    # Determinar el índice de la clase predicha
    pred_index = int(prediction > 0.5)
    # Generar mapa de calor
    heatmap = make_gradcam_heatmap(img_array, model1, last_conv_layer_name, pred_index=pred_index)
    # Superponer mapa de calor en la imagen original
    overlayed_img = overlay_heatmap(heatmap, orig_img)
    # Retornar la imagen superpuesta y los porcentajes de predicción
    prediction_percentage = {'PNEUMONIA': float(prediction), 'NORMAL': float(1 - prediction)}
    return overlayed_img, prediction_percentage

# Crear interfaz Gradio con ejemplos de imágenes
demo_model1 = gr.Interface(
    fn=image_classifier1,
    inputs=gr.Image(type="pil", label="Subir imagen de rayos X"),
    outputs=[gr.Image(type="numpy", label="Imagen con Mapa de Calor"), gr.Label(label="Predicción")],
    title="<h1 style='text-align: center;'>IsaTron V2: Herramienta de Apoyo al Diagnóstico de Neumonía</h1>",
    description="""
    <div style='text-align: justify;'>
    IsaTron es una herramienta de inteligencia artificial desarrollada con redes neuronales convolucionales (CNN) para apoyar el diagnóstico de neumonía a partir de imágenes de rayos X. La IA analiza las imágenes y produce un mapa de calor que resalta las áreas de mayor relevancia para la predicción del modelo, lo cual ayuda a los profesionales de la salud a visualizar mejor las zonas afectadas.
    </div>
    <div style='text-align: justify;'>
    <strong>Advertencia:</strong> IsaTron está diseñado como una herramienta de apoyo y no reemplaza una evaluación médica profesional. Es crucial que los resultados generados por esta herramienta sean interpretados por personal de salud calificado.
    </div>
    """,
    examples=["IM-0115-0001.jpeg", "IM-0117-0001.jpeg", "IM-0119-0001.jpeg", "person30_bacteria_150.jpeg"],
    article="""
    <div style='text-align: justify;'>
    Este proyecto sigue en desarrollo y utiliza tecnologías avanzadas de inteligencia artificial, como redes neuronales convolucionales y Grad-CAM, para mejorar la interpretabilidad de los resultados. IsaTron ha sido entrenado con imágenes médicas y es capaz de predecir neumonía con un alto grado de confianza. Sin embargo, los resultados obtenidos deben ser confirmados por un médico especialista para realizar un diagnóstico clínico adecuado.
    </div>

    <div style='text-align: center;'>Jeysshon, 2024.</div>
    """
)

# Ejecutar la interfaz
if __name__ == "__main__":
    demo_model1.launch(share=True)