Los Mapas de Características (Feature Maps) son representaciones de datos producidas por las capas internas de una red neuronal.

En las Redes Neuronales Convolucionales (CNN), estos mapas contienen las respuestas de filtros que procesan una imagen, una señal u otro conjunto de datos estructurados.

Por ejemplo, cuando una CNN recibe una fotografía, sus primeras capas pueden producir mapas relacionados con contrastes, bordes, colores y texturas.

Las capas posteriores transforman esas representaciones en otras que pueden responder a patrones visuales más complejos.

Estos mapas son una parte fundamental del funcionamiento de las CNN porque permiten transmitir información de una capa a otra.

También resultan útiles para investigar qué está calculando un modelo y detectar determinados problemas durante el entrenamiento.

En Deep Learning, los términos Feature Map y Activation Map suelen utilizarse de manera cercana.

Sin embargo, existe una distinción conceptual que conviene comprender.

Un Feature Map es una representación de características producida por una operación o capa.

Un Activation Map se refiere especialmente a los valores de activación producidos ante una entrada específica.

Dependiendo del artículo, framework o contexto, ambos términos pueden designar el mismo tensor.

Por ejemplo, la salida de una capa Conv2D después de aplicar ReLU puede describirse tanto como Feature Map como Activation Map.

Pero estos mapas no son lo mismo que los kernels de la capa.

Los kernels son conjuntos de pesos entrenables.

Los mapas son las respuestas obtenidas al utilizar esos pesos sobre datos.

También debemos distinguir los mapas de activación de los mapas de atribución.

Un método como Grad-CAM calcula una visualización relacionada con la contribución de determinadas características a una puntuación concreta del modelo.

Por tanto, un mapa de activación no proporciona automáticamente una explicación de por qué se predijo una categoría.

Comprender estas diferencias es importante cuando desarrollamos sistemas de visión artificial o queremos interpretar el comportamiento de una red neuronal.

En aplicaciones de Visibilidad en Inteligencia Artificial (AI Visibility), los mapas de características pueden utilizarse para analizar cómo un modelo visual procesa fotografías comerciales, logotipos, capturas de sitios web y otros activos de marca.

También pueden ayudar a investigar errores de clasificación y evaluar si un modelo depende de determinados patrones visuales.

Sin embargo, no deben confundirse con las métricas que cuantifican menciones o recomendaciones de marcas en asistentes como ChatGPT, Gemini y Claude.

En esta entrada estudiaremos sus fundamentos matemáticos, las diferencias entre mapas de características y mapas de activación, las dimensiones de los tensores, los mecanismos de visualización, los Forward Hooks, Grad-CAM y ejemplos completos utilizando NumPy, PyTorch y Keras.

¿Qué es un Mapa de Características?

Un Mapa de Características es una representación intermedia calculada por una capa neuronal a partir de los datos que recibe.

En una CNN bidimensional, normalmente consiste en uno o varios canales distribuidos sobre una cuadrícula espacial.

Definición breve: Un Mapa de Características (Feature Map) es una representación producida por una capa de una red neuronal que contiene respuestas a patrones aprendidos o definidos mediante sus operaciones, y que se utiliza como entrada para etapas posteriores del modelo.

En una CNN, los mapas de características suelen adoptar la forma de tensores con dimensiones de lote, canales, altura y anchura.

Por ejemplo:

[8, 32, 64, 64]

En PyTorch, esta representación corresponde a:

• 8 imágenes.
• 32 canales de características.
• 64 posiciones de altura.
• 64 posiciones de anchura.

Cada canal contiene valores calculados a partir de las entradas y los parámetros de la capa.

¿Qué es un Mapa de Activación?

Un Mapa de Activación (Activation Map) es una representación de las respuestas de una capa o conjunto de neuronas ante una entrada específica.

Ejemplo

Una imagen contiene un objeto con bordes verticales.

Un filtro sensible a determinadas transiciones puede producir respuestas elevadas cerca de esos bordes.

La distribución espacial de dichas respuestas constituye un mapa de activación.

¿Es equivalente a Feature Map?

En numerosas explicaciones de CNN, sí se emplean como términos intercambiables.

No obstante, en una descripción técnica puede especificarse si estamos observando:

• La salida de una convolución antes de la activación.
• La salida después de ReLU.
• La salida después de BatchNorm.
• La salida de un bloque residual.
• La representación de una etapa completa.

Estas representaciones pueden tener la misma forma, pero valores diferentes.

Feature Maps frente a Activation Maps

¿Por qué importa la distinción?

Porque los pesos de un filtro permanecen constantes durante una inferencia concreta, mientras que sus activaciones cambian con la entrada.

Además, un mapa de características no indica necesariamente qué regiones causaron una clasificación específica.

¿Cómo se generan los Mapas de Características?

Consideremos una convolución bidimensional.

La entrada contiene una imagen:

X

La capa aplica diferentes filtros:

W₁, W₂, …, Wₖ

Cada filtro produce un canal de salida.

Fórmula simplificada

Zₖ(i,j) = bₖ + Σc Σu Σv Wₖ,c(u,v) Xc(i+u,j+v)

Donde:

• Zₖ representa el canal de salida k.
• bₖ es el sesgo correspondiente.
• Wₖ,c contiene los pesos del filtro.
• Xc es el canal de entrada.
• i y j representan posiciones espaciales.

Esta fórmula representa una correlación cruzada sin detallar Stride, Padding ni Dilation.

Posteriormente puede aplicarse una función de activación:

Aₖ(i,j) = φ(Zₖ(i,j))

Por ejemplo:

Aₖ(i,j) = max(0, Zₖ(i,j))

cuando utilizamos ReLU.

¿Qué significa?

Cada posición del mapa final contiene una respuesta calculada para una región determinada de la entrada.

Ejemplo matemático de un Feature Map

Supongamos una imagen en escala de grises:

1  2  3
4  5  6
7  8  9

Utilizamos el kernel:

 1   0
 0  -1

Aplicamos correlación cruzada con Stride 1 y sin Padding.

Primera ventana

1  2
4  5

Resultado:

1 − 5 = −4

Segunda ventana

2  3
5  6

Resultado:

2 − 6 = −4

Repitiendo la operación:

-4  -4
-4  -4

Este es el mapa anterior a la función de activación.

¿Qué ocurre con ReLU?

ReLU transforma valores negativos en cero.

El resultado será:

0  0
0  0

¿Qué demuestra?

El mismo filtro produce un mapa antes de la activación y otro después de aplicar ReLU.

Ambos contienen información diferente.

Ejemplo 1 — Generar Feature Maps con NumPy

Vamos a implementar un pequeño sistema de convolución para visualizar las respuestas de varios kernels.

import numpy as np
import matplotlib.pyplot as plt
# Imagen sintética
image = np.zeros(
    (64, 64),
    dtype=np.float64
)
image[12:52, 20:44] = 1.0
# Filtros manuales
sobel_x = np.array([
    [-1, 0, 1],
    [-2, 0, 2],
    [-1, 0, 1]
], dtype=float)
sobel_y = np.array([
    [-1, -2, -1],
    [0, 0, 0],
    [1, 2, 1]
], dtype=float)
laplacian = np.array([
    [0, 1, 0],
    [1, -4, 1],
    [0, 1, 0]
], dtype=float)
def correlate2d(image, kernel):
    h, w = image.shape
    kh, kw = kernel.shape
    out_h = h - kh + 1
    out_w = w - kw + 1
    result = np.zeros(
        (out_h, out_w),
        dtype=float
    )
    for i in range(out_h):
        for j in range(out_w):
            region = image[
                i:i + kh,
                j:j + kw
            ]
            result[i, j] = np.sum(
                region * kernel
            )
    return result
