Convolución y Fundamentos de CNNs

🚧 Limitaciones de las redes densas (MLP)

Hasta ahora, las redes que hemos estudiado —el perceptrón multicapa (MLP)— utilizan capas densas (fully-connected): cada neurona de una capa está conectada a todas las neuronas de la capa anterior. Esto funciona razonablemente bien para datos tabulares de pocas dimensiones, pero se vuelve insostenible cuando trabajamos con imágenes.

Veamos exactamente por qué. Una imagen en escala de grises de tan solo 28 \times 28 píxeles (como las del dataset MNIST) tiene 784 valores de entrada. Una imagen a color de 224 \times 224 píxeles (tamaño estándar en visión por computador) tiene:

Si conectamos esa entrada a una primera capa oculta de tan solo 1024 neuronas, necesitamos:

¡Más de 154 millones de parámetros solo en la primera capa! Y esto para una resolución modesta. Imágenes de alta resolución harían el problema completamente inviable.

Problema 1: no hay noción de estructura espacial

Para alimentar una imagen a un MLP, debemos aplanarla en un vector unidimensional (flatten). Un píxel en la esquina superior izquierda y su vecino inmediato quedan en posiciones consecutivas del vector, pero un píxel de la esquina superior derecha —que está justo al lado si la imagen tiene pocas columnas— puede quedar a cientos de posiciones de distancia.

Al aplanar la imagen, destruimos la información espacial: las relaciones de vecindad, los patrones locales, las texturas y los bordes. El MLP recibe un mar de números sin saber cuáles son vecinos entre sí.

Problema 2: sin invarianza a la traslación

Si un gato aparece en la esquina superior izquierda de una imagen, y luego lo movemos a la esquina inferior derecha, un MLP necesita aprender a reconocerlo en cada posición por separado. Las neuronas de la capa densa que detectaban el gato arriba-izquierda son completamente distintas a las que lo detectarían abajo-derecha.

Esto no solo es ineficiente: en la práctica, requiere muchísimos más datos de entrenamiento para que la red "vea" cada patrón en todas las posiciones posibles.

Problema 3: no se comparten parámetros

En un MLP, cada conexión tiene su propio peso. Si la red aprende a detectar un borde vertical en una zona de la imagen, ese conocimiento no se transfiere a otras zonas. Debe aprender el mismo patrón múltiples veces para distintas posiciones.

Esto resulta en un uso extremadamente ineficiente de los parámetros: la gran mayoría de los pesos acaban codificando patrones redundantes.

Inspiración biológica: el córtex visual

La solución a estos problemas no surgió del vacío. En 1962, los neurocientíficos David Hubel y Torsten Wiesel descubrieron que las neuronas del córtex visual de los gatos responden a patrones locales específicos (bordes con una orientación particular) en regiones limitadas del campo visual, llamadas campos receptivos. Además, distintas neuronas detectan el mismo tipo de patrón en distintas posiciones del campo visual.

Este hallazgo —que les valió el Premio Nobel de Medicina en 1981— inspiró directamente el diseño de las redes convolucionales: filtros locales (campos receptivos pequeños) que comparten pesos (el mismo detector en todas las posiciones). El primer modelo computacional basado en estas ideas fue el Neocognitron de Kunihiko Fukushima (1980), precursor directo de las CNNs modernas.

💡 ¿Qué necesitamos?

Los tres problemas anteriores apuntan a la misma solución: necesitamos una arquitectura que:

Estos tres principios son exactamente los que implementa la operación de convolución, y las redes que la utilizan: las redes neuronales convolucionales (CNN).

🔬 ¿Qué es la convolución?

La convolución es una operación matemática fundamental que, en esencia, mide cuánto se parece una parte de la señal a un patrón dado. En el contexto de redes neuronales, la señal es la imagen (o el mapa de activación de una capa previa) y el patrón es un filtro o kernel: una matriz pequeña de pesos.

