Redes Neuronales Convolucionales (CNN): la arquitectura que le enseñó a las máquinas a ver

Respuesta rápida

Una Red Neuronal Convolucional (CNN) es una arquitectura de deep learning diseñada para procesar datos con estructura de cuadrícula, como imágenes. En lugar de conectar cada píxel con cada neurona (lo que sería imposiblemente costoso), usa filtros convolucionales que desliza por la imagen detectando bordes, texturas y formas. Las primeras capas encuentran líneas y curvas; las últimas capas reconocen ojos, ruedas o caras completas. Es la tecnología que permite a tu móvil desbloquearse con la cara, a los coches autónomos ver señales de tráfico, y a los médicos detectar tumores en radiografías.

El problema: las imágenes son enormes

Antes de entender las CNN, necesitas ver por qué las redes neuronales "normales" (las densas o fully-connected) no sirven para imágenes.

Imagina una foto modesta de 224×224 píxeles en color. Eso son 224 × 224 × 3 = 150.528 números. Si conectas cada uno de esos números a una capa oculta de tan solo 1.000 neuronas, necesitas 150.528 × 1.000 = 150 millones de pesos solo en esa primera capa. Y eso para una foto pequeña. Una imagen de 4K tendría miles de millones de parámetros solo al inicio.

Pero el problema no es solo el tamaño. Es que una red densa trata cada píxel como independiente. No sabe que el píxel de arriba a la izquierda está físicamente cerca del de arriba a la derecha. No entiende el espacio. Si entrenas una red densa para reconocer gatos y luego le muestras el mismo gato desplazado dos píxeles a la derecha, la red lo verá como una imagen completamente diferente.

Necesitamos algo que:

1. Respete la estructura espacial de la imagen.
2. Detecte patrones locales (bordes, esquinas) independientemente de dónde aparezcan.
3. Use muchos menos parámetros que una red densa.

Ahí es donde entran las CNN.

---

La intuición: un detective con una lupa

Imagina que eres un detective y tienes que encontrar una huella dactilar en una fotografía gigante. No miras toda la imagen de golpe. Tomas una lupa pequeña, la deslizas sistemáticamente por toda la foto, y en cada posición decides: "aquí hay una línea curva", "aquí hay una bifurcación", "aquí no hay nada interesante".

Eso es una convolución. La lupa es un filtro o kernel: una pequeña matriz de números (típicamente 3×3, 5×5 o 7×7) que se desliza sobre la imagen. En cada posición, multiplica los números del filtro por los píxeles que tiene debajo, suma todo, y produce un único número de salida.

El truco está en que el mismo filtro se usa en toda la imagen. Si el filtro aprende a detectar bordes verticales, lo hará tanto en la esquina superior izquierda como en la esquina inferior derecha. Los pesos se comparten. Eso reduce drásticamente el número de parámetros y hace la red invariante a traslaciones: un gato en el centro de la foto es lo mismo que un gato en la esquina, para la CNN.

---

La matemática de la convolución (sin miedo)

Vamos a verlo con números reales. Tienes una imagen pequeña en escala de grises y un filtro 3×3.

Imagen de entrada:

$$\begin{bmatrix} 1 & 1 & 1 & 0 & 0 \\ 1 & 1 & 1 & 0 & 0 \\ 1 & 1 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 & 1 \\ 0 & 0 & 0 & 1 & 1 \end{bmatrix}$$

Filtro (kernel) para detectar bordes verticales:

$$\begin{bmatrix} 1 & 0 & -1 \\ 1 & 0 & -1 \\ 1 & 0 & -1 \end{bmatrix}$$

El filtro se coloca en la esquina superior izquierda y se calcula:

$(1 \cdot 1) + (1 \cdot 0) + (1 \cdot -1) + (1 \cdot 1) + (1 \cdot 0) + (1 \cdot -1) + (1 \cdot 1) + (1 \cdot 0) + (1 \cdot -1) = 0$

Luego se desliza un píxel a la derecha y se repite. Al final obtienes un mapa de características más pequeño que la imagen original.

La operación completa se escribe así:

$(I * K)(i, j) = \sum_{m} \sum_{n} I(i+m, j+n) \cdot K(m, n)$

Donde $I$ es la imagen, $K$ es el kernel, y $(i, j)$ son las coordenadas del píxel de salida. No es más que multiplicar elemento a elemento y sumar.

En código Python con NumPy:

import numpy as np