maps = [
    image,
    correlate2d(image, sobel_x),
    correlate2d(image, sobel_y),
    correlate2d(image, laplacian)
]
titles = [
    "Imagen original",
    "Sobel X",
    "Sobel Y",
    "Laplaciano"
]
fig, axes = plt.subplots(
    1, 4,
    figsize=(14, 4)
)
for ax, feature_map, title in zip(
    axes,
    maps,
    titles
):
    ax.imshow(
        feature_map,
        cmap="gray"
    )
    ax.set_title(title)
    ax.axis("off")
plt.tight_layout()
plt.show()

¿Qué demuestra?

Diferentes kernels producen mapas de características distintos a partir de la misma imagen.

Cada mapa responde a una propiedad diferente de la entrada.

¿Son Feature Maps aprendidos?

No.

Utilizamos filtros manuales para ilustrar la operación.

En una CNN entrenable, los coeficientes normalmente se ajustan durante el aprendizaje.

¿Qué dimensiones tiene un Feature Map?

En una CNN, las dimensiones dependen de:

• Número de imágenes.
• Número de canales de salida.
• Altura.
• Anchura.
• Kernel Size.
• Stride.
• Padding.
• Dilation.

Formato PyTorch

[N, C, H, W]

Formato Keras habitual

[N, H, W, C]

Ejemplo

Tenemos ocho imágenes RGB de 64 × 64.

Una Conv2D genera 32 filtros de salida.

Con kernel 3 × 3, Stride 1 y Padding 1:

En PyTorch:

[8, 32, 64, 64]

En Keras con channels_last:

[8, 64, 64, 32]

¿Por qué importa?

Porque al visualizar mapas debemos seleccionar correctamente las dimensiones del canal y de la observación.

¿Qué significa el número de canales?

Cada canal representa una componente de la representación calculada por la capa.

En una convolución estándar, cada filtro de salida produce un canal.

Ejemplo

Una capa tiene:

64 filtros de salida

Produce:

64 canales de características

¿Significa que identifica 64 objetos diferentes?

No.

Los canales no tienen por qué corresponder a conceptos independientes o identificables.

Un objeto puede representarse mediante numerosos canales.

Un mismo canal también puede responder a diferentes patrones.

¿Por qué es importante?

Porque los Feature Maps contienen representaciones distribuidas.

No debemos interpretar cada canal como una categoría semántica fija sin evidencia adicional.

¿Por qué cambian los mapas entre capas?

Cada capa transforma las características que recibe.

Primera capa

Puede responder a patrones locales sencillos.

Capas intermedias

Pueden combinar respuestas anteriores para formar características más complejas.

Capas profundas

Pueden representar combinaciones relacionadas con estructuras de objetos y propiedades relevantes para la tarea.

¿Siempre existe una jerarquía visual interpretable?

No necesariamente.

Las representaciones dependen de la arquitectura, el entrenamiento y los datos.

La idea de una jerarquía progresiva es útil, pero no permite asignar un significado universal a cada capa.

Feature Maps tempranos frente a profundos

Precaución

No todas las CNN siguen exactamente esta organización.

Existen arquitecturas que conservan resoluciones altas, utilizan rutas multiescala o modifican la estructura de canales.

¿Cómo influyen Stride y Padding?

El tamaño de los mapas depende de la configuración de cada convolución.

Para una dimensión:

Lout = ⌊(Lin + 2P − D(K − 1) − 1)/S + 1⌋

Donde:

• Lin es el tamaño de entrada.
• P es Padding simétrico.
• D es Dilation.
• K es Kernel Size.
• S es Stride.

Ejemplo

Entrada:

64 × 64

Kernel:

3 × 3

Stride:

2

Padding:

1

Dilation:

1

Salida:

32 × 32

¿Qué ocurre con los canales?

El número de canales depende de los filtros de salida, no directamente de Stride.

¿Qué relación existe con Pooling?

Pooling transforma mapas de características mediante operaciones de agregación.

Max Pooling

Selecciona el valor máximo de cada región.

Average Pooling

Calcula el promedio de una región.

Global Average Pooling

Resume cada canal espacial completo mediante una media.

¿Qué ocurre con los Feature Maps?

Sus dimensiones pueden reducirse.

¿Se pierde información?

Sí, la agregación puede descartar detalles espaciales.

Por eso debe diseñarse de acuerdo con la tarea.

En segmentación, por ejemplo, puede ser necesario recuperar o conservar información espacial mediante conexiones adicionales.

¿Qué es Receptive Field?

El Campo Receptivo (Receptive Field) representa la región de entrada que puede influir en una unidad concreta de un Feature Map.

Ejemplo

Una Conv2D de 3 × 3 utiliza una vecindad espacial local.

Si varias capas se encadenan, una unidad posterior puede depender de una región más amplia de la imagen original.

¿Por qué importa?

Porque ayuda a explicar cuánta información contextual puede incorporar una respuesta.

¿Campo receptivo grande equivale a comprensión global?

No.

Un campo receptivo teórico amplio no garantiza que todas las posiciones influyan de manera significativa en la respuesta.

¿Cómo visualizar Feature Maps con PyTorch?

PyTorch permite obtener activaciones mediante distintas estrategias.

Podemos:

• Acceder directamente a salidas intermedias en forward.
• Separar partes de un modelo.
• Registrar Forward Hooks.
• Construir extractores de características.
• Utilizar herramientas de visualización.

Para comenzar utilizaremos una CNN pequeña.

Ejemplo 2 — Visualizar Feature Maps de una CNN en PyTorch

Instalación

pip install torch numpy matplotlib

Código completo

import torch
import torch.nn as nn
import matplotlib.pyplot as plt
torch.manual_seed(42)
# CNN de ejemplo
model = nn.Sequential(
    nn.Conv2d(
        1, 8,
        kernel_size=3,
        padding=1
    ),
    nn.ReLU(),
    nn.Conv2d(
        8, 16,
        kernel_size=3,
        padding=1
    ),
    nn.ReLU()
)
# Imagen sintética
image = torch.zeros(
    1, 1, 64, 64
)
image[:, :, 16:48, 24:40] = 1.0
model.eval()
with torch.inference_mode():
    first_conv = model[0](image)
    first_activation = model[1](
        first_conv
    )
    second_conv = model[2](
        first_activation
    )
    second_activation = model[3](
        second_conv
    )
print(
    "Primera capa:",
    first_activation.shape
)
print(
    "Segunda capa:",
    second_activation.shape
)
maps = (
    first_activation[0]
    .detach()
    .cpu()
    .numpy()
)
fig, axes = plt.subplots(
    2, 4,
    figsize=(10, 5)
)
for i, ax in enumerate(axes.flat):
    ax.imshow(
        maps[i],
        cmap="viridis"
    )
    ax.set_title(f"Canal {i}")
    ax.axis("off")
plt.tight_layout()
plt.show()

¿Qué demuestra?