Para entender la convolución de forma intuitiva, imagina que deslizas una lupa muy pequeña sobre una imagen. En cada posición, la lupa compara la zona que ve con un patrón de referencia (el kernel). Si la zona se parece mucho al patrón, devuelve un valor alto; si no se parece, devuelve un valor cercano a cero. El resultado es un nuevo mapa que indica dónde y cuánto aparece ese patrón en la imagen. Lo más poderoso: en una CNN, la red aprende automáticamente qué patrones (kernels) buscar durante el entrenamiento.

Convolución continua

En matemáticas, la convolución de dos funciones continuas f y g se define como:

La idea: deslizamos la función g sobre f, la invertimos (flip), y en cada posición calculamos la integral del producto. El resultado nos dice cuánto "se superponen" ambas funciones en cada punto.

Convolución discreta 1D

En la práctica, trabajamos con señales discretas (secuencias de valores). La convolución discreta es:

Aquí, g es nuestro kernel (un vector de pocos valores) que se desliza sobre la señal f.

Convolución 2D (para imágenes)

Para imágenes, usamos la convolución 2D. Dado un input \mathbf{I} (la imagen) y un kernel \mathbf{K} de tamaño k_h \times k_w, el valor de salida en la posición (i, j) es:

El kernel se coloca sobre una región de la imagen, se multiplican los valores elemento a elemento, y se suman todos los productos. El resultado es un solo número que indica cuánto se activa el filtro en esa posición. Luego, el kernel se desplaza a la siguiente posición y se repite.

Ejemplo paso a paso

Consideremos un input de 5 \times 5 y un kernel de 3 \times 3:

Es importante recalcar que la convolución resuelve de un plumazo los tres problemas del MLP que vimos antes. Al ser una operación local (el kernel solo mira unos pocos píxeles a la vez), no necesitamos conectar cada neurona con toda la imagen. Los pesos del kernel se comparten en todas las posiciones, reduciendo los parámetros de millones a solo k \times k por filtro. Y como el mismo filtro se aplica en todas partes, la red detecta un patrón da igual dónde aparezca en la imagen (invarianza a la traslación).

🧪 Explorador interactivo de convolución 2D

Visualiza paso a paso cómo un kernel se desliza sobre una imagen, multiplicando y sumando valores. Puedes elegir entre varios filtros predefinidos (detección de bordes, desenfoque, realce) o editar los valores del kernel manualmente.

📐 Tamaño del kernel

El tamaño del kernel (o filtro) determina cuántos píxeles vecinos considera la convolución en cada paso. Es el hiperparámetro más básico y uno de los más importantes.

Los kernels suelen ser cuadrados y de tamaño impar (3, 5, 7…) para que tengan un píxel central bien definido, lo que facilita el padding simétrico.

🔲 Padding (relleno)

Al aplicar un kernel de k \times k sobre un input de n \times n, el output es más pequeño: (n - k + 1) \times (n - k + 1). Esto ocurre porque el kernel no puede "salirse" del borde de la imagen.

El padding consiste en añadir valores (típicamente ceros) alrededor del input para controlar el tamaño de la salida. Puede parecer un detalle técnico menor, pero tiene un impacto significativo en el diseño de redes profundas: sin padding, cada capa convolucional reduce las dimensiones espaciales, lo que limita cuántas capas podemos apilar antes de que la resolución desaparezca. Con padding "same", podemos apilar tantas capas convolutionales como queramos sin perder resolución, y dejar la reducción de tamaño para las capas de pooling o strides.

👣 Stride (paso)

El stride indica cuántos píxeles se desplaza el kernel entre una posición y la siguiente. Con stride 1, el kernel se mueve un píxel a la vez. Con stride 2, salta de dos en dos, reduciendo la salida a la mitad.

Donde n_{\text{in}} es el tamaño del input, p es el padding, k es el tamaño del kernel, y s es el stride.

