🧮 Computational Mathematics

Inicio · Parte 15 — Matemática de Deep Learning

310 — Convolución discreta

deep-learning clase 10 de 20 4 horas demostración discrete_convolution

El tamaño de salida sale de una fórmula, y equivocarla es el error más común al montar una CNN.

Fórmulas

salida = ⌊(n + 2p − k)/s⌋ + 1
padding 'same' con s=1: p = (k−1)/2
parámetros de la capa: k²·c_in·c_out + c_out

Desarrollo

La convolución 2D desliza un núcleo sobre una imagen calculando sumas ponderadas locales. Sus tres parámetros geométricos —tamaño del núcleo k, padding p y stride s— determinan el tamaño de la salida mediante una fórmula que conviene tener memorizada, porque el 90 % de los errores al construir una CNN son desajustes de forma.

El padding rellena el borde, normalmente con ceros, y sirve para dos cosas: conservar el tamaño espacial y evitar que los píxeles del borde se usen menos que los del centro. El modo same con stride 1 requiere p = (k−1)/2, que es la razón de que los núcleos suelan tener tamaño impar.

El stride es el salto entre posiciones. Con s = 2 la salida tiene aproximadamente la mitad de tamaño en cada dimensión, lo que sirve como alternativa aprendida al pooling. Las arquitecturas modernas tienden a usar convoluciones con stride en lugar de pooling, porque la reducción se aprende en vez de imponerse.

El núcleo del ejemplo es un filtro de Sobel, un detector clásico de bordes verticales diseñado a mano en los años 60. En una CNN, un núcleo con esa forma emerge del entrenamiento sin que nadie lo programe: las primeras capas aprenden detectores de bordes y de color porque son las características más útiles para casi cualquier tarea visual.

Ejemplo trabajado

Sobel vertical sobre una entrada 5×5.

entrada: 5×5      kernel: 3×3 (Sobel vertical)

kernel = [[−1  0  1]
          [−2  0  2]
          [−1  0  1]]

salida con stride 1, sin padding:
  [[ 8,0  −16,0  −22,0]
   [ 6,0  −13,0  −21,0]
   [ 0,0    0,0   −2,0]]
  forma: (3, 3)

Fórmula: (5 + 0 − 3)/1 + 1 = 3                       ✓

con stride 2:  (5 + 0 − 3)/2 + 1 = 2  →  forma (2,2) ✓

Para conservar 5×5 con k=3 y s=1 haría falta p = 1.

Qué calcula el laboratorio

Convolución 2D con padding y stride: el cálculo de la forma de salida.

python classes/part-15-matematica-de-deep-learning/310-convolucion-discreta/lab.py
compmath run 310

Salidas del laboratorio (11)

Muestra de la ejecución real

{
  "entrada_shape": [
    5,
    5
  ],
  "kernel_shape": [
    3,
    3
  ],
  "kernel": [
    [
      -1.0,
      0.0,
      1.0
    ],
    [
      -2.0,
      0.0,
      2.0
    ],
    [
      -1.0,
      0.0,
      1.0
    ]
  ],
  "salida_stride_1": [
    [
      8.0,
      -16.0,
      -22.0
    ],
    [
      6.0,
      -13.0,
      -21.0
    ],
    [
      0.0,
      0.0,
      -2.0
    ]
  ],
  "shape_stride_1": [
    3,
    3
  ],
  "shape_stride_2": [
    2,
    2
  ]
}

Errores comunes

Dónde se usa

Diseño de redes convolucionales, procesamiento de imágenes, detección de bordes y capas convolucionales en audio y series.

Idea rectora de la parte

El gradiente que se desvanece es un producto de derivadas menores que uno.

Error a evitar

Inicializar todos los pesos iguales y romper la simetría nunca.

Conexión con IA

Toda arquitectura moderna, incluido el Transformer, se construye sobre estos bloques y sobre este mismo mecanismo de derivación.

Bibliografía de la clase

Archivos de la clase

← 309 Regularización y dropout 311 CNN y receptive fields →