La primera convolución genera ocho canales de características.

La segunda genera dieciséis.

Podemos extraer cada representación y visualizarla por separado.

¿Son mapas de un modelo entrenado?

No.

Los pesos están inicializados aleatoriamente.

Por tanto, el ejemplo explica la mecánica de extracción y visualización, no el significado de características aprendidas.

¿Qué es un Forward Hook?

Un Forward Hook es un mecanismo de PyTorch que permite ejecutar una función cuando un módulo termina su operación forward.

Podemos utilizarlo para inspeccionar la salida de una capa sin reescribir toda la arquitectura.

¿Qué información recibe?

En su forma habitual:

• El módulo.
• Los argumentos de entrada.
• La salida del módulo.

¿Qué podemos hacer?

Registrar, copiar o inspeccionar activaciones.

Precaución

Los hooks pueden modificar las salidas si devuelven un reemplazo.

Para diagnóstico conviene que la función de captura no modifique la salida.

También es recomendable eliminar los hooks cuando dejan de utilizarse.

Ejemplo 3 — Capturar Feature Maps con Forward Hooks

import torch
import torch.nn as nn
torch.manual_seed(42)
model = nn.Sequential(
    nn.Conv2d(1, 8, 3, padding=1),
    nn.ReLU(),
    nn.Conv2d(8, 16, 3, padding=1),
    nn.ReLU()
)
activations = {}
def capture(name):
    def hook(module, inputs, output):
        activations[name] = (
            output.detach().cpu()
        )
    return hook
handle1 = model[0].register_forward_hook(
    capture("conv1")
)
handle2 = model[2].register_forward_hook(
    capture("conv2")
)
X = torch.randn(
    1, 1, 64, 64
)
model.eval()
with torch.inference_mode():
    _ = model(X)
for name, value in activations.items():
    print(
        name,
        value.shape
    )
handle1.remove()
handle2.remove()

¿Qué demuestra?

Podemos capturar automáticamente las salidas de dos capas convolucionales.

¿Por qué utilizar detach()?

Permite separar el tensor del grafo de diferenciación automática cuando solamente queremos observarlo.

¿Por qué utilizar cpu()?

Facilita la visualización posterior con bibliotecas como NumPy y Matplotlib.

Precaución

La captura utiliza las salidas de las convoluciones, antes de las capas ReLU.

Si queremos obtener activaciones después de ReLU, debemos registrar los hooks sobre los módulos de activación.

¿Qué diferencia existe entre activación antes y después de ReLU?

Consideremos:

z = Conv(x)

Después:

a = ReLU(z)

Antes de ReLU

El mapa puede contener valores positivos y negativos.

Después de ReLU

Los valores negativos se convierten en cero.

¿Por qué importa?

Porque una visualización posterior a ReLU puede ocultar respuestas negativas que estaban presentes antes de la activación.

¿Qué representación deberíamos visualizar?

Depende de la pregunta.

Si investigamos la convolución, puede interesarnos z.

Si investigamos las representaciones que recibe la siguiente etapa, puede interesarnos a.

Ejemplo 4 — Comparar antes y después de ReLU

import torch
import torch.nn.functional as F
import matplotlib.pyplot as plt
torch.manual_seed(42)
conv = nn.Conv2d(
    1, 1,
    kernel_size=3,
    padding=1
)
image = torch.randn(
    1, 1, 32, 32
)
with torch.inference_mode():
    before = conv(image)
    after = F.relu(before)
fig, axes = plt.subplots(
    1, 2,
    figsize=(8, 4)
)
axes[0].imshow(
    before[0, 0].numpy(),
    cmap="coolwarm"
)
axes[0].set_title(
    "Antes de ReLU"
)
axes[1].imshow(
    after[0, 0].numpy(),
    cmap="viridis"
)
axes[1].set_title(
    "Después de ReLU"
)
for ax in axes:
    ax.axis("off")
plt.tight_layout()
plt.show()

¿Qué demuestra?

La función de activación modifica los valores del mapa aunque mantenga su forma espacial.

¿Cómo visualizar los Feature Maps de una ResNet?

Una ResNet preentrenada permite estudiar representaciones más interesantes que las de un modelo aleatorio.

Por ejemplo, ResNet-18 contiene:

• Convolución inicial.
• Batch Normalization.
• ReLU.
• Max Pooling.
• Cuatro etapas residuales.
• Global Average Pooling.
• Clasificador final.

Las distintas etapas producen tensores con resoluciones y canales diferentes.

Ejemplo 5 — Feature Maps de ResNet-18

Instalación

pip install torch torchvision pillow matplotlib

Código completo

import torch
import matplotlib.pyplot as plt
from PIL import Image
from torchvision.models import (
    resnet18,
    ResNet18_Weights
)
weights = ResNet18_Weights.DEFAULT
model = resnet18(
    weights=weights
)
model.eval()
# Preprocesamiento correcto
preprocess = weights.transforms()
image = Image.open(
    "imagen.jpg"
).convert("RGB")
X = preprocess(
    image
).unsqueeze(0)
captured = {}
def save_activation(name):
    def hook(module, inputs, output):
        captured[name] = (
            output.detach().cpu()
        )
    return hook
handles = []
for name in [
    "relu",
    "layer1",
    "layer2",
    "layer3",
    "layer4"
]:
    module = getattr(
        model,
        name
    )
    handles.append(
        module.register_forward_hook(
            save_activation(name)
        )
    )
with torch.inference_mode():
    logits = model(X)
for handle in handles:
    handle.remove()
for name, tensor in captured.items():
    print(
        name,
        tensor.shape
    )
# Visualizar 8 canales de layer1
maps = captured["layer1"][0].numpy()
fig, axes = plt.subplots(
    2, 4,
    figsize=(10, 5)
)
for index, ax in enumerate(axes.flat):
    ax.imshow(
        maps[index],
        cmap="viridis"
    )
    ax.set_title(
        f"Canal {index}"
    )
    ax.axis("off")
plt.tight_layout()
plt.show()

¿Qué demuestra?

El modelo procesa una fotografía y permite examinar sus representaciones internas.

Formas habituales para entrada 224 × 224

¿Qué ocurre con la profundidad?

Los mapas suelen reducir su resolución espacial mientras aumenta el número de canales.

Limitación

La forma específica depende de la variante de ResNet y de las dimensiones de entrada.

Además, los nombres de módulos corresponden a la implementación utilizada.

¿Por qué no podemos interpretar directamente cada canal?

Una red entrenada puede representar información mediante combinaciones de canales.

Ejemplo

Un canal responde a determinadas texturas.

Otro responde a patrones geométricos.

Una predicción puede depender de numerosas respuestas y de sus interacciones.

¿Un canal corresponde exactamente a un objeto?

No necesariamente.

¿Cómo podemos investigar su significado?

Mediante:

• Visualización con múltiples imágenes.
• Maximización de activaciones.
• Estudios de ablación.
• Comparación entre categorías.
• Métodos de atribución.
• Evaluación de hipótesis específicas.

Precaución

Una visualización sugestiva no demuestra que la característica observada sea la única causa de la predicción.

¿Qué es Activation Maximization?

Activation Maximization es una técnica que busca entradas capaces de aumentar la activación de una unidad, canal o grupo de características.

Procedimiento conceptual