def convolucion2d(imagen, kernel):
    h, w = imagen.shape
    kh, kw = kernel.shape
    salida = np.zeros((h - kh + 1, w - kw + 1))
    for i in range(salida.shape[0]):
        for j in range(salida.shape[1]):
            region = imagen[i:i+kh, j:j+kw]
            salida[i, j] = np.sum(region * kernel)
    return salida

imagen = np.array([
    [1, 1, 1, 0, 0],
    [1, 1, 1, 0, 0],
    [1, 1, 1, 0, 0],
    [0, 0, 0, 1, 1],
    [0, 0, 0, 1, 1]
])

kernel = np.array([
    [1, 0, -1],
    [1, 0, -1],
    [1, 0, -1]
])

print(convolucion2d(imagen, kernel))
# Salida: matriz donde los bordes verticales entre la zona de 1s y 0s se resaltan

Stride (paso): Es cuántos píxeles avanza el filtro cada vez. Un stride de 1 produce mapas grandes; un stride de 2 los reduce a la mitad. Es una forma de "comprimir" la información.

Padding (relleno): Si no quieres que el mapa de salida sea más pequeño que la entrada, rodeas la imagen de ceros antes de convolucionar. Así el filtro puede centrarse también en los píxeles del borde. Padding = 1 añade un borde de un píxel de ceros.

Con padding y stride, las dimensiones de salida se calculan así:

$W_{out} = \left\lfloor \frac{W_{in} - K + 2P}{S} \right\rfloor + 1$

Donde $W$ es el ancho, $K$ el tamaño del kernel, $P$ el padding, y $S$ el stride.

---

ReLU: la función que acelera todo

Después de la convolución, cada valor del mapa de características pasa por una función de activación. En las CNN modernas, casi siempre es ReLU (Rectified Linear Unit):

$f(x) = \max(0, x)$

Si el resultado de la convolución es positivo, pasa tal cual. Si es negativo, se convierte en cero. Es la función más simple que existe después de la lineal, y eso es precisamente por qué funciona tan bien:

1. Es extremadamente rápida de calcular.
2. Evita el problema del gradiente que desaparece (a diferencia de sigmoid o tanh).
3. Introduce no linealidad: sin ella, una pila de convoluciones sería equivalente a una sola convolución.

Visualmente, ReLU actúa como un umbral: solo las características fuertes (detecciones confiables) pasan a la siguiente capa. Las detecciones débiles se silencian.

---

Pooling: reducir para generalizar

Después de varias convoluciones + ReLU, la red aplica pooling (submuestreo). La operación más común es el Max Pooling: divides el mapa de características en regiones pequeñas (típicamente 2×2) y te quedas solo con el valor máximo de cada región.

Por ejemplo, con una ventana 2×2 y stride 2:

$$\begin{bmatrix} \color{green}{\mathbf{9}} & 8 & \color{green}{\mathbf{3}} & 1 \\ 2 & 1 & 0 & 2 \\ \color{green}{\mathbf{7}} & 3 & \color{green}{\mathbf{4}} & 2 \\ 1 & 0 & 1 & 0 \end{bmatrix} \xrightarrow{\text{MaxPool 2×2}} \begin{bmatrix} 9 & 3 \\ 7 & 4 \end{bmatrix}$$

¿Por qué hacer esto?

1. Reduce la dimensionalidad: menos píxeles = menos cálculo en capas posteriores.
2. Añade invarianza a pequeñas traslaciones: si un borde se mueve un píxel, el max pooling probablemente sigue capturándolo.
3. Evita el sobreajuste: al perder detalles finos, la red se ve forzada a aprender patrones generales en lugar de memorizar ruido.

También existe Average Pooling, que calcula la media en lugar del máximo. Es más suave pero a veces borra características importantes. En la práctica, Max Pooling es el estándar en CNNs clásicas, aunque arquitecturas modernas como ResNet a veces usan stride en la convolución en lugar de pooling explícito.

---

La arquitectura completa de una CNN

Una CNN típica para clasificación tiene cuatro bloques funcionales:

Bloques convolucionales: Cada bloque aprende características a diferente nivel de abstracción.

Flatten: Convierte los mapas de características 3D en un vector 1D para la capa densa.

Capas fully-connected (FC): Son redes densas normales que toman las características aprendidas por las convoluciones y las combinan para la clasificación final.

Softmax: Convierte las salidas en probabilidades que suman 1.

---

Qué aprende cada capa: una jerarquía visual

Una de las cosas más fascinantes de las CNN es que podemos ver qué aprenden. Si entrenas una red para clasificar imágenes y luego visualizas los filtros de cada capa, descubres una jerarquía emergente:

