Convolution

La convolución consiste en deslizar por una entrada una pequeña cuadrícula de pesos, llamada kernel o filtro, y calcular una suma ponderada en cada posición. En visión por computador (CV), la entrada es una imagen o una pila de mapas de características, y cada kernel produce un mapa de salida con valores altos allí donde aparece su patrón: un borde vertical, una zona con textura o, en las capas más profundas de una red, parte de una rueda o de una cara. Desde hace mucho tiempo se usan kernels diseñados manualmente en el procesamiento de imágenes para desenfocar, enfocar y detectar bordes. En una red neuronal convolucional (CNN), los valores del kernel son pesos del modelo que se aprenden durante el entrenamiento, así que la red descubre sus propios detectores de características.

Cómo funciona la convolución#

En cada posición, el kernel se coloca sobre una zona de la entrada, cada peso del kernel se multiplica por el valor de entrada que tiene debajo y los productos se suman, junto con un sesgo, para obtener un valor de salida. Al desplazar el kernel por toda la altura y anchura se genera un mapa de salida bidimensional. Las entradas reales tienen varios canales, como los canales rojo, verde y azul de una imagen, así que cada kernel abarca todos los canales de entrada: un kernel de 3×3 aplicado a una entrada de 64 canales contiene 3 × 3 × 64 = 576 pesos y sigue generando un solo canal de salida. Una capa convolucional aplica muchos kernels de este tipo, y el número de kernels determina el número de canales de salida; por tanto, una capa que pasa de 64 a 128 canales con kernels de 3×3 tiene 3 × 3 × 64 × 128 = 73.728 pesos.

El mismo kernel se reutiliza en todas las posiciones, por eso las capas convolucionales necesitan muchos menos parámetros que las capas totalmente conectadas y un patrón aprendido en una esquina de la imagen se reconoce en cualquier otra. Si se desplaza la entrada, la salida se desplaza en la misma medida; esta propiedad se llama equivariancia a la traslación. Cada valor de salida depende solo de una pequeña zona de la entrada, y apilar capas amplía el campo receptivo que resume un valor de salida profundo, desde unos pocos píxeles hasta la mayor parte de la imagen.

En realidad, las bibliotecas de aprendizaje profundo calculan correlación cruzada: la convolución matemática invierte el kernel antes de deslizarlo, pero Conv2d de PyTorch no lo hace. Como el kernel se aprende, la red simplemente aprende los pesos invertidos, y en la práctica ambos métodos son intercambiables. Las bibliotecas para GPU, como cuDNN, suelen reformular la convolución como una multiplicación de matrices grande o usar algoritmos basados en Winograd o FFT, que calculan el mismo resultado más rápido que deslizar literalmente el kernel.

Paso, relleno, dilatación y grupos#

Cuatro hiperparámetros controlan la forma de la salida de una convolución y el coste de calcularla:

• Paso: La distancia entre las posiciones del kernel. Un paso de 2 omite una posición de cada dos y reduce a la mitad la altura y anchura de la salida; así es como muchas CNN modernas reducen la resolución.
• Relleno: Valores adicionales, normalmente ceros, que se añaden alrededor del borde de la entrada. Un relleno de 1 mantiene la salida de una convolución de 3×3 del mismo tamaño que la entrada cuando el paso es 1.
• Dilatación: Separa los puntos de muestreo del kernel; así, un kernel de 3×3 con dilatación 2 cubre un área de 5×5 con los mismos nueve pesos y amplía el campo receptivo sin coste adicional.
• Grupos: Divide los canales en grupos independientes. Si hay un grupo por canal, una convolución en profundidad filtra cada canal por separado, y una convolución puntual de 1×1 posterior mezcla los canales. Esta pareja se llama convolución separable en profundidad y MobileNets la popularizó para el hardware móvil.

Para una entrada de tamaño n, un kernel de tamaño k, un relleno p, un paso s y una dilatación d, el tamaño de salida es ⌊(n + 2p − d(k − 1) − 1) / s⌋ + 1. El fragmento siguiente aplica cuatro capas que transforman cada mapa de características de 64 canales y 80×80 en uno de 128 canales:

import torch
from torch import nn

x = torch.randn(1, 64, 80, 80)  # a 64-channel, 80x80 feature map

# Four ways to map 64 input channels to 128 output channels
layers = {
    "standard 3x3": nn.Conv2d(64, 128, kernel_size=3, padding=1, bias=False),
    "stride 2": nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1, bias=False),
    "dilation 2": nn.Conv2d(64, 128, kernel_size=3, padding=2, dilation=2, bias=False),
    "depthwise separable": nn.Sequential(
        nn.Conv2d(64, 64, kernel_size=3, padding=1, groups=64, bias=False),  # one 3x3 filter per channel
        nn.Conv2d(64, 128, kernel_size=1, bias=False),  # 1x1 convolution mixes channels
    ),
}
for name, layer in layers.items():
    params = sum(p.numel() for p in layer.parameters())
    print(f"{name}: output {tuple(layer(x).shape)}, {params:,} weights")

La capa estándar genera (1, 128, 80, 80) con 73.728 pesos. El paso 2 reduce a la mitad la salida a (1, 128, 40, 40) con los mismos pesos, y la dilatación 2 mantiene el tamaño de 80×80 y los 73.728 pesos, mientras cada salida abarca un área de 5×5. La pareja separable en profundidad produce la misma salida (1, 128, 80, 80) con solo 8.768 pesos, unas 8,4 veces menos. YOLO26 usa ambas ideas: cinco convoluciones de 3×3 con paso 2 reducen una imagen de 640×640 a la cuadrícula de 20×20 de su mapa de características más profundo de la red troncal, y la rama de clasificación de su cabezal de detección combina convoluciones en profundidad de 3×3 y puntuales de 1×1 para reducir el cálculo.

Convolución en otras dimensiones#

• Convolución 1D: Se desplaza a lo largo de un único eje y se usa con formas de onda de audio, señales de sensores y series temporales.
• Convolución 3D: Añade un eje de profundidad o tiempo y se usa con clips de vídeo y exploraciones volumétricas, como las TC y las RM de análisis de imágenes médicas.
• Convolución transpuesta: Extiende cada valor de entrada por una salida más grande y aumenta la resolución de los mapas de características en modelos de segmentación como U-Net. Restaura el tamaño espacial que redujo una convolución con paso, usando sus propios pesos aprendidos.

Convolución y operaciones relacionadas#

• Capa totalmente conectada: Conecta cada entrada con cada salida mediante un peso propio. Una convolución es una capa totalmente conectada restringida a zonas locales, con pesos compartidos entre posiciones.
• Agrupación: Desliza una ventana como una convolución, pero aplica una regla fija, como tomar el máximo, sin pesos aprendidos.
• Autoatención: Calcula pesos entre cada pareja de posiciones en función de los datos, por lo que relaciona partes distantes de una imagen en una sola capa. Una convolución aplica el mismo kernel fijo en todas partes y solo ve una ventana local, lo que mantiene su coste lineal respecto al número de píxeles.
• Filtrado de imágenes: Los filtros clásicos, como el desenfoque gaussiano y el detector de bordes de Sobel, son convoluciones con kernels fijos diseñados manualmente. filter2D de OpenCV también calcula la correlación, igual que las bibliotecas de aprendizaje profundo, y al invertir el kernel se obtiene una convolución propiamente dicha.