1. Seleccionar una activación objetivo.
2. Crear una entrada inicial.
3. Calcular la activación.
4. Obtener gradientes respecto a la entrada.
5. Modificar la entrada para aumentar esa activación.
6. Repetir.

¿Para qué sirve?

Para explorar qué patrones pueden activar una característica.

¿Qué limitación tiene?

Sin restricciones o regularización, las imágenes optimizadas pueden producir patrones artificiales poco interpretables.

¿Qué es un Mapa de Atribución?

Un Mapa de Atribución (Attribution Map) busca representar qué posiciones o características están relacionadas con una salida específica.

Diferencia frente a Activation Map

Un Activation Map muestra la respuesta de una capa.

Un Attribution Map se calcula respecto a una puntuación, clase u objetivo determinado.

¿Son equivalentes?

No.

Un canal puede presentar activaciones elevadas aunque su contribución a una clase concreta sea pequeña o incluso esté relacionada con otra decisión.

¿Qué es Grad-CAM?

Grad-CAM (Gradient-weighted Class Activation Mapping) es un método de visualización que utiliza las activaciones de una capa y los gradientes de una puntuación objetivo respecto a esas activaciones.

Se utiliza especialmente para producir mapas aproximados de localización relacionados con una predicción.

¿Qué permite estudiar?

Por ejemplo, qué regiones de una imagen están asociadas con la puntuación de una determinada clase.

¿Es igual que visualizar todos los Feature Maps?

No.

Grad-CAM combina los canales utilizando pesos derivados de gradientes de una salida objetivo.

¿Demuestra causalidad?

No por sí solo.

Es una técnica de explicación aproximada que requiere interpretación y validación cuidadosas.

Fórmula de Grad-CAM

Supongamos que una capa produce mapas:

Aᵏ

Donde k representa un canal.

Para una clase c, obtenemos gradientes:

∂Sᶜ/∂Aᵏᵢⱼ

Donde Sᶜ representa una puntuación de clase, habitualmente un logit.

Los coeficientes de Grad-CAM pueden calcularse mediante:

αᶜₖ = (1/Z) Σᵢ Σⱼ ∂Sᶜ/∂Aᵏᵢⱼ

Donde Z es el número de posiciones espaciales.

El mapa se construye como:

Lᶜ = ReLU(Σₖ αᶜₖ Aᵏ)

¿Qué significa?

Los gradientes proporcionan pesos para combinar los mapas de activación.

La función ReLU conserva las contribuciones positivas de esa combinación.

¿Qué ocurre después?

El mapa puede ampliarse a la resolución de la imagen para visualizarlo como una superposición.

Precaución

El mapa final suele tener una resolución espacial reducida, dependiendo de la capa seleccionada.

Ejemplo 6 — Grad-CAM básico en PyTorch

Vamos a utilizar ResNet-18 y obtener un mapa relacionado con la clase predicha.

import torch
import torch.nn.functional as F
import matplotlib.pyplot as plt
from PIL import Image
from torchvision.models import (
    resnet18,
    ResNet18_Weights
)
weights = ResNet18_Weights.DEFAULT
model = resnet18(
    weights=weights
)
model.eval()
image = Image.open(
    "imagen.jpg"
).convert("RGB")
preprocess = weights.transforms()
X = preprocess(
    image
).unsqueeze(0)
# Capturar activaciones y conservar
# sus gradientes
captured = {}
def forward_hook(module, inputs, output):
    captured["activation"] = output
    output.retain_grad()
target_layer = model.layer4
handle = target_layer.register_forward_hook(
    forward_hook
)
try:
    model.zero_grad(set_to_none=True)
    logits = model(X)
    class_id = int(
        logits.argmax(dim=1).item()
    )
    target_score = logits[0, class_id]
    target_score.backward()
    activation = captured[
        "activation"
    ]
    gradients = activation.grad
    # Media espacial por canal
    weights_per_channel = gradients.mean(
        dim=(2, 3),
        keepdim=True
    )
    cam = (
        weights_per_channel * activation
    ).sum(dim=1, keepdim=True)
    cam = F.relu(cam)
    # Ampliar a la resolución del tensor
    cam = F.interpolate(
        cam,
        size=X.shape[-2:],
        mode="bilinear",
        align_corners=False
    )
    cam = cam[0, 0].detach().cpu()
    cam = cam - cam.min()
    cam = cam / (
        cam.max() + 1e-8
    )
finally:
    handle.remove()
plt.figure(figsize=(6, 6))
plt.imshow(
    cam.numpy(),
    cmap="jet"
)
plt.title(
    f"Grad-CAM — Clase {class_id}"
)
plt.colorbar()
plt.axis("off")
plt.show()

¿Qué demuestra?

El código calcula una visualización relacionada con la puntuación de la clase predicha.

Primero obtiene las activaciones de layer4.

Después calcula sus gradientes respecto al logit objetivo.

Finalmente, combina los canales y amplía el mapa.

¿Por qué no utilizamos torch.inference_mode()?

Porque Grad-CAM necesita calcular gradientes.

¿Es una implementación completa para producción?

No.

Es una implementación educativa.

Para un sistema más riguroso conviene gestionar correctamente el preprocesamiento, la superposición sobre la imagen transformada, el dispositivo, el manejo de errores y la interpretación de los resultados.

¿El mapa tiene la misma resolución informativa que la imagen?

No.

La ampliación mediante interpolación no crea detalles que no estaban presentes en el mapa original.

¿Qué son los Forward Hooks y los Backward Hooks?

Son mecanismos que permiten observar diferentes momentos del cálculo de un módulo.

Forward Hook

Se ejecuta después de calcular una salida.

Resulta útil para registrar activaciones.

Backward Hook

Permite inspeccionar determinadas señales durante la retropropagación.

¿Cuándo utilizarlos?

• Depuración.
• Visualización.
• Diagnóstico de gradientes.
• Análisis de capas intermedias.

Precaución

La gestión de hooks y los detalles de Autograd deben respetar la API de la versión utilizada.

Es importante eliminar los hooks cuando ya no se necesitan.

¿Cómo visualizar Feature Maps con Keras?

En Keras, una estrategia habitual consiste en crear un segundo modelo cuyas salidas correspondan a capas intermedias del modelo original.

Podemos utilizar la API funcional:

keras.Model(inputs=model.inputs, outputs=…)

Esto permite obtener varias representaciones mediante una sola llamada.

Ejemplo 7 — Extraer Feature Maps con Keras

Instalación

pip install keras tensorflow numpy matplotlib

Código completo

import numpy as np
import keras
from keras import layers
import matplotlib.pyplot as plt
keras.utils.set_random_seed(42)
inputs = keras.Input(
    shape=(64, 64, 1)
)
x = layers.Conv2D(
    8,
    kernel_size=3,
    padding="same",
    activation="relu",
    name="conv_1"
)(inputs)
x = layers.MaxPooling2D(
    pool_size=2,
    name="pool_1"
)(x)
x = layers.Conv2D(
    16,
    kernel_size=3,
    padding="same",
    activation="relu",
    name="conv_2"
)(x)
outputs = layers.GlobalAveragePooling2D()(x)
model = keras.Model(
    inputs,
    outputs
)
# Crear un modelo de activaciones
activation_model = keras.Model(
    inputs=model.inputs,
    outputs=[
        model.get_layer("conv_1").output,
        model.get_layer("conv_2").output
    ]
)
image = np.zeros(
    (1, 64, 64, 1),
    dtype="float32"
)
image[:, 16:48, 24:40, 0] = 1.0
first_maps, second_maps = (
    activation_model.predict(
        image,
        verbose=0
    )
)
print(
    "Conv1:",
    first_maps.shape
)
print(
    "Conv2:",
    second_maps.shape
)
fig, axes = plt.subplots(
    2, 4,
    figsize=(10, 5)
)
for index, ax in enumerate(axes.flat):
    ax.imshow(
        first_maps[0, :, :, index],
        cmap="viridis"
    )
    ax.set_title(
        f"Canal {index}"
    )
    ax.axis("off")