Esto no lo programó nadie. Es un comportamiento emergente del entrenamiento: la red descubre sola que las imágenes se organizan jerárquicamente.

---

Batch Normalization: estabilizar el entrenamiento

Entrenar CNNs profundas es difícil. A medida que los gradientes fluyen hacia atrás, las activaciones de las capas early cambian drásticamente, lo que obliga a las capas laterales a reajustarse constantemente. Eso ralentiza el entrenamiento.

Batch Normalization soluciona esto normalizando las activaciones de cada capa: resta la media y divide por la desviación estándar, luego aprende a escalar y desplazar de nuevo:

$\hat{x} = \frac{x - \mu_B}{\sqrt{\sigma^2_B + \epsilon}}$

$y = \gamma \hat{x} + \beta$

Esto permite usar tasas de aprendizaje más altas y hace que las redes converjan más rápido. Hoy en día, casi toda CNN moderna incluye BatchNorm después de cada convolución.

---

Dropout: evitar que memorice

Las CNNs con muchos parámetros pueden memorizar las imágenes de entrenamiento en lugar de aprender patrones generales. Dropout combate esto: durante el entrenamiento, apaga aleatoriamente un porcentaje de neuronas (típicamente 20-50%) en cada iteración.

Esto obliga a la red a no depender de ninguna neurona individual. Es como entrenar un equipo de fútbol donde en cada partido faltan jugadores al azar: todos deben saber jugar en todas las posiciones. Al final, el equipo completo juega mejor.

---

Evolución histórica: de LeNet a ResNet

Las CNNs no aparecieron de la noche a la mañana. Su evolución muestra cómo cada generación resolvió los problemas de la anterior.

LeNet-5 (1998) — La abuela de todas las CNN

Yann LeCun la diseñó para leer dígitos escritos a mano en cheques bancarios. Tenía solo 7 capas, 60.000 parámetros, y usaba kernels 5×5 con pooling 2×2. Funcionaba, pero el hardware de la época no permitía escalar.

AlexNet (2012) — El despertar

Alex Krizhevsky ganó ImageNet 2012 por paliza usando una CNN profunda entrenada en dos GPUs. AlexNet tenía 8 capas, 60 millones de parámetros, y usó ReLU + Dropout por primera vez a gran escala. El error de clasificación se redujo del 26% al 15%, dejando en ridículo a todos los métodos clásicos de visión por computador.

VGGNet (2014) — La simplicidad funciona

El equipo de Oxford demostró que usar muchas capas convolucionales pequeñas (3×3) es mejor que pocas capas grandes. VGG-16 tiene 16 capas y 138 millones de parámetros. Su arquitectura es tan simple y repetitiva que todavía se enseña en universidades.

ResNet (2015) — Rompiendo la barrera de la profundidad

Hasta 2015, las redes más allá de 20 capas empezaban a empeorar. Los gradientes se atenuaban y la red perdía rendimiento. Kaiming He introdujo las conexiones residuales (skip connections): cada capa aprende no la transformación completa, sino la diferencia respecto a la entrada.

$y = F(x) + x$

Si $F(x)$ aprende a ser cero, la capa simplemente deja pasar la señal. Esto permite entrenar redes de 50, 100 o incluso 1.000 capas sin que los gradientes desaparezcan. ResNet-152 ganó ImageNet 2015 con un error del 3.6%, superando ya al rendimiento humano.

EfficientNet (2019) — Escala con cabeza

Google propuso escalar la red de forma uniforme: no solo más capas (profundidad), sino también más canales (anchura) y mayor resolución de entrada. EfficientNet-B7 alcanza el estado del arte en ImageNet usando 8 veces menos parámetros que las redes anteriores.

---

Transfer Learning: no entrenes desde cero

Entrenar una ResNet desde cero en ImageNet cuesta semanas y miles de dólares en GPUs. La buena noticia es que casi nadie lo hace.

Transfer Learning consiste en tomar una red ya entrenada por Google, Meta o Microsoft (con millones de imágenes) y adaptarla a tu problema. La idea es que las capas early aprenden características universales (bordes, texturas) que sirven para cualquier imagen, mientras que las capas finales aprenden lo específico de tu dominio.

Dos estrategias comunes:

1. Extracción de características: congelas todas las capas convolucionales y solo entrenas la capa de clasificación final. Funciona si tu dataset es pequeño (cientos de imágenes).

2. Fine-tuning: descongelas las últimas capas convolucionales y las ajustas con una tasa de aprendizaje muy baja. Funciona si tu dataset es mediano (miles de imágenes).