• Stride = 1: resolución completa. El output tiene casi el mismo tamaño que el input (depende del padding).
• Stride = 2: reduce la resolución a la mitad. Se usa como alternativa al pooling para hacer downsampling.
• Stride > 2: poco frecuente; reduce la resolución agresivamente y puede perder información.

🕳️ Dilation (dilatación)

La dilatación (o atrous convolution) introduce espacios entre los elementos del kernel. Un kernel 3×3 con dilation = 2 cubre una región efectiva de 5×5, pero solo usa 9 parámetros.

Donde d es el factor de dilatación. Con d=1 (sin dilatación), el kernel es el estándar.

La dilatación es especialmente útil en segmentación semántica, donde necesitamos un campo receptivo grande sin perder resolución (sin pooling). Arquitecturas como DeepLab la utilizan extensivamente con sus módulos de Atrous Spatial Pyramid Pooling (ASPP), que aplican múltiples convoluciones dilatadas con distintos factores en paralelo para capturar contexto a varias escalas simultáneamente. La convolución dilatada fue introducida originalmente por Yu & Koltun (2016) y se usa ampliamente en tareas que requieren predicciones densas (segmentación, detección).

En la práctica, un error de diseño frecuente es usar dilataciones crecientes sin cuidado, lo que puede provocar "gridding artifacts": la red solo muestrea ciertos píxeles dejando huecos regulares. Esto se mitiga alternando convoluciones dilatadas con convoluciones estándar o usando factores de dilatación que no sean múltiplos entre sí. Para más detalles sobre segmentación, consulta el submódulo de Segmentación semántica.

📏 Fórmula general del tamaño de salida

La fórmula completa que determina el tamaño del output de una convolución 2D es:

Donde:

• n_{\text{in}} — tamaño del input (alto o ancho)
• k — tamaño del kernel
• p — padding
• s — stride
• d — dilation (por defecto 1)

🧱 La capa convolucional

Una capa convolucional aplica múltiples filtros sobre su input. Cada filtro produce un mapa de características (feature map). Si la capa tiene C_{\text{out}} filtros, produce C_{\text{out}} feature maps apilados, formando un volumen 3D.

Es una idea elegante: en lugar de tener un único filtro, usamos decenas o cientos de filtros distintos en cada capa. Cada uno aprende a detectar un patrón diferente (un tipo de borde, una textura, un gradiente de color…), y los resultados se apilan como capas de un volumen. Así, la salida de una capa convolucional no es una imagen 2D, sino un tensor 3D que codifica múltiples características del input en cada posición espacial.

Donde \mathbf{X}_i es el canal i del input, \mathbf{K}_{i,j} es el kernel que conecta el canal i del input con el feature map j del output, b_j es el bias del filtro j, y \sigma es la función de activación (típicamente ReLU).

Canales y feature maps

En la primera capa, los canales de entrada son los canales de color de la imagen (1 para escala de grises, 3 para RGB). Cada filtro de la capa tiene un kernel separado para cada canal, y el resultado se suma.

A partir de la segunda capa, los "canales" ya no son R, G, B, sino los feature maps de la capa anterior: mapas de bordes detectados, texturas, patrones, etc. Las capas posteriores combinan estos mapas para detectar patrones de nivel más alto. Esta transición es sutil pero fundamental: cada capa opera sobre las representaciones aprendidas por la capa anterior, no sobre la imagen original. Esto permite construir una jerarquía de conceptos cada vez más abstractos.

🔽 Capas de pooling

Las capas de pooling reducen las dimensiones espaciales de los feature maps, manteniendo las características más importantes. Esto aporta:

• Reducción de cómputo: menos píxeles → menos operaciones en capas posteriores.
• Invarianza local: pequeños desplazamientos del patrón no cambian el resultado.
• Control de overfitting: menos parámetros en las capas siguientes.