plt.tight_layout()
plt.show()

¿Qué demuestra?

Podemos obtener varias activaciones intermedias sin modificar el método de inferencia del modelo.

¿Qué forma tiene la primera capa?

[1, 64, 64, 8]

¿Y la segunda?

[1, 32, 32, 16]

Precaución

El modelo tiene pesos iniciales aleatorios.

La visualización muestra cómo funciona el proceso, pero no representa características aprendidas.

¿Cómo funciona Keras con modelos preentrenados?

Podemos utilizar arquitecturas como ResNet50 para inspeccionar mapas intermedios.

Ejemplo

import keras
base = keras.applications.ResNet50(
    include_top=False,
    weights="imagenet",
    input_shape=(224, 224, 3)
)
for layer in base.layers[:10]:
    print(
        layer.name,
        layer.output.shape
    )

¿Qué demuestra?

El modelo expone capas con nombres y formas que podemos consultar.

¿Podemos crear modelos de activación?

Sí.

Podemos seleccionar capas concretas mediante get_layer() y construir un modelo que devuelva sus salidas.

Precaución

Los nombres dependen de la arquitectura.

No debemos suponer que dos variantes distintas de ResNet exponen exactamente los mismos nombres internos.

Ejemplo 8 — Visualizar capas de ResNet50 en Keras

import keras
import numpy as np
from PIL import Image
import matplotlib.pyplot as plt
base = keras.applications.ResNet50(
    include_top=False,
    weights="imagenet",
    input_shape=(224, 224, 3)
)
base.trainable = False
layer_names = [
    "conv1_relu",
    "conv2_block3_out",
    "conv3_block4_out"
]
activation_model = keras.Model(
    inputs=base.input,
    outputs=[
        base.get_layer(name).output
        for name in layer_names
    ]
)
image = Image.open(
    "imagen.jpg"
).convert("RGB")
image = image.resize(
    (224, 224)
)
array = np.asarray(
    image,
    dtype="float32"
)
array = np.expand_dims(
    array,
    axis=0
)
array = keras.applications.resnet.preprocess_input(
    array
)
feature_maps = activation_model.predict(
    array,
    verbose=0
)
for name, features in zip(
    layer_names,
    feature_maps
):
    print(
        name,
        features.shape
    )
    # Visualización del primer canal
    plt.figure(figsize=(5, 5))
    plt.imshow(
        features[0, :, :, 0],
        cmap="viridis"
    )
    plt.title(name)
    plt.axis("off")
    plt.show()

¿Qué demuestra?

Podemos extraer y visualizar representaciones de diferentes etapas de una ResNet50 preentrenada.

¿Qué debemos observar?

Los mapas pueden mostrar estructuras espaciales y patrones distintos entre capas.

Precaución

El primer canal no tiene por qué ser el más informativo.

Una investigación más completa debería comparar distintos canales e imágenes.

¿Cómo comparar mapas de diferentes capas?

Las capas pueden producir mapas con valores y resoluciones muy diferentes.

Por eso debemos seleccionar una estrategia de visualización adecuada.

Opción 1. Escala independiente

Normalizar cada mapa por separado para observar su estructura interna.

Opción 2. Escala compartida

Utilizar el mismo rango numérico entre mapas comparables.

Opción 3. Estadísticas cuantitativas

Registrar medias, desviaciones, máximos y normas.

¿Cuál es mejor?

Depende del objetivo.

La escala independiente permite observar patrones débiles.

Pero puede ocultar diferencias importantes de magnitud.

La escala compartida facilita determinadas comparaciones cuantitativas.

Ejemplo 9 — Normalizar mapas para visualización

import numpy as np
def normalize_map(feature_map):
    feature_map = np.asarray(
        feature_map,
        dtype=np.float64
    )
    low = feature_map.min()
    high = feature_map.max()
    if high - low < 1e-12:
        return np.zeros_like(
            feature_map
        )
    return (
        (feature_map - low) /
        (high - low)
    )

¿Qué demuestra?

Permite visualizar mapas cuyos rangos numéricos son diferentes.

Precaución

Este procedimiento cambia la escala de visualización.

No debe utilizarse para afirmar que dos canales tienen activaciones de magnitud equivalente.

¿Qué métricas podemos calcular sobre un Feature Map?

Además de visualizarlo, podemos registrar estadísticas.

Media

μ = (1/N)Σaᵢ

Desviación estándar

σ = √[(1/N)Σ(aᵢ − μ)²]

Valor máximo

max(aᵢ)

RMS

RMS = √[(1/N)Σaᵢ²]

Fracción de ceros

p₀ = cantidad de componentes cero / N

¿Por qué importa?

Estas estadísticas pueden ayudar a detectar capas con:

• Activaciones excesivamente grandes.
• Valores no finitos.
• Canales casi constantes.
• Respuestas saturadas.
• Alta proporción de ceros.

Precaución

Una proporción alta de ceros puede ser normal en capas ReLU.

No demuestra automáticamente la existencia de un problema.

Ejemplo 10 — Diagnóstico de activaciones en PyTorch

import torch
def activation_statistics(tensor):
    tensor = tensor.detach().float()
    return {
        "mean": tensor.mean().item(),
        "std": tensor.std(
            unbiased=False
        ).item(),
        "rms": tensor.square()
            .mean()
            .sqrt()
            .item(),
        "zero_fraction": (
            tensor == 0
        ).float().mean().item(),
        "finite_fraction": torch.isfinite(
            tensor
        ).float().mean().item()
    }
stats = activation_statistics(
    first_activation
)
for key, value in stats.items():
    print(
        key,
        value
    )

¿Qué demuestra?

Podemos complementar la inspección visual con métricas numéricas.

¿Qué utilidad tiene en producción?

Estas medidas pueden incorporarse a un procedimiento de diagnóstico de modelos.

Sin embargo, conservar todas las activaciones de una red grande puede consumir mucha memoria.

¿Qué es un canal inactivo?

Un canal puede producir valores cero o muy pequeños para determinadas entradas.

¿Significa que el filtro no sirve?

No necesariamente.

Puede responder a patrones que no aparecen en esa imagen.

¿Qué ocurre si permanece inactivo en todas las observaciones?

Podría justificar una investigación adicional.

¿Puede ocurrir con ReLU?

Sí.

Determinadas configuraciones pueden producir activaciones cero en numerosos ejemplos.

¿Es siempre Dying ReLU?

No.

Para diagnosticar Dying ReLU debemos estudiar el comportamiento a través de múltiples entradas y durante el entrenamiento.

¿Qué es la saturación de activaciones?