En PyTorch, cargar un modelo preentrenado es trivial:

import torchvision.models as models

# Cargar ResNet-50 preentrenado en ImageNet
resnet = models.resnet50(weights='DEFAULT')

# Congelar todas las capas
for param in resnet.parameters():
    param.requires_grad = False

# Reemplazar la última capa para tu número de clases
import torch.nn as nn
resnet.fc = nn.Linear(resnet.fc.in_features, num_tus_clases)

Con 100 imágenes de tu gato, puedes tener un clasificador funcional en minutos en lugar de semanas.

---

Más allá de la clasificación: detección y segmentación

Las CNNs no solo clasifican. También pueden localizar objetos dentro de una imagen, o incluso pintar cada píxel con su categoría.

Detección de objetos

YOLO (You Only Look Once): En lugar de proponer miles de regiones candidatas, YOLO divide la imagen en una cuadrícula y predice, para cada celda, si contiene un objeto, dónde está su caja delimitadora, y de qué clase se trata. Todo en una sola pasada forward. YOLO puede procesar 60 imágenes por segundo en tiempo real.

Faster R-CNN: Usa una red de propuesta de regiones (RPN) para encontrar zonas interesantes, y luego una CNN clasifica cada región. Es más preciso que YOLO pero más lento. Se usa cuando la precisión importa más que la velocidad.

Segmentación semántica

La segmentación asigna una clase a cada píxel de la imagen. La arquitectura estrella es U-Net, diseñada originalmente para biomedicina.

U-Net tiene una forma de U: la mitad izquierda comprime la imagen (encoder) y la mitad derecha la expande (decoder). Las conexiones skip llevan información de alta resolución desde la compresión hasta la expansión, permitiendo que la salida tenga el mismo tamaño que la entrada, con cada píxel clasificado.

Aplicaciones: segmentar tumores en escáneres, identificar carriles en conducción autónoma, o extraer fondos en videoconferencias.

---

CNN en 1D: cuando los datos no son imágenes

La convolución no es exclusiva de imágenes. Si tienes una señal temporal —como electrocardiogramas, datos de bolsa, o audio— puedes usar convoluciones 1D.

En lugar de un kernel 2D que se desliza en horizontal y vertical, usas un kernel 1D que se desliza a lo largo del tiempo. Detecta patrones temporales: picos, valles, cambios de tendencia.

Las redes convolucionales 1D fueron muy populares en procesamiento de lenguaje antes de los Transformers. Hoy se siguen usando en análisis de series temporales y detección de anomalías en sensores.

---

Implementación completa en PyTorch

Vamos a construir una CNN desde cero para clasificar imágenes del dataset CIFAR-10 (10 clases de objetos cotidianos: aviones, coches, pájaros, gatos...). El dataset tiene imágenes de 32×32 píxeles en color.

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms

# 1. Preparar los datos
transform = transforms.Compose([
    transforms.RandomHorizontalFlip(),      # aumento de datos
    transforms.RandomCrop(32, padding=4),   # aumento de datos
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

trainset = torchvision.datasets.CIFAR10(
    root='./data', train=True, download=True, transform=transform
)
trainloader = torch.utils.data.DataLoader(
    trainset, batch_size=128, shuffle=True, num_workers=2
)

# 2. Definir la CNN
class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        # Bloque 1: 32x32 -> 16x16
        self.conv1 = nn.Conv2d(3, 64, kernel_size=3, padding=1)
        self.bn1 = nn.BatchNorm2d(64)
        self.pool = nn.MaxPool2d(2, 2)

        # Bloque 2: 16x16 -> 8x8
        self.conv2 = nn.Conv2d(64, 128, kernel_size=3, padding=1)
        self.bn2 = nn.BatchNorm2d(128)

        # Bloque 3: 8x8 -> 4x4
        self.conv3 = nn.Conv2d(128, 256, kernel_size=3, padding=1)
        self.bn3 = nn.BatchNorm2d(256)

        # Clasificador
        self.fc1 = nn.Linear(256 * 4 * 4, 512)
        self.dropout = nn.Dropout(0.5)
        self.fc2 = nn.Linear(512, 10)

    def forward(self, x):
        x = self.pool(torch.relu(self.bn1(self.conv1(x))))   # 32->16
        x = self.pool(torch.relu(self.bn2(self.conv2(x))))   # 16->8
        x = self.pool(torch.relu(self.bn3(self.conv3(x))))   # 8->4
        x = x.view(x.size(0), -1)                            # flatten
        x = torch.relu(self.fc1(x))
        x = self.dropout(x)
        x = self.fc2(x)
        return x

# 3. Entrenar
model = CNN().cuda()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

for epoch in range(20):
    running_loss = 0.0
    for images, labels in trainloader:
        images, labels = images.cuda(), labels.cuda()

        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()

    print(f'Época {epoch+1}, pérdida: {running_loss/len(trainloader):.3f}')

print('Entrenamiento finalizado')

Con esta arquitectura simple y 20 épocas, deberías alcanzar alrededor del 85-88% de precisión en CIFAR-10. No es estado del arte, pero es más que suficiente para entender cómo encajan las piezas.

---

Data Augmentation: multiplicar tu dataset gratis

Si tienes pocas imágenes, no necesitas más datos: necesitas variaciones de los que tienes. La data augmentation aplica transformaciones aleatorias durante el entrenamiento:

En PyTorch se aplica fácilmente con torchvision.transforms.

---

Métricas para evaluar una CNN

La precisión (accuracy) no siempre es suficiente. Si tu dataset está desbalanceado (95% perros, 5% gatos), un modelo que siempre diga "perro" tendrá 95% de accuracy pero será inútil.

Para problemas multiclase, la matriz de confusión muestra qué clases se confunden entre sí. Es una herramienta diagnóstica invaluable.

---

Preguntas frecuentes

¿Por qué los kernels suelen ser 3×3 y no más grandes?

Dos convoluciones 3×3 seguidas tienen el mismo campo receptivo que una 5×5, pero con menos parámetros (18 vs 25) y más no linealidades (dos ReLU en lugar de una). VGG demostró que apilar 3×3 es mejor que usar kernels grandes. Hoy en día, 3×3 es el estándar.

¿Cuántas capas convolucionales necesito?

No hay número mágico. Para MNIST, 2 capas bastan. Para ImageNet, necesitas 20-50. La regla empírica: empieza simple y añade complejidad solo si la validación no mejora.

¿Qué es el campo receptivo?

Es el área de la imagen original que influye en una neurona de una capa posterior. Una capa convolucional 3×3 ve 3×3 píxeles. Dos capas 3×3 ven 5×5. Tres capas ven 7×7. Las capas de pooling aumentan el campo receptivo rápidamente. Para reconocer un objeto completo, necesitas que el campo receptivo sea comparable al tamaño del objeto.

¿Las CNN funcionan con imágenes en blanco y negro?

Sí. En ese caso la entrada tiene 1 canal en lugar de 3. La primera convolución sería nn.Conv2d(1, 64, ...) en lugar de Conv2d(3, 64, ...). MNIST es el ejemplo clásico.

¿Por qué la precisión en entrenamiento sube pero en validación se estanca?

Es el clásico sobreajuste. La red está memorizando las imágenes de entrenamiento en lugar de aprender patrones generales. Soluciones: más datos, data augmentation, dropout más agresivo, o regularización L2.

¿Qué diferencia hay entre stride y pooling?

Ambos reducen el tamaño espacial. Stride lo hace durante la convolución (el filtro salta píxeles). Pooling lo hace en una operación separada después. Stride es más eficiente computacionalmente. Pooling es más explícito y a veces preserva mejor la información (especialmente max pooling).

¿Puedo usar una CNN para datos tabulares?

No es lo habitual. Los datos tabulares no tienen estructura espacial local. Para eso están los árboles de decisión, XGBoost o redes densas. Las CNN brillan donde hay correlación espacial o temporal local.

¿Qué GPU necesito para entrenar?

Para datasets pequeños (MNIST, CIFAR-10), una GPU de 4-6GB como una GTX 1660 o RTX 3060 basta. Para ImageNet o arquitecturas grandes, necesitas 16-24GB (RTX 4090, A100). Si no tienes GPU, Google Colab te presta una gratis con 12-16GB.

¿Cuánto tarda en entrenar?

CIFAR-10 con la arquitectura de arriba: 10-20 minutos en una GPU moderna. ImageNet desde cero: días o semanas en múltiples GPUs. Por eso el transfer learning es tan popular.

¿Dónde puedo ver filtros entrenados reales?

TensorBoard (TensorFlow) y Weights & Biases permiten visualizar los filtros de cada capa. También puedes usar librerías como torch-cnn-visualizer o keras-vis para generar imágenes que maximicen la activación de neuronas específicas. Es una forma fascinante de entender qué "ve" la red.

---

Relacionado: Si ya dominas las CNN y quieres entender la arquitectura que las desafió en visión por computador, lee Transformadores: qué son, cómo funcionan y por qué lo cambiaron todo.