En este proyecto, me alej\u00e9 de las Redes Neuronales Convolucionales (CNN) est\u00e1ndar para explorar un enfoque m\u00e1s sofisticado: un Autoencoder Convolucional<\/strong>. En lugar de alimentar p\u00edxeles crudos directamente a un clasificador, entren\u00e9 un autoencoder para aprender una representaci\u00f3n estructural y comprimida del cerebro: el Espacio Latente<\/strong>. Este enfoque permite al modelo filtrar el ruido y centrarse en los patrones anat\u00f3micos antes de realizar un diagn\u00f3stico.<\/p>\n\n\n\n El sistema final alcanza una precisi\u00f3n del 96% y, lo que es crucial, implementa Grad-CAM<\/strong> para visualizar exactamente d\u00f3nde se encuentra el tumor, a\u00f1adiendo una capa de confianza para los entornos cl\u00ednicos.<\/p>\n\n\n\n El n\u00facleo de esta soluci\u00f3n es el autoencoder. Esta red aprende a comprimir la imagen de entrada de 128 x 128 p\u00edxeles en un vector de caracter\u00edsticas compacto y luego la reconstruye. Al forzar a la red a pasar informaci\u00f3n a trav\u00e9s de un cuello de botella (bottleneck<\/em>), nos aseguramos de que aprenda las caracter\u00edsticas m\u00e1s destacadas de la estructura cerebral.<\/p>\n\n\n\n Aqu\u00ed est\u00e1 la implementaci\u00f3n de la arquitectura del autoencoder usando TensorFlow y Keras:<\/p>\n\n\n \u00bfRealmente entiende los cerebros? (Reconstrucci\u00f3n)<\/strong><\/p>\n\n\n\n Antes de construir el clasificador, debemos verificar que nuestro autoencoder est\u00e9 aprendiendo caracter\u00edsticas significativas y no simplemente memorizando ruido. Para hacer esto, observamos la p\u00e9rdida de reconstrucci\u00f3n y comparamos las im\u00e1genes de entrada con las salidas generadas.<\/p>\n\n\n\n Pie de foto: La p\u00e9rdida de entrenamiento muestra una convergencia constante, lo que indica que el modelo est\u00e1 aprendiendo efectivamente la estructura interna de las exploraciones de MRI.<\/p>\n\n\n\n La inspecci\u00f3n visual confirma que el “Espacio Latente” contiene suficiente informaci\u00f3n para reconstruir la anatom\u00eda mientras filtra algo de ruido de alta frecuencia.<\/p>\n\n\n\n [Insert Brain reconstruction.jpg here]<\/p>\n\n\n\n Pie de foto: Arriba: MRI original | Abajo: Imagen reconstruida. Observa c\u00f3mo se preservan la estructura general y el \u00e1rea del tumor.<\/p>\n\n\n\n Una vez entrenado el autoencoder, la parte del “Decodificador” ya no es necesaria para el diagn\u00f3stico. Nos interesa el Codificador<\/strong>, que act\u00faa como nuestro extractor de caracter\u00edsticas. Congelamos los pesos del codificador y adjuntamos un cabezal de clasificaci\u00f3n denso a su salida.<\/p>\n\n\n\n Este enfoque transforma el problema: en lugar de clasificar una imagen compleja de 128 x 128, la red densa clasifica las caracter\u00edsticas comprimidas de alto nivel extra\u00eddas por el codificador.<\/p>\n\n\n\n [insertar aqui diagrama autoencoder con clasificador.png]<\/p>\n\n\n\n Aqu\u00ed est\u00e1 el c\u00f3digo para el clasificador que se asienta sobre el espacio latente:<\/p>\n\n\n El proceso de entrenamiento para este clasificador es r\u00e1pido y estable porque el trabajo pesado (extracci\u00f3n de caracter\u00edsticas) ya fue realizado por el autoencoder.<\/p>\n\n\n\n El rendimiento en la tarea de detecci\u00f3n de tumores cerebrales fue robusto. El modelo logr\u00f3 una precisi\u00f3n general del 96%, con un rendimiento muy equilibrado entre la identificaci\u00f3n de casos positivos (Tumor) y casos negativos (Sin Tumor).<\/p>\n\n\n\n Como se muestra en la matriz de confusi\u00f3n, los falsos positivos y falsos negativos son m\u00ednimos (13 y 7 respectivamente de 450 im\u00e1genes de prueba). En un contexto m\u00e9dico, minimizar los falsos negativos es cr\u00edtico, y nuestro recall<\/em> (sensibilidad) para la clase “Tumor” es excelente, situ\u00e1ndose en 0.97.<\/p>\n\n\n\n Los n\u00fameros de precisi\u00f3n son buenos, pero en sanidad, la confianza es mejor. “\u00bfPor qu\u00e9 dijo el modelo que este paciente tiene un tumor?”<\/p>\n\n\n\n Para responder a esto, implement\u00e9 Grad-CAM<\/strong> (Gradient-weighted Class Activation Mapping). Esta t\u00e9cnica nos permite visualizar qu\u00e9 partes de la imagen original llevaron al modelo a tomar su decisi\u00f3n. Calculamos los gradientes de la puntuaci\u00f3n de clasificaci\u00f3n con respecto a los mapas de caracter\u00edsticas convolucionales finales en el codificador.<\/p>\n\n\n\n Aqu\u00ed est\u00e1 la implementaci\u00f3n de la l\u00f3gica Grad-CAM:<\/p>\n\n\nLa Arquitectura: Aprendiendo la Anatom\u00eda<\/strong><\/h4>\n\n\n\n
![\"\"](\"https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/01\/diagrama-autoencoder-1-1.png\")
<\/figure>\n\n\n\ndef<\/span> build_autoencoder<\/span>(input_shape)<\/span>:<\/span>\n input_layer = tf.keras.Input(shape=input_shape)\n\n x = layers.Conv2D(32<\/span>, (3<\/span>, 3<\/span>), activation='relu'<\/span>, padding='same'<\/span>)(input_layer)\n x = layers.MaxPooling2D((2<\/span>, 2<\/span>), padding='same'<\/span>)(x)\n x = layers.Conv2D(64<\/span>, (3<\/span>, 3<\/span>), activation='relu'<\/span>, padding='same'<\/span>)(x)\n x = layers.MaxPooling2D((2<\/span>, 2<\/span>), padding='same'<\/span>)(x)\n x = layers.Conv2D(128<\/span>, (3<\/span>, 3<\/span>), activation='relu'<\/span>, padding='same'<\/span>)(x)\n\n latent_space = layers.MaxPooling2D((2<\/span>, 2<\/span>), padding='same'<\/span>, name=\"latent_space\"<\/span>)(x)\n\n x = layers.Conv2D(128<\/span>, (3<\/span>, 3<\/span>), activation='relu'<\/span>, padding='same'<\/span>)(latent_space)\n x = layers.UpSampling2D((2<\/span>, 2<\/span>))(x)\n x = layers.Conv2D(64<\/span>, (3<\/span>, 3<\/span>), activation='relu'<\/span>, padding='same'<\/span>)(x)\n x = layers.UpSampling2D((2<\/span>, 2<\/span>))(x)\n x = layers.Conv2D(32<\/span>, (3<\/span>, 3<\/span>), activation='relu'<\/span>, padding='same'<\/span>)(x)\n x = layers.UpSampling2D((2<\/span>, 2<\/span>))(x)\n\n reconstructed_output = layers.Conv2D(1<\/span>, (3<\/span>, 3<\/span>), activation='sigmoid'<\/span>, padding='same'<\/span>)(x)\n\n autoencoder_model = models.Model(input_layer, reconstructed_output)\n autoencoder_model.compile(optimizer='adam'<\/span>, loss='binary_crossentropy'<\/span>)\n\n return<\/span> autoencoder_model<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n![\"\"](\"https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/01\/Autoencoder-Train.jpg\")
<\/figure>\n\n\n\n![\"\"](\"https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/01\/Brain-reconstruction.jpg\")
<\/figure>\n\n\n\nDe la Compresi\u00f3n a la Clasificaci\u00f3n<\/strong><\/h4>\n\n\n\n
def<\/span> build_classifier<\/span>(latent_shape)<\/span>:<\/span>\n classifier_model = models.Sequential([\n layers.Flatten(input_shape=latent_shape[1<\/span>:]),\n layers.Dense(256<\/span>, activation='relu'<\/span>),\n layers.Dropout(0.3<\/span>),\n layers.BatchNormalization(),\n layers.Dense(64<\/span>, activation='relu'<\/span>),\n layers.Dense(1<\/span>, activation='sigmoid'<\/span>)\n ])\n \n classifier_model.compile(\n optimizer='adam'<\/span>, \n loss='binary_crossentropy'<\/span>, \n metrics=['accuracy'<\/span>]\n )\n return<\/span> classifier_model<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n![\"\"](\"https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/01\/Clasifier-Train.jpg\")
Los Resultados<\/strong><\/h4>\n\n\n\n
![\"\"](\"https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/01\/tabla-de-resultados.jpg\")
<\/figure>\n\n\n\n![\"\"](\"https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/01\/Matriz-de-confusion.jpg\")
<\/figure>\n\n\n\nAbriendo la “Caja Negra” con Grad-CAM<\/strong><\/h4>\n\n\n\n
def<\/span> generate_grad_cam_heatmap<\/span>(encoder_model, classifier_model, image_array, layer_name)<\/span>:<\/span>\n img_tensor = tf.expand_dims(image_array, axis=0<\/span>)\n\n grad_model = tf.keras.models.Model(\n inputs=encoder_model.input,\n outputs=[encoder_model.get_layer(layer_name).output, encoder_model.output]\n )\n\n with<\/span> tf.GradientTape() as<\/span> tape:\n conv_outputs, latent_features = grad_model(img_tensor)\n prediction = classifier_model(latent_features)\n loss = prediction[:, 0<\/span>]\n\n grads = tape.gradient(loss, conv_outputs)\n pooled_grads = tf.reduce_mean(grads, axis=(0<\/span>, 1<\/span>, 2<\/span>))\n conv_outputs = conv_outputs[0<\/span>]\n \n heatmap = tf.reduce_mean(tf.multiply(pooled_grads, conv_outputs), axis=-1<\/span>)\n heatmap = np.maximum(heatmap, 0<\/span>)\n \n max_heat = np.max(heatmap)\n if<\/span> max_heat == 0<\/span>:\n max_heat = 1e-8<\/span>\n heatmap \/= max_heat\n\n\n return<\/span> heatmap<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
![\"\"](\"https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/01\/mapa-de-calor-1024x576.jpg\")
<\/figure>\n\n\n\n