Algunas funciones de activación tienen regiones donde su derivada es pequeña.

Por ejemplo:

• Sigmoid.
• Tanh.

¿Por qué importa?

Porque puede afectar al flujo de gradientes.

¿Podemos observarlo mediante mapas?

En determinadas situaciones, sí.

Podemos registrar distribuciones de activaciones y comprobar cuántos valores se encuentran en regiones saturadas.

Precaución

Las activaciones por sí solas no sustituyen un análisis de gradientes.

¿Qué relación existe con Vanishing Gradients?

Los Gradientes Desvanecientes describen la atenuación excesiva de señales durante Backpropagation.

Los Feature Maps describen representaciones calculadas durante Forward Propagation.

¿Están relacionados?

Sí.

Las activaciones influyen en los Jacobianos y, por tanto, en los gradientes.

¿Son lo mismo?

No.

Un mapa de activación puede ser pequeño aunque el modelo no presente necesariamente un problema de Vanishing Gradients.

¿Qué relación existe con Batch Normalization?

Batch Normalization transforma determinadas activaciones utilizando estadísticas del entrenamiento.

¿Qué ocurre con los Feature Maps?

Sus distribuciones cambian.

¿Por qué importa al visualizar?

Un mapa obtenido antes de BatchNorm puede diferir considerablemente de uno obtenido después.

¿Cuál debemos utilizar?

Depende de qué componente queremos estudiar.

Para comparaciones rigurosas debemos registrar exactamente el punto del modelo donde se capturó el tensor.

¿Qué relación existe con Residual Connections?

En un bloque residual:

y = x + F(x)

La salida combina una representación anterior con una transformación aprendible.

¿Qué significa para los mapas?

El Feature Map resultante incluye ambas contribuciones.

¿Podemos visualizar las dos rutas por separado?

Sí, cuando la arquitectura permite acceder a sus salidas.

¿Por qué puede ser útil?

Permite estudiar cuánto cambia la representación dentro de un bloque.

Precaución

La diferencia entre mapas no proporciona por sí sola una medida completa de la importancia del bloque para la predicción.

¿Qué relación existe con Pooling?

Las capas de Pooling producen representaciones agregadas.

Max Pooling

Conserva máximos locales.

Average Pooling

Calcula promedios.

Global Average Pooling

Reduce cada canal espacial a un resumen numérico.

¿Qué ocurre con la visualización?

La resolución puede disminuir.

Cuando un mapa queda reducido a 1 × 1, deja de existir una distribución espacial detallada que pueda visualizarse como una imagen.

¿Qué es una representación multiescala?

Una representación multiescala combina características de diferentes resoluciones.

¿Por qué importa?

Porque algunas tareas necesitan información local y global.

Ejemplos

• Detección de objetos.
• Segmentación.
• Reconocimiento de estructuras de diferentes tamaños.

¿Dónde aparece?

En arquitecturas encoder-decoder, Feature Pyramid Networks y otros diseños.

¿Qué aportan las Skip Connections?

Pueden transferir mapas de mayor resolución hacia etapas posteriores.

Feature Maps en U-Net

U-Net utiliza una estructura encoder-decoder con conexiones entre etapas de resolución relacionada.

Encoder

Produce representaciones progresivamente transformadas y, normalmente, de menor resolución.

Decoder

Reconstruye una representación espacial apropiada para la tarea.

Skip Connections

Transmiten características desde etapas del encoder hacia etapas del decoder.

¿Por qué importa?

Porque el decoder puede recuperar información espacial que sería difícil reconstruir solamente a partir de las características más comprimidas.

Aplicación

La segmentación de imágenes requiere predicciones asociadas con posiciones o regiones.

Feature Maps en ResNet

ResNet utiliza bloques residuales y varias etapas.

¿Qué ocurre con los mapas?

La resolución espacial suele disminuir entre etapas.

El número de canales aumenta en numerosas variantes.

¿Qué permite estudiar la visualización?

• Diferencias entre etapas.
• Activaciones asociadas con patrones visuales.
• Efectos de las transformaciones residuales.
• Posibles anomalías en la distribución de activaciones.

¿Es suficiente para explicar una clasificación?

No.

Se necesitan análisis adicionales para estudiar la relación causal entre representaciones y predicciones.

¿Cómo identificar mapas útiles?

Un mapa visualmente llamativo no es necesariamente importante para la tarea.

Posibles criterios

1. Relación con el rendimiento predictivo.
2. Comportamiento ante múltiples ejemplos.
3. Consistencia dentro de una categoría.
4. Sensibilidad a cambios controlados.
5. Resultado de ablaciones.
6. Análisis de atribución.
7. Evaluación sobre datos independientes.

¿Por qué importa?

Porque una visualización puede resultar intuitiva pero inducir interpretaciones incorrectas.

¿Qué es un estudio de ablación?

Una Ablación (Ablation Study) consiste en modificar o eliminar un componente para observar cómo cambia el comportamiento del sistema.

Ejemplo

Una CNN contiene 64 canales en una etapa.

Podemos analizar qué ocurre si anulamos temporalmente determinadas características en un experimento controlado.

¿Qué podemos medir?

• Cambio de pérdida.
• Cambio de precisión.
• Cambio en una puntuación de clase.
• Sensibilidad a determinadas imágenes.

Precaución

Anular canales puede crear distribuciones de representaciones que no aparecían durante el entrenamiento.

Por tanto, los resultados deben interpretarse cuidadosamente.

Ejemplo 11 — Ablación sencilla de un canal

En un modelo construido específicamente para diagnóstico, podemos modificar una representación intermedia antes de pasarla a la etapa posterior.

import torch
import torch.nn as nn
torch.manual_seed(42)
conv1 = nn.Conv2d(
    1, 8,
    kernel_size=3,
    padding=1
)
conv2 = nn.Conv2d(
    8, 16,
    kernel_size=3,
    padding=1
)
image = torch.randn(
    1, 1, 32, 32
)
with torch.inference_mode():
    features = torch.relu(
        conv1(image)
    )
    original = conv2(features)
    modified = features.clone()
    # Anular canal cero
    modified[:, 0] = 0
    ablated = conv2(modified)
    difference = (
        original - ablated
    ).abs().mean()
print(
    "Diferencia media:",
    difference.item()
)

¿Qué demuestra?

Podemos cuantificar cómo cambia la representación posterior al eliminar un canal.

Limitación

El modelo es aleatorio y no está entrenado.

La diferencia numérica no equivale a importancia predictiva.

Para estudiar la importancia en una tarea necesitamos un modelo entrenado y métricas apropiadas.

¿Cómo se relacionan los Feature Maps con la detección de objetos?

Un detector puede utilizar mapas de diferentes etapas para localizar objetos.

¿Por qué?

Porque la localización requiere información espacial.

Ejemplo

Un objeto pequeño puede necesitar características de resolución relativamente alta.

Un objeto grande puede beneficiarse de representaciones con mayor contexto.

¿Todos los detectores utilizan mapas del mismo modo?

No.

Existen diferentes arquitecturas y mecanismos de agregación.

Feature Maps y reconocimiento de logotipos

Una CNN puede utilizarse para clasificar o detectar logotipos.

¿Qué función cumplen los Feature Maps?

Representan patrones visuales que el modelo utiliza en sus etapas posteriores.

¿Podemos identificar qué canales responden a un logotipo?