El pooling es una operación de submuestreo (downsampling) que reduce la resolución espacial pero no modifica el número de canales. Si la entrada tiene 64 feature maps, la salida también tendrá 64 feature maps, pero cada uno será de menor tamaño. Es importante entender que el pooling no tiene parámetros entrenables: es una operación fija y determinista.

Max Pooling

El max pooling toma el valor máximo de cada ventana. Es el tipo de pooling más utilizado porque preserva las activaciones más fuertes (las features más "presentes"):

Average Pooling

El average pooling calcula la media de cada ventana. Es menos agresivo que el max pooling y se usa principalmente como Global Average Pooling (GAP) al final de la red, reduciendo cada feature map a un solo número:

🏗️ Arquitectura típica de una CNN

Una CNN típica sigue un patrón que se repite desde las primeras arquitecturas (LeNet-5, 1998) hasta las modernas:

Conforme avanzamos por la red, las dimensiones espaciales (H, W) disminuyen y el número de canales (C) aumenta. Es decir, pasamos de información "amplia y superficial" (muchos píxeles, pocos canales) a "compacta y profunda" (pocos píxeles, muchos canales). Este patrón de diseño —conocido informalmente como "pirámide invertida"— es una de las ideas más robustas de la arquitectura de CNNs y aparece en prácticamente todas las redes modernas, desde VGG hasta EfficientNet:

Batch Normalization

En la práctica, casi todas las CNNs modernas incluyen una capa de Batch Normalization (Ioffe & Szegedy, 2015) después de cada convolución (y antes de la activación). BatchNorm normaliza las activaciones de cada mini-batch para que tengan media cero y varianza unitaria, y luego aplica una transformación afín aprendida:

Donde \mu_B y \sigma_B^2 son la media y varianza del mini-batch, y \gamma, \beta son parámetros entrenables de escala y desplazamiento. BatchNorm aporta tres beneficios principales: estabiliza el entrenamiento (permite usar learning rates más altos), actúa como regularizador (reduce la necesidad de Dropout en muchos casos), y acelera la convergencia. El patrón típico de un bloque convolucional moderno es: Conv → BatchNorm → ReLU.

⚙️ Parámetros entrenables en una CNN

Una de las mayores ventajas de las CNNs es su eficiencia en parámetros. Mientras que en una red densa cada conexión tiene su propio peso, en una CNN los pesos del kernel se comparten (weight sharing) a lo largo de toda la imagen. Esta idea, que parece simple, tiene implicaciones profundas: reduce los parámetros en varios órdenes de magnitud, introduce una forma de regularización implícita, y —lo más elegante— codifica la suposición de que los patrones visuales son estacionarios: un borde vertical tiene la misma apariencia independientemente de dónde aparezca en la imagen.

Weight sharing: compartir pesos

Cuando un filtro de 3 \times 3 se aplica sobre una imagen de 224 \times 224, los mismos 9 pesos se usan en cada una de las 222 \times 222 = 49{,}284 posiciones. Esto implica:

• Muchas menos variables a optimizar → entrenamiento más rápido y menos datos necesarios.
• El mismo detector se aplica en toda la imagen → invarianza a traslación.
• Generaliza mejor → un detector de bordes aprendido funciona en cualquier posición.

¿Cuántos parámetros tiene una capa Conv2D?

Cada capa convolucional tiene kernels + biases:

Es decir: cada filtro tiene k \times k \times C_\text{in} pesos (un kernel por cada canal de entrada), y hay C_\text{out} filtros, cada uno con su bias.

Ejemplo: conteo completo de una CNN

Consideremos una CNN sencilla para clasificar imágenes de 32×32×3 (como CIFAR-10):

Compáralo con un MLP equivalente: la misma imagen aplanada (32 \times 32 \times 3 = 3{,}072 inputs) con capas de 256, 128, 10 neuronas tendría más de 820.000 parámetros, ¡casi 9 veces más!

¿Y las capas de pooling?

Ejemplo en código

import torch.nn as nn

class SimpleCNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 32, kernel_size=3, padding=1),   # 896 params
            nn.ReLU(),
            nn.Conv2d(32, 64, kernel_size=3, padding=1),  # 18.496 params
            nn.ReLU(),
            nn.MaxPool2d(2),                               # 0 params
            nn.Conv2d(64, 128, kernel_size=3, padding=1), # 73.856 params
            nn.ReLU(),
            nn.AdaptiveAvgPool2d(1),                       # GAP, 0 params
        )
        self.classifier = nn.Linear(128, 10)               # 1.290 params

    def forward(self, x):
        x = self.features(x)
        x = x.view(x.size(0), -1)
        return self.classifier(x)

model = SimpleCNN()
total = sum(p.numel() for p in model.parameters())
print(f"Total parámetros: {total:,}")  # → 94,538

import tensorflow as tf

model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, 3, padding='same', activation='relu',
                           input_shape=(32, 32, 3)),     # 896
    tf.keras.layers.Conv2D(64, 3, padding='same', activation='relu'),  # 18.496
    tf.keras.layers.MaxPooling2D(2),                      # 0
    tf.keras.layers.Conv2D(128, 3, padding='same', activation='relu'), # 73.856
    tf.keras.layers.GlobalAveragePooling2D(),             # 0
    tf.keras.layers.Dense(10),                            # 1.290
])

model.summary()
# Total params: 94,538

🔍 Extracción de características

La gran revolución de las CNNs es que aprenden automáticamente qué features extraer. Antes de las CNNs, los ingenieros diseñaban manualmente descriptores como SIFT, HOG o LBP —un proceso artesanal, costoso y que requería conocimiento experto del dominio. Las CNNs reemplazan ese proceso aprendiendo filtros óptimos directamente de los datos, lo que explica en gran parte su superioridad en tareas de visión. El momento clave fue AlexNet (Krizhevsky et al., 2012), que ganó la competición ImageNet con un margen enorme sobre los métodos basados en descriptores manuales, demostrando definitivamente la superioridad del aprendizaje automático de características.

Aprendizaje jerárquico

Las capas de una CNN forman una jerarquía de representaciones. Cada capa construye sobre las features de la anterior, creando detectores progresivamente más complejos y abstractos:

¿Por qué funciona la jerarquía?

Cada capa convolucional tiene un campo receptivo (receptive field) limitado. Un kernel de 3×3 solo "ve" 3×3 píxeles del input. Pero al apilar capas, el campo receptivo efectivo crece:

Con L=1 capa: campo de 3×3 → detecta bordes.
Con L=3 capas: campo de 7×7 → detecta texturas.
Con L=10 capas: campo de 21×21 → detecta objetos completos.

🗺️ Visualización de feature maps

Podemos visualizar qué "ve" cada capa extrayendo las activaciones intermedias (feature maps) y mostrándolas como imágenes en escala de grises. Valores altos (claros) indican que el filtro ha detectado el patrón en esa posición.

Esta técnica es muy útil para depurar modelos: si los feature maps de las primeras capas no muestran bordes ni texturas reconocibles, algo va mal en el entrenamiento. También permite verificar que la red se enfoca en las partes correctas de la imagen para hacer su predicción, lo cual es especialmente importante en aplicaciones críticas como diagnóstico médico o conducción autónoma.

import torch
import torchvision.models as models
import matplotlib.pyplot as plt

# Cargar modelo preentrenado
model = models.vgg16(pretrained=True)
model.eval()

# Hook para capturar activaciones intermedias
activations = {}
def get_activation(name):
    def hook(model, input, output):
        activations[name] = output.detach()
    return hook

# Registrar hooks en las primeras capas conv
model.features[0].register_forward_hook(get_activation('conv1'))
model.features[5].register_forward_hook(get_activation('conv3'))
model.features[10].register_forward_hook(get_activation('conv6'))

# Forward pass con una imagen
img_tensor = torch.randn(1, 3, 224, 224)  # imagen de ejemplo
_ = model(img_tensor)