Podemos investigarlo mediante visualización y otros experimentos.

¿Es suficiente observar una activación intensa?

No.

Debemos comprobar si esa respuesta es consistente, específica y relevante para la predicción.

Feature Maps y OCR

Los sistemas de reconocimiento óptico de caracteres pueden utilizar extractores visuales convolucionales.

¿Qué representan los mapas?

Información sobre trazos, formas y estructuras relacionadas con el contenido visual.

¿Una CNN convierte directamente un mapa en texto?

No necesariamente.

Un sistema OCR completo puede necesitar componentes adicionales de reconocimiento y decodificación.

¿Por qué importan los Feature Maps para AI Visibility?

Una plataforma de AI Visibility puede incorporar análisis visual de activos de marca.

Por ejemplo:

• Fotografías de productos.
• Logotipos.
• Capturas de páginas web.
• Elementos gráficos.
• Creatividades publicitarias.
• Imágenes asociadas a categorías comerciales.

Los mapas de características permiten estudiar cómo los modelos visuales procesan estos materiales.

Ejemplo empresarial

Una organización utiliza un clasificador para distinguir entre:

Logotipo

Fotografía de producto

Captura de sitio web

El modelo emplea capas convolucionales que generan representaciones internas.

La visualización de esos mapas puede ayudar a investigar determinados errores.

¿Qué ocurre si el clasificador confunde un logotipo con una fotografía de producto?

Podemos examinar las activaciones y analizar ejemplos donde aparece el error.

¿Eso garantiza identificar la causa?

No.

La visualización proporciona evidencia complementaria, pero debe combinarse con evaluación sistemática.

Ejemplo 12 — Extractor de Feature Maps para activos de marca

import torch
import torch.nn as nn
class BrandVisualModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Sequential(
            nn.Conv2d(
                3, 32,
                kernel_size=3,
                padding=1
            ),
            nn.ReLU()
        )
        self.conv2 = nn.Sequential(
            nn.Conv2d(
                32, 64,
                kernel_size=3,
                stride=2,
                padding=1
            ),
            nn.ReLU()
        )
        self.conv3 = nn.Sequential(
            nn.Conv2d(
                64, 128,
                kernel_size=3,
                stride=2,
                padding=1
            ),
            nn.ReLU()
        )
        self.pool = nn.AdaptiveAvgPool2d(
            (1, 1)
        )
        self.classifier = nn.Linear(
            128,
            3
        )
    def forward(self, x):
        maps1 = self.conv1(x)
        maps2 = self.conv2(maps1)
        maps3 = self.conv3(maps2)
        features = self.pool(
            maps3
        ).flatten(1)
        logits = self.classifier(
            features
        )
        return logits, {
            "layer1": maps1,
            "layer2": maps2,
            "layer3": maps3
        }
model = BrandVisualModel()
X = torch.randn(
    8, 3, 128, 128
)
model.eval()
with torch.inference_mode():
    logits, maps = model(X)
print("Logits:", logits.shape)
for name, tensor in maps.items():
    print(
        name,
        tensor.shape
    )

Resultados esperados

Logits:

[8, 3]

Layer1:

[8, 32, 128, 128]

Layer2:

[8, 64, 64, 64]

Layer3:

[8, 128, 32, 32]

¿Qué demuestra?

Podemos diseñar un modelo que entregue tanto sus predicciones como sus representaciones intermedias.

¿Es apropiado para producción?

Puede utilizarse como base, pero en producción conviene evitar devolver todas las activaciones cuando no son necesarias, ya que pueden consumir memoria.

Limitación

El modelo no está entrenado.

No constituye un clasificador validado de activos de marca.

¿Los Feature Maps miden Recommendation Rate?

No.

Recommendation Rate representa una frecuencia de recomendaciones observadas bajo una metodología determinada.

Los Feature Maps son representaciones internas de redes neuronales.

Relación indirecta

Si una plataforma utiliza un modelo visual para analizar contenido de marca, los mapas pueden facilitar su diagnóstico.

Lo que no hacen

No aumentan directamente las recomendaciones que generan asistentes externos.

Tampoco modifican automáticamente sus respuestas.

¿Los Feature Maps miden Citation Coverage?

No.

Citation Coverage se relaciona con citas o referencias observadas según una definición determinada.

Un Feature Map representa respuestas internas de un modelo.

¿Puede contribuir a un sistema más amplio?

Sí, como componente de un análisis visual específico.

¿Es una métrica de citas?

No.

Errores frecuentes con Feature Maps y Activation Maps

Error 1. Confundir filtros y mapas de activación

Los filtros son pesos; los mapas son respuestas.

Error 2. Suponer que Feature Map y Grad-CAM son equivalentes

Grad-CAM utiliza gradientes de una puntuación objetivo.

Error 3. Interpretar un canal como un concepto semántico definitivo

Las representaciones pueden ser distribuidas.

Error 4. Visualizar pesos aleatorios como si fueran características aprendidas

Se necesita entrenamiento relevante.

Error 5. Ignorar las dimensiones de los tensores

NCHW y NHWC utilizan órdenes diferentes.

Error 6. Comparar mapas con escalas independientes sin aclararlo

Puede ocultar diferencias de magnitud.

Error 7. Olvidar la posición de ReLU

Los valores pueden cambiar considerablemente.

Error 8. Confundir activaciones anteriores y posteriores a BatchNorm

Son representaciones diferentes.

Error 9. Suponer que todas las capas profundas tienen mapas de baja resolución

Depende de la arquitectura.

Error 10. Capturar activaciones sin liberar referencias

Puede provocar un uso innecesario de memoria.

Error 11. Registrar hooks y no eliminarlos

Puede producir capturas duplicadas o efectos no deseados.

Error 12. Aplicar inference_mode al calcular Grad-CAM

Grad-CAM necesita gradientes.

Error 13. Interpretar una superposición Grad-CAM como una explicación causal definitiva

No existe esa garantía.

Error 14. Considerar un canal inactivo como un error automático

Puede ser normal para determinadas entradas.

Error 15. Confundir análisis de representaciones visuales con métricas de AI Visibility

Son conceptos diferentes.

Buenas prácticas para visualizar Feature Maps

1. Utilizar modelos entrenados para análisis semántico.
2. Seleccionar imágenes representativas.
3. Registrar la arquitectura exacta.
4. Identificar el punto donde se capturan las activaciones.
5. Verificar las formas de los tensores.
6. Utilizar el preprocesamiento correcto.
7. Comparar mapas de distintas capas.
8. Examinar varios canales.
9. Explicar la normalización visual.
10. Registrar estadísticas cuantitativas.
11. Evitar interpretaciones basadas en una sola imagen.
12. Eliminar hooks cuando ya no se necesitan.
13. Controlar el consumo de memoria.
14. Combinar visualización con ablaciones y evaluaciones.
15. Documentar limitaciones de los métodos de atribución.

Preguntas frecuentes sobre Feature Maps y Activation Maps

¿Qué significa Feature Map?

Significa Mapa de Características.

¿Qué significa Activation Map?

Significa Mapa de Activación.

¿Qué es un Feature Map?

Es una representación intermedia producida por una capa neuronal.

¿Qué es un Activation Map?

Es una representación de las respuestas de una capa ante una entrada concreta.

¿Son iguales Feature Map y Activation Map?

En CNN se utilizan frecuentemente como términos equivalentes, aunque puede distinguirse el punto exacto de cálculo.

¿Qué es un Kernel?

Es un conjunto de pesos aplicado mediante una operación convolucional.

¿Qué diferencia existe entre Kernel y Feature Map?

El kernel contiene pesos; el Feature Map contiene respuestas calculadas.

¿Qué es un canal de características?

Es una componente de la representación producida por una capa.

¿Un canal representa siempre un objeto?

No.

¿Qué determina el número de canales?

La configuración de filtros y la arquitectura.

¿Qué es NCHW?

Batch, Channels, Height, Width.

¿Qué es NHWC?

Batch, Height, Width, Channels.

¿Qué formato utiliza PyTorch?

Habitualmente NCHW para Conv2D.

¿Qué formato utiliza Keras?

Habitualmente NHWC con channels_last.

¿Qué es ReLU?

Es una activación que transforma valores negativos en cero y conserva los positivos.

¿ReLU cambia los mapas?

Sí, modifica sus valores.

¿Qué es BatchNorm?

Es una normalización que puede transformar la distribución de activaciones.

¿Qué es Pooling?

Es una agregación que resume regiones de los mapas.

¿Qué es Global Average Pooling?

Es un promedio espacial por canal.

¿Qué es Receptive Field?

Es la región de entrada que puede influir en una unidad posterior.

¿Qué es una representación multiescala?

Es una combinación de características de distintas resoluciones.

¿Qué es Feature Visualization?

Es el estudio visual de representaciones neuronales.

¿Qué es Activation Maximization?

Es optimizar una entrada para incrementar una activación seleccionada.

¿Qué es un Forward Hook?

Es un mecanismo de PyTorch para ejecutar una función después del cálculo de un módulo.

¿Qué es register_forward_hook?

Es una API de PyTorch para registrar un hook de salida de un módulo.

¿Por qué debemos eliminar hooks?

Para evitar ejecuciones y referencias innecesarias.

¿Qué significa detach()?

Es separar un tensor de su grafo de Autograd para determinados usos de inspección.

¿Qué significa cpu()?

Es mover un tensor a memoria de CPU.

¿Qué es un Mapa de Atribución?

Es una visualización calculada respecto a una salida u objetivo del modelo.

¿Qué es Grad-CAM?

Es un método que combina activaciones y gradientes para generar mapas relacionados con una puntuación objetivo.

¿Grad-CAM es un Activation Map convencional?

No.

¿Grad-CAM necesita Backpropagation?

Sí, necesita gradientes respecto a un objetivo.

¿Grad-CAM demuestra qué píxeles causaron una decisión?

No de manera definitiva.

¿Se puede utilizar Grad-CAM con ResNet?

Sí.

¿Se pueden visualizar activaciones de ResNet-18?

Sí.

¿Se pueden visualizar activaciones de ResNet-50?

Sí.

¿Se pueden visualizar en Keras?

Sí, creando un modelo con salidas intermedias.

¿Qué es un modelo de activaciones?

Es un modelo que devuelve representaciones de capas seleccionadas.

¿Qué es una activación inactiva?

Es una respuesta cero o pequeña bajo una definición concreta.

¿Una activación cero indica un error?

No necesariamente.

¿Qué es Dying ReLU?

Es una situación donde ciertas neuronas permanecen en regiones sin gradiente útil para las entradas relevantes.

¿Los Feature Maps permiten detectar Vanishing Gradients?

Pueden aportar información, pero se necesita analizar también los gradientes.

¿Qué es un estudio de ablación?

Es modificar un componente para estudiar su efecto.

¿Se utilizan Feature Maps en U-Net?

Sí.

¿Se utilizan en ResNet?

Sí.

¿Se utilizan para detección de objetos?

Sí, como representaciones espaciales dentro de detectores.

¿Se utilizan para segmentación?

Sí.

¿Se utilizan para OCR?

Sí, en determinados extractores visuales.

¿Se pueden utilizar en audio?

Sí, según la arquitectura y representación.

¿Se pueden utilizar en vídeo?

Sí.

¿Se pueden visualizar mapas de modelos aleatorios?

Sí, pero no deben interpretarse como características aprendidas.

¿Por qué importa la escala de visualización?

Porque puede alterar cómo percibimos la intensidad relativa de las respuestas.

¿Los Feature Maps aumentan Recommendation Rate?

No directamente.

¿Los Feature Maps generan Citation Coverage?

No.

¿Por qué importan para AI Visibility?

Pueden ayudar a diagnosticar modelos visuales utilizados para analizar activos de marca.

Conceptos relacionados

• Inteligencia Artificial.
• Aprendizaje Automático.
• Aprendizaje Profundo.
• Redes Neuronales.
• Visión por Computadora.
• Redes Neuronales Convolucionales.
• Capas Convolucionales.
• Filtros Convolucionales.
• Kernels Convolucionales.
• Feature Maps.
• Activation Maps.
• Feature Visualization.
• Forward Hooks.
• Backpropagation.
• ReLU.
• Batch Normalization.
• Receptive Field.
• Stride.
• Padding.
• Pooling.
• Global Average Pooling.
• Residual Connections.
• ResNet.
• U-Net.
• Feature Pyramid Networks.
• Activation Maximization.
• Grad-CAM.
• Attribution Maps.
• Ablation Studies.
• Vanishing Gradients.
• Extracción de Características.
• Transfer Learning.
• AI Visibility.

Conclusión

Los Mapas de Características (Feature Maps) son representaciones fundamentales del funcionamiento interno de las redes neuronales, especialmente de las CNN.

Se generan cuando una capa transforma los datos que recibe mediante filtros y otras operaciones.

Cada canal contiene respuestas que pueden utilizarse en etapas posteriores del modelo.

Los Mapas de Activación (Activation Maps) permiten estudiar cómo responde una capa ante una entrada concreta.

En muchos contextos ambos conceptos se utilizan de forma intercambiable.

Sin embargo, es importante distinguirlos de los pesos de los filtros y de los mapas de atribución calculados para una predicción específica.

La visualización de estas representaciones permite investigar diferencias entre capas, analizar patrones de respuesta y detectar determinados problemas de procesamiento.

Herramientas como Forward Hooks en PyTorch y los modelos de salidas intermedias en Keras facilitan estas tareas.

Métodos como Grad-CAM permiten ampliar el análisis hacia representaciones relacionadas con clases o puntuaciones concretas.

No obstante, las visualizaciones deben interpretarse con cautela.

Un canal no corresponde necesariamente a un objeto identificable, y una región destacada no demuestra por sí sola una relación causal exclusiva con la predicción.

Para obtener conclusiones fiables conviene combinar visualización, métricas cuantitativas, ejemplos representativos, pruebas de ablación y evaluación independiente.

En aplicaciones de AI Visibility, estos mapas pueden contribuir al diagnóstico de modelos que procesan imágenes de productos, logotipos y otros activos visuales comerciales.

La conclusión fundamental es que los Feature Maps muestran cómo una red neuronal transforma y representa la información a lo largo de sus capas. Su visualización proporciona una herramienta valiosa para comprender y depurar modelos, siempre que se distingan claramente las activaciones, los filtros y los métodos de atribución, y que las interpretaciones se contrasten mediante experimentos.