# Visualizar primeros 16 feature maps de conv1
fig, axes = plt.subplots(4, 4, figsize=(10, 10))
for i, ax in enumerate(axes.flat):
    ax.imshow(activations['conv1'][0, i].numpy(), cmap='viridis')
    ax.set_title(f'Filtro {i}')
    ax.axis('off')
plt.suptitle('Feature maps de Conv1')
plt.tight_layout()
plt.show()

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

# Cargar modelo preentrenado
base_model = tf.keras.applications.VGG16(weights='imagenet')

# Crear modelo que devuelva las activaciones intermedias
layer_outputs = [layer.output for layer in base_model.layers[:8]]
activation_model = tf.keras.Model(
    inputs=base_model.input,
    outputs=layer_outputs
)

# Forward pass
img = np.random.rand(1, 224, 224, 3).astype(np.float32)
activations = activation_model.predict(img)

# Visualizar feature maps de la primera capa conv
first_layer_activation = activations[1]  # Después de Conv1
fig, axes = plt.subplots(4, 4, figsize=(10, 10))
for i, ax in enumerate(axes.flat):
    ax.imshow(first_layer_activation[0, :, :, i], cmap='viridis')
    ax.set_title(f'Filtro {i}')
    ax.axis('off')
plt.suptitle('Feature maps de la primera capa Conv2D')
plt.tight_layout()
plt.show()

🧠 Interpretabilidad de CNNs

Las CNNs suelen considerarse "cajas negras", pero existen técnicas para entender qué ha aprendido cada filtro y por qué la red toma una decisión. Esto es crucial tanto para depurar modelos como para aplicaciones donde la explicabilidad es necesaria (medicina, conducción autónoma…). La interpretabilidad no es un lujo académico: regulaciones como la GDPR europea incluyen un "derecho a la explicación" que exige que las decisiones automatizadas sean comprensibles. Además, un modelo interpretable es más fácil de depurar, mejorar y mantener en producción.

Visualización de filtros aprendidos

Los filtros (kernels) de las primeras capas se pueden visualizar directamente como pequeñas imágenes. En redes entrenadas en ImageNet, los filtros de la primera capa típicamente aprenden:

• Detectores de bordes en distintas orientaciones (horizontales, verticales, diagonales).
• Detectores de color que responden a combinaciones específicas de canales RGB.
• Patrones de frecuencia similares a filtros Gabor (usados en visión clásica).

🔥 Grad-CAM: mapas de calor de decisión

Grad-CAM (Gradient-weighted Class Activation Mapping) es la técnica más popular para entender dónde mira la red al hacer una predicción. Produce un mapa de calor que resalta las regiones de la imagen más relevantes para una clase concreta. Fue propuesto por Selvaraju et al. (2017) y se ha convertido en el estándar de facto para explicar decisiones de CNNs gracias a su sencillez y versatilidad: funciona con cualquier arquitectura CNN sin necesidad de modificar la red o reentrenarla.

¿Cómo funciona?

1. Se realiza un forward pass con la imagen y se obtiene la predicción para la clase c.
2. Se calcula el gradiente de la salida de la clase y^c respecto a los feature maps \mathbf{A}^k de la última capa convolucional.
3. Se calcula la importancia de cada feature map k mediante global average pooling del gradiente:

4. El mapa de calor final es la combinación lineal ponderada de los feature maps, seguida de ReLU (solo nos interesan las activaciones positivas):

El resultado se redimensiona al tamaño de la imagen original y se superpone como un mapa de calor, mostrando qué regiones "activaron" la decisión de la red.

import torch
import torch.nn.functional as F
import torchvision.models as models
import matplotlib.pyplot as plt
import numpy as np

model = models.resnet50(pretrained=True)
model.eval()

# Capturar feature maps y gradientes de la última capa conv
feature_maps = {}
gradients = {}

def forward_hook(module, input, output):
    feature_maps['last_conv'] = output

def backward_hook(module, grad_input, grad_output):
    gradients['last_conv'] = grad_output[0]

# Registrar hooks en layer4 (última capa conv de ResNet)
model.layer4[-1].register_forward_hook(forward_hook)
model.layer4[-1].register_full_backward_hook(backward_hook)

# Forward pass
img_tensor = torch.randn(1, 3, 224, 224)  # Tu imagen preprocesada
output = model(img_tensor)
class_idx = output.argmax(dim=1).item()

# Backward pass para la clase predicha
model.zero_grad()
output[0, class_idx].backward()

# Calcular Grad-CAM
grads = gradients['last_conv']           # (1, 2048, 7, 7)
fmaps = feature_maps['last_conv']        # (1, 2048, 7, 7)
weights = grads.mean(dim=[2, 3], keepdim=True)  # α_k = GAP de gradientes

cam = (weights * fmaps).sum(dim=1, keepdim=True)  # Combinación ponderada
cam = F.relu(cam)                                    # Solo positivos
cam = F.interpolate(cam, size=(224, 224), mode='bilinear', align_corners=False)
cam = cam.squeeze().detach().numpy()
cam = (cam - cam.min()) / (cam.max() - cam.min() + 1e-8)  # Normalizar [0,1]

# Visualizar
plt.imshow(img_tensor.squeeze().permute(1, 2, 0).numpy() * 0.5 + 0.5)
plt.imshow(cam, alpha=0.5, cmap='jet')
plt.title(f'Grad-CAM para clase {class_idx}')
plt.axis('off')
plt.show()

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

model = tf.keras.applications.ResNet50(weights='imagenet')
img = tf.random.normal((1, 224, 224, 3))

# Modelo que devuelve la última capa conv + predicción
last_conv_layer = model.get_layer('conv5_block3_out')
grad_model = tf.keras.Model(
    inputs=model.input,
    outputs=[last_conv_layer.output, model.output]
)

# Forward + gradientes
with tf.GradientTape() as tape:
    conv_output, predictions = grad_model(img)
    class_idx = tf.argmax(predictions[0])
    loss = predictions[:, class_idx]

# Gradientes respecto a los feature maps
grads = tape.gradient(loss, conv_output)      # (1, 7, 7, 2048)
weights = tf.reduce_mean(grads, axis=[1, 2])  # α_k: (1, 2048)

# Mapa Grad-CAM
cam = tf.reduce_sum(
    conv_output * weights[:, tf.newaxis, tf.newaxis, :],
    axis=-1
)[0]  # (7, 7)
cam = tf.nn.relu(cam)
cam = tf.image.resize(cam[..., tf.newaxis], (224, 224))[..., 0]
cam = (cam - tf.reduce_min(cam)) / (tf.reduce_max(cam) - tf.reduce_min(cam) + 1e-8)

plt.imshow(img[0] * 0.5 + 0.5)
plt.imshow(cam.numpy(), alpha=0.5, cmap='jet')
plt.title(f'Grad-CAM para clase {class_idx.numpy()}')
plt.axis('off')
plt.show()

🎯 Saliency maps y otras técnicas

Además de Grad-CAM, existen otras técnicas de interpretabilidad:

Saliency Maps (mapas de saliencia)

Un saliency map calcula el gradiente de la salida respecto a los píxeles de entrada directamente. La idea fue introducida por Simonyan et al. (2013) y es la forma más sencilla de interpretar una CNN:

Los píxeles con gradientes grandes son los más influyentes en la decisión. A diferencia de Grad-CAM (que da mapas suaves y gruesos), los saliency maps son de resolución completa pero más ruidosos. Para reducir el ruido, se puede utilizar SmoothGrad (Smilkov et al., 2017), que promedia los saliency maps de múltiples versiones ligeramente perturbadas de la imagen, produciendo mapas mucho más nítidos y fiables.

Comparación de técnicas