las ecuaciones de esta slide
W1 ∈ ℝD×HWC,   #pesosMLP = D·H·W·C (+D sesgos)(nota, §1)
aplanar la imagen H×W×C da HWC entradas; la primera capa de un MLP de anchura D necesita un peso por cada par (neurona, píxel). Para 224×224×3 y D = 1024 son 1.5·108 parámetros solo en la primera capa.
#pesosconv = (k·k·Cin+1)·Cout(pesos compartidos)
una capa convolucional reusa el mismo kernel k×k en todas las posiciones: su coste no depende de H ni de W. La CNN pequeña de esta demo (32–64–128 filtros 3×3 + cabeza de 10 clases) se calcula con esta fórmula capa a capa.
guion paso a paso
  1. Deja D = 1024 y C = 3 y sube R de 28 a 224. La curva tinta (MLP) sube dos órdenes de magnitud; la dorada (CNN) ni se inmuta: el coste de la conv no depende de la resolución.
  2. Con R = 224, lee el lector: deberías ver ≈1.5·108 pesos de MLP, el número exacto de la nota técnica. A 4 bytes por peso son ≈590 MB solo de primera capa.
  3. Duplica D a 2048. El MLP se duplica; la CNN no cambia: D solo existe en el mundo MLP.
  4. Baja R a 28 (tamaño Fashion-MNIST). Ahí el MLP aún es viable (≈2.4M pesos): por eso los MLP "funcionaban" en los datasets pequeños de los 90.
Comprueba que entiendes: si duplico la resolución R, ¿por cuánto se multiplica cada modelo?
El MLP por 4: sus pesos crecen como R² (D·R²·C). La parte convolucional por 1: (k²Cin+1)Cout no contiene R. Lo único que crece en la CNN es el cómputo (más posiciones donde aplicar el kernel) y la memoria de activaciones, no los parámetros que hay que aprender con datos finitos.

Setup. Mercadona quiere detectar lineales vacíos con una cámara por pasillo. La imagen llega como matriz R×R×C. Arriba: número de parámetros (escala log) en función de R para un MLP con D neuronas ocultas (tinta) y para una CNN pequeña de tres capas 3×3 con 32, 64 y 128 filtros más cabeza de 10 clases (dorado). Abajo: las dos barras a tu configuración actual, con su memoria en MB (float32).

Juega. Mueve R y mira cómo la curva tinta crece como R² mientras la dorada es plana. Mueve D: solo se mueve el MLP. El punto dorado y el punto tinta marcan tu configuración en ambas curvas.

Lee así. El cociente del lector (×MLP/CNN) es el factor de ahorro de la convolución. Con menos parámetros que estimar, la CNN entrena con los pocos miles de fotos etiquetadas que una empresa puede pagar; el MLP necesitaría millones.

Mensaje. No es solo memoria: cada peso es algo que hay que aprender de datos. La CNN gana porque incorpora dos sesgos inductivos correctos para imágenes: localidad (solo conecta vecinos) y equivarianza por traslación (el mismo detector vale en toda la imagen).

Términos. Aplanar: convertir la matriz H×W×C en un vector de HWC números, perdiendo la estructura espacial. Sesgo inductivo: supuesto estructural que la arquitectura impone antes de ver datos. float32: 4 bytes por parámetro.

las ecuaciones de esta slide
Yi,j,o = Σu=0..k-1 Σv=0..k-1 Σc=1..Cin Xi+u, j+v, c·Ku,v,c,o + bo(Ec. 1)
la convolución: el valor de salida en la posición (i,j) del canal o es la suma ponderada del parche k×k que empieza en (i,j), con los pesos del kernel K, más un sesgo bo. Aquí Cin = 1 (escala de grises) y b = 0, así que quedan los 9 productos que ves en el lector.
1·1 + 0·0 + 2·(−1) + 0·1 + 1·0 + 3·(−1) + 2·1 + 1·0 + 0·(−1) = −2(ejemplo de clase, 5×5)
el cálculo a mano del deck: parche (1,0,2 / 0,1,3 / 2,1,0) por el kernel de bordes verticales (1,0,−1 / 1,0,−1 / 1,0,−1). El lector de esta slide reproduce exactamente esta aritmética para la celda que elijas.
guion paso a paso
  1. Con el kernel "borde vertical", arrastra la posición de 0 a 35 despacio. El feature map solo se enciende (valor 3) en las dos columnas cuya ventana pisa la transición de 1 a 0: el kernel es un detector de ese borde.
  2. Haz clic en varios píxeles de la imagen para abrir un hueco en el borde. El feature map se apaga exactamente ahí: la convolución es local, solo ve su parche 3×3.
  3. Cambia a "borde horizontal". El mapa queda casi a cero: esta imagen no tiene bordes horizontales que detectar. Cada kernel busca UN patrón.
  4. Pulsa "blur" y luego "identidad" mirando el lector. Blur promedia el parche (salida suave entre 0 y 1); identidad copia el píxel central: la convolución generaliza ambas cosas.
Comprueba que entiendes: ¿por qué el feature map es 6×6 si la imagen es 8×8?
Porque el kernel 3×3 solo cabe en posiciones donde el parche completo está dentro de la imagen: 8−3+1 = 6 posiciones por fila y por columna. Es el caso p = 0 (sin padding), s = 1 de la fórmula o = ⌊(i+2p−k)/s⌋+1 de la siguiente slide: ⌊(8+0−3)/1⌋+1 = 6.

Setup. Imagen de juguete 8×8 con un borde vertical (mitad izquierda a 1, mitad derecha a 0), como la frontera entre estante lleno y estante vacío en la foto del lineal. El kernel 3×3 se desliza por las 36 posiciones válidas; la ventana actual se dibuja en dorado sobre la imagen y su celda de salida se marca en el feature map. La imagen es editable: clic en un píxel lo conmuta 0↔1. El kernel también: clic en una celda del kernel la hace ciclar por −2, −1, 0, 1, 2.

Juega. El lector escribe los 9 productos de la Ec. (1) para la posición elegida, exactamente como el ejemplo a mano de clase (el del parche 5×5 que da −2, o el de la imagen 4×4 cuya salida 2×2 era 3, −3, 0, 3). Comprueba dos o tres celdas a mano: es la misma cuenta.

Lee así. Un valor grande positivo dice "aquí el parche se parece a la plantilla"; cero dice "nada que ver". Una capa convolucional real hace esto con 32–512 kernels en paralelo, cada uno aprendido por backprop, no diseñado a mano como aquí.

Mensaje. Los 9 números del kernel son los únicos parámetros, y se reusan en las 36 posiciones: pesos compartidos. El MLP de la slide anterior habría usado 36×9 parámetros distintos para hacer esto mismo.

Términos. Kernel / filtro: plantilla k×k de pesos. Parche: trozo k×k de la imagen bajo el kernel. Feature map: matriz de salida, una activación por posición. Sobel: kernel clásico de bordes con fila central reforzada (1,2,1 en vez de 1,1,1).

la ecuación de esta slide
o = ⌊i + 2p − ks⌋ + 1(tamaño de salida)
i = tamaño de entrada, p = padding (ceros añadidos a cada lado), k = tamaño del kernel, s = stride (paso del deslizamiento). El numerador i+2p−k es cuánto puede avanzar el kernel; dividir por s cuenta los saltos; el +1 cuenta la posición inicial. El suelo ⌊·⌋ descarta el trozo final si no cabe un salto entero: por eso puede "no encajar".
guion paso a paso
  1. Con i = 8, k = 3, p = 0, s = 1, sube p a 1. La salida pasa de 6 a 8: padding "same", la resolución se conserva. Las celdas punteadas son los ceros añadidos.
  2. Vuelve a p = 0 y sube s a 2. La salida cae de 6 a 3 y aparece el badge "no encaja": (8−3) no es múltiplo de 2 y queda 1 columna sin cubrir a la derecha. El suelo de la fórmula la descarta.
  3. Con s = 2, sube i a 9. Ahora (9−3)/2 = 3 exacto: badge verde. Mismo kernel, misma stride; encajar depende de la aritmética modular.
  4. Mueve t y mira el panel de arriba. La ventana dorada salta de s en s celdas: stride 2 mira una de cada dos posiciones, por eso reduce resolución (y cómputo) a la mitad.
Comprueba que entiendes: ¿qué p hace falta para salida "same" (o = i) con s = 1?
Con s = 1 la fórmula da o = i+2p−k+1; igualando a i queda p = (k−1)/2. Por eso los kernels son de tamaño impar: k = 3 → p = 1, k = 5 → p = 2, k = 7 → p = 3. Con k par no existe un p entero que centre el kernel, y por eso casi no se usan.

Setup. Vista 1D de una fila de la imagen (la fórmula es idéntica para alto y ancho). Arriba: la fila de entrada con sus p ceros de padding a cada lado (celdas punteadas), la ventana del kernel en la posición t (dorado) y la fila de salida; cada celda de salida está unida a la ventana que la produce. Abajo: la salida o en función de i para tus k, p, s actuales; la escalera que ves es el suelo ⌊·⌋ en acción.

Juega. El badge avisa cuando (i+2p−k) no es múltiplo de s: hay columnas de entrada que ninguna ventana cubre. En una CNN real eso significa tirar información del borde derecho/inferior de la foto del producto; con p bien elegido no se tira nada.

Lee así. En el panel inferior, el tramo plano de la escalera son tamaños de entrada distintos que producen la misma salida: información descartada por el suelo. Cuando la curva pasa por tu i actual sin tramo plano, el encaje es exacto.

Mensaje. Padding y stride son las dos perillas de ingeniería de toda arquitectura CNN: p conserva resolución y bordes, s la reduce deliberadamente (las arquitecturas modernas prefieren stride 2 a max-pool agresivo, como dice la nota del día).

Términos. Padding: orla de ceros añadida alrededor de la imagen. Stride: paso con que se desliza el kernel. "same": configuración que mantiene o = i. ⌊x⌋: mayor entero ≤ x.

las ecuaciones de esta slide
Yi,j,c = máx0≤u,v<kp Xi·s+u, j·s+v, c(max-pooling)
cada celda de salida es el máximo de una ventana kp×kp del feature map, con paso s = kp (ventanas sin solape). Se queda con "el detector más activado de la zona" y olvida en qué píxel exacto se activó.
Yi,j,c = 1kp² Σ0≤u,v<kp Xi·s+u, j·s+v, c(average pooling)
la variante media: sustituye el máximo por el promedio de la ventana. Conserva más información de nivel pero diluye los picos; el max es más invariante a dónde cae exactamente la activación.
guion paso a paso
  1. Pulsa el botón de desplazar y vuelve a pulsarlo, mirando el feature map central. Las dos franjas activadas (+3 en el flanco izquierdo, −3 en el derecho) saltan de columna: el feature map es EQUIVARIANTE, se mueve con la imagen.
  2. Mira las barras del panel inferior con kp = 2 y max. El feature map cambia un 100%; el mapa pooleado, un 67%: el pooling ha absorbido un tercio del desplazamiento.
  3. Sube kp a 3. El mapa pooleado no cambia NADA (0%): la ventana 3×3 traga el píxel de desplazamiento entero. Más invariancia, pero solo quedan 2×2 celdas de resolución.
  4. Con kp = 2, activa average pooling. El cambio vuelve al 100%: la media nota cualquier valor que se mueva dentro de la ventana; el max solo nota si el pico entra o sale de ella.
Comprueba que entiendes: ¿por qué el max-pool es más invariante que la media a traslaciones pequeñas?
Si el pico de activación se mueve 1 píxel pero sigue dentro de la misma ventana kp×kp, el máximo de esa ventana no cambia en absoluto. La media sí cambia en cuanto cualquier valor de la ventana cambia. El precio del max es que tira el resto de la información de la ventana: solo sobrevive "el patrón está aquí", no "cuánto ni exactamente dónde".

Setup. Imagen 8×8 con una barra vertical de 3 píxeles (el montante de la estantería en la foto del lineal) y el mismo kernel detector de bordes verticales de la slide anterior, que produce +3 en el flanco izquierdo de la barra y −3 en el derecho. Arriba: imagen → feature map 6×6 → mapa pooleado (3×3 con kp = 2, 2×2 con kp = 3). El botón desplaza la imagen entera un píxel a la derecha, como cuando la cámara del lineal vibra entre dos fotos del mismo estante. Abajo: cambio relativo medio (en %) que ese desplazamiento provoca en el feature map y en el mapa pooleado, calculado de verdad sobre las dos versiones.

Juega. El cociente entre las dos barras es la ganancia de invariancia: cuántas veces menos cambia la representación tras el pooling. Compara kp = 2 con kp = 3 y max con media.

Lee así. Para el clasificador "estante lleno/vacío" lo que importa es si hay borde de estante, no en qué píxel exacto cae. El pooling convierte equivarianza (el mapa se mueve con la imagen) en invariancia aproximada (la salida apenas se mueve).

Mensaje. Pooling = perder resolución a propósito para ganar robustez y reducir cómputo. En arquitecturas modernas el mismo efecto se consigue con stride 2 en la propia convolución, pero el principio es idéntico.

Términos. Equivariante: si la entrada se traslada, la salida se traslada igual. Invariante: la salida no cambia aunque la entrada se traslade. kp: lado de la ventana de pooling. Cambio relativo: media de |Δ| dividida por la media de |valores|.

las ecuaciones de esta slide
hv = ReLU(X ∗ Kv),   hh = ReLU(X ∗ Kh)(capa 1: bordes)
dos aplicaciones de la Ec. (1) con kernels distintos: Kv detecta el borde vertical izquierdo (columnas −1, 0, 1) y Kh el borde horizontal superior (filas −1, 0, 1). La ReLU (max(0,·)) descarta las respuestas negativas: nos quedamos con "borde en la orientación buscada", no su opuesto.
esquina = ReLU(hv ∗ Wv + hh ∗ Wh − b2)(capa 2: composición)
la segunda capa es la Ec. (1) con Cin = 2: suma las contribuciones de los DOS canales de entrada. Wv busca una línea vertical de activaciones en hv y Wh una horizontal en hh; solo donde coinciden ambas (la esquina) se supera el umbral b2.
guion paso a paso
  1. Mueve c0 una posición a la derecha mirando el panel inferior. El pico del detector de esquinas se mueve exactamente una posición a la derecha: toda la pila conv+conv es equivariante.
  2. Mira los dos mapas intermedios. hv dibuja solo el lado izquierdo del cuadrado, hh solo el lado superior: cada kernel de la capa 1 extrae UNA primitiva.
  3. Baja b2 a 0. El mapa de esquinas se ensucia: cualquier borde aislado ya activa algo. El umbral es lo que exige la COINCIDENCIA de las dos primitivas.
  4. Sube b2 a 12. Todo se apaga, incluso la esquina: un umbral demasiado exigente mata el detector. En una CNN real, b2 es un parámetro más que el entrenamiento ajusta solo.
Comprueba que entiendes: ¿por qué la capa 2 necesita Cin = 2 y no puede hacerlo un solo kernel sobre la imagen?
Un kernel 3×3 sobre la imagen solo ve un parche 3×3: en ese parche una "esquina" y un "borde" pueden ser indistinguibles. La capa 2 no mira píxeles: mira los mapas de bordes ya calculados, y pregunta "¿hay evidencia vertical Y horizontal a la vez aquí?". Además su campo receptivo efectivo sobre la imagen ya es 5×5 (siguiente slide). Esa es la jerarquía: bordes → esquinas → partes → objetos, cada capa componiendo lo anterior.

Setup. Imagen 12×12 con un cuadrado 5×5 (una "prenda" en la foto de catálogo de Zara, si quieres). Arriba: la imagen y los dos mapas de la capa 1 (bordes verticales izquierdos, bordes horizontales superiores), ya pasados por ReLU. Abajo: la salida de la capa 2, que combina ambos canales y resta el umbral b2; el círculo dorado marca su máximo. Todo se recalcula con las dos convoluciones de verdad cada vez que mueves un slider.

Juega. El lector compara la posición del pico con la esquina superior izquierda real del cuadrado: se mueven juntos, casilla a casilla. Eso es lo que significa "composición jerárquica" en el deck: la capa 2 no ve píxeles, ve primitivas.

Lee así. En una ResNet entrenada con fotos de producto pasa lo mismo a lo grande: capa 1 bordes y colores, capas medias texturas y partes (cuello, manga, botones), capas altas prendas completas. Nadie diseña esos kernels: el gradiente los encuentra.

Mensaje. La profundidad no es un capricho: es el mecanismo por el que detectores simples y baratos se componen en detectores complejos. Dos capas 3×3 ya detectan algo (esquinas) que ninguna de ellas puede detectar sola.

Términos. ReLU: max(0,x), apaga lo negativo. Primitiva: patrón simple de capa baja (borde, esquina). Canal: cada feature map de una capa; la capa siguiente los suma con sus propios pesos (Σc de la Ec. 1). b2: sesgo negativo que actúa de umbral de coincidencia.

la ecuación de esta slide
RFl = RFl−1 + (k−1)·Πi=1..l−1 si,   RF0 = 1(campo receptivo)
cada capa con kernel k añade (k−1) píxeles de alcance, multiplicados por el producto de strides anteriores: si antes hubo un pooling de stride 2, cada paso de la capa actual vale 2 píxeles de la imagen original. Con k = 3 y s = 1: RF = 3, 5, 7, 9, … (el 3 → 5 → 7 del deck); con poolings intercalados el crecimiento se acelera.
guion paso a paso
  1. Con k = 3, s = 1 y sin pooling, sube L hasta que la curva cruce la línea del objeto de 50 px. Hacen falta 25 capas: el "para un objeto de 50 px necesitas ∼25 capas 3×3" del deck, calculado en vivo.
  2. Activa el pooling intercalado con L = 8. El campo receptivo salta de 17 a 68 píxeles: los strides multiplican el alcance de todas las capas posteriores. Así es como ResNet cubre 224 px con kernels de 3.
  3. Sube k a 7 sin pooling. Cada capa suma 6 en vez de 2: menos capas para el mismo alcance, pero (siguiente slide) muchos más parámetros por capa. VGG demostró en 2014 que apilar 3×3 sale más barato.
  4. Sube O a 100 px. El punto de cruce se va aún más lejos: objetos más grandes exigen más profundidad o más pooling. La profundidad de ResNet-50 no es capricho.
Comprueba que entiendes: una neurona de la capa 2 (k = 3, s = 1), ¿qué ve exactamente de la imagen?
Ve un parche 5×5. Su entrada es un parche 3×3 del feature map 1, y cada una de esas 9 activaciones ve a su vez un parche 3×3 de la imagen; las 9 ventanas se solapan y su unión es 5×5. Es la fórmula: RF₂ = 3 + (3−1)·1 = 5. Por eso el detector de esquinas de la slide anterior podía ver "más" que un solo kernel: operaba con campo receptivo 5×5.

Setup. Arriba: el campo receptivo RFl capa a capa (curva dorada), la talla del objeto a reconocer (línea discontinua) y el punto donde la red por fin "ve" el objeto completo. Abajo: el cono de visión: una neurona de la última capa arriba, y el ensanchamiento de lo que alcanza a ver capa a capa hasta los píxeles de la imagen abajo. Todo sale de iterar la fórmula del panel, con los strides de pooling si los activas.

Juega. El lector da el RF final, la instancia numérica de la fórmula para las tres primeras capas y el número de capas necesario para tu objeto. Si la curva no llega, te lo dice.

Lee así. Piensa en la foto del lineal de Mercadona: una balda vacía ocupa 80–150 px. Una CNN de 3 capas sin pooling (RF = 7) es físicamente incapaz de verla entera, por mucho que entrenes: el campo receptivo es una cota dura de lo que la arquitectura puede representar.

Mensaje. Profundidad y pooling no solo añaden capacidad: ensanchan lo que cada neurona puede ver. "Deep" en deep learning es, para visión, una necesidad geométrica.

Términos. RFl: lado del cuadrado de píxeles de la imagen original que influye en una neurona de la capa l. Πsi: producto de los strides de las capas anteriores ("jump"). Cono de visión: la pirámide invertida de dependencias entre capas.

las ecuaciones de esta slide
#paramsconv = (k·k·Cin + 1)·Cout(capa convolucional)
cada uno de los Cout kernels tiene k·k·Cin pesos (la Σc de la Ec. 1 atraviesa los canales de entrada) más 1 sesgo bo. No aparece H ni W: pesos compartidos en el espacio.
#paramsdensa = (H·W·Cin + 1)·(H·W·Cout)(capa densa equivalente)
la capa totalmente conectada que produce el mismo tensor de salida H×W×Cout: cada activación de salida tiene su propio peso hacia cada entrada. Crece como H²W²: cuarta potencia de la resolución.
guion paso a paso
  1. Sube H de 8 a 64 mirando las dos barras. La densa gana cuatro órdenes de magnitud; la conv no se mueve ni un píxel: H no está en su fórmula.
  2. Sube k de 3 a 7 con H = 32. La conv se multiplica por ≈5.4 (49/9). Caro, pero sigue siendo ridículo al lado de la densa. Es el trade-off de la slide del campo receptivo: k grande compra alcance pagando parámetros.
  3. Pon Cin = 3, Cout = 32, k = 3 (primera capa típica). 896 parámetros: el (9·3+1)·32 que puedes comprobar a mano. Así empieza una ResNet de verdad.
  4. Mira el panel inferior y localiza dónde se cruzarían las curvas. Nunca se cruzan: para cualquier H ≥ k la conv es más barata, y la brecha crece como H⁴.
Comprueba que entiendes: ¿por qué la conv es un caso particular de la densa con restricciones?
La densa equivalente tiene una matriz gigante de pesos entre entrada y salida. La conv impone dos restricciones sobre esa matriz: (i) localidad: el peso es 0 si la entrada está a más de k/2 de la salida; (ii) compartición: los pesos no nulos son los mismos en todas las posiciones. El número de parámetros libres cae de (HWCin)(HWCout) a k²CinCout. Menos libertad = menos datos necesarios, siempre que la restricción sea verdadera para imágenes, y lo es.

Setup. La fórmula exacta de coste de una capa convolucional frente a la capa densa que produciría el mismo tensor de salida. Arriba: las dos cantidades en barras (escala log), con la memoria float32 de cada una. Abajo: parámetros en función de la resolución H para tus k, Cin, Cout: la densa es una recta de pendiente 4 en log-log, la conv una horizontal.

Juega. El lector instancia ambas fórmulas con tus números y da el factor de ahorro. Prueba la configuración de una capa intermedia de ResNet (k = 3, Cin = Cout = 64, H = 28) y mira cuántos órdenes de magnitud separan ambos mundos.

Lee así. Esta fórmula es la que el equipo de data science presenta a IT cuando pide presupuesto de GPU: los parámetros del modelo (y su memoria) los fijan k y los canales, no la resolución de las cámaras del lineal.

Mensaje. Junto con la slide 1, esta es la justificación cuantitativa completa de la CNN: misma operación (suma ponderada), dos restricciones estructurales, cuatro órdenes de magnitud menos parámetros.

Términos. Cin, Cout: canales de entrada y salida de la capa. Capa densa: cada salida conectada a todas las entradas. Tensor de activaciones: H×W×C valores que fluyen entre capas (eso sí crece con H).

las ecuaciones de esta slide
y = ℱ(x; {Wi}) + x(bloque residual, Ec. 3 de la nota)
el bloque ResNet: la salida es lo que computan las capas convolucionales ℱ más la propia entrada (skip connection). El bloque ya no aprende "la transformación", aprende "la corrección respecto a la identidad".
∂y∂x = 1 + ℱ′(x)  ⇒   ∂xL∂x0 = Πl=1..L (1 + ℱ′l)  frente a  Πl=1..L ℱ′l(gradiente)
al derivar, la skip añade un 1 a cada factor de la cadena. Sin skip, el gradiente es un producto de factores típicamente <1 que se hunde exponencialmente con L (se "desvanece"); con skip, cada factor ronda 1 y el gradiente llega vivo a las primeras capas.
guion paso a paso
  1. Con g = 0.5, sube L de 5 a 100 mirando la curva tinta. A L = 50 el gradiente plano ronda 10⁻²⁹: numéricamente muerto. La dorada (residual) aguanta en torno a 10⁻⁴: unos 25 órdenes de magnitud de ventaja.
  2. Sube g hacia 1.3. Ahora la curva tinta EXPLOTA hacia arriba: el producto de factores >1 diverge. Sin skip solo existe el filo de la navaja g ≈ 1.
  3. Pulsa "nueva red" varias veces con g = 0.5. Los factores aleatorios cambian, el patrón nunca: desvanecimiento exponencial vs estabilidad. No es mala suerte, es estructura.
  4. Lee el badge con L = 50, g = 0.5. Marca "gradiente desvanecido" para la red plana: antes de 2015 (ResNet), 50 capas eran literalmente inentrenables.
Comprueba que entiendes: ¿por qué |1 + ℱ′| ronda 1 aunque |ℱ′| sea pequeño y aleatorio?
Porque sumar 1 centra el factor en la identidad: si ℱ′ ∼ 0 ± 0.5, entonces 1+ℱ′ ∼ 1 ± 0.5, y el producto de muchos factores centrados en 1 deriva lentamente (paseo aleatorio en log) en vez de hundirse exponencialmente. El bloque "no hacer nada" (ℱ = 0) da exactamente la identidad: añadir capas nunca puede empeorar el óptimo, que era el argumento original del paper de He et al. (2015).

Setup. Veinticinco años de arquitecturas en una frase: LeNet (1998, 5 capas, dígitos de cheques), AlexNet (2012, 8 capas, ImageNet), VGG (2014, 19 capas de puros 3×3) y el muro: más capas empeoraban el entrenamiento. ResNet (2015) lo derriba con la skip connection. El canvas simula la cadena de gradientes: para cada capa l, el módulo del gradiente que llega desde la pérdida (escala log), con factores ℱ′l = g·εl, εl ∼ N(0,1): tinta sin skip (Πℱ′), dorado con skip (Π(1+ℱ′)).

Juega. El producto se calcula de verdad sobre los factores sorteados: el lector da el gradiente que llega a la capa 1 en ambos mundos y su cociente, que con L = 50 y g = 0.5 supera los 20 órdenes de magnitud.

Lee así. La zona g < 1 es el desvanecimiento (curva tinta cayendo en recta: exponencial en escala log); la zona g > 1 es la explosión. La dorada apenas depende de g: esa indiferencia es lo que compra la skip.

Mensaje. ResNet-50/101/152 existen porque y = ℱ(x)+x convierte un producto que se muere en un producto que sobrevive. Es la arquitectura por defecto del transfer learning de la siguiente slide, y la que fine-tunearás en la práctica.

Términos. Skip connection: el "+x" que sortea el bloque. Gradiente desvanecido: producto de jacobianos <1 que decae exponencialmente con la profundidad. ℱ′: derivada local del bloque (aquí un escalar de juguete; en la red real, un jacobiano).

las ecuaciones de esta slide
θ̂ = arg mínθh 1n Σi=1..n ℓ(fθb,θh(xi), yi),  θb = θb(0) fijo(Ec. 4 de la nota)
transfer learning, régimen feature extraction: el backbone θb (preentrenado en ImageNet) se congela y solo se minimiza sobre la cabeza θh. Aquí ℓ es la log-pérdida logística y la cabeza se entrena por descenso de gradiente en tu navegador, de verdad.
coste desde cero ≈ 24 h × 3.0 $/h = 72 $;   coste con transfer ≈ 5 min × 0 $/h = 0 $(cálculo del deck)
el cálculo de coste del deck: ResNet-50 desde cero pide ∼10⁶ imágenes y una A100 un día entero; con el backbone congelado bastan ∼10³ imágenes y la T4 gratuita de Colab. Hugging Face Hub es donde ese trabajo de 72 $ se publica para que lo reuses.
guion paso a paso
  1. Pon n = 40 (lo que una pyme etiqueta en una tarde). La cabeza sobre features preentrenadas ronda ya el 85–90% de acierto en test; desde cero apenas supera el azar.
  2. Sube n despacio hasta 640. La curva "desde cero" mejora (de ≈57% a ≈69%) pero se estanca lejos de la dorada: con features pobres, más datos no bastan. En la realidad, reentrenar el backbone entero solo alcanza al transfer con cientos de miles de fotos.
  3. Pulsa "nueva muestra" varias veces con n = 40 y luego con n = 320. Con n pequeño las accuracies bailan mucho más: menos datos = más varianza, en ambos mundos.
  4. Mira el panel derecho. La frontera (recta) que aprende la cabeza separa las dos nubes: en el espacio de features preentrenadas el problema es casi lineal. Eso es lo que ImageNet te regala.
Comprueba que entiendes: ¿por qué "desde cero" necesita más datos si ambos modelos usan la misma regla de aprendizaje?
Porque estima más parámetros a partir de features peores. Aquí la cabeza preentrenada ajusta 3 números sobre 2 features donde las clases ya están separadas; "desde cero" ajusta 17 sobre 16 dimensiones donde la señal es débil y el resto es ruido, así que con n pequeño memoriza ruido (sobreajuste). En la práctica real la brecha es mucho mayor: 25.5M de parámetros de ResNet-50 contra los miles de la cabeza. Regla del deck: con menos de 50 000 imágenes, transfer casi siempre.

Setup. Clasificador "prenda OK / prenda con defecto" para el control de calidad de Inditex. Simulo el dilema de la Ec. (4): la misma cabeza logística entrenada (i) sobre las 2 features que da un backbone preentrenado, donde las clases forman dos nubes separadas, y (ii) "desde cero", sobre 16 features crudas con señal débil enterrada en ruido. Arriba: accuracy en un test fijo de 500 fotos en función de n (eje log); el marcador es tu n actual. Abajo: tus n puntos de entrenamiento en el espacio de features preentrenadas y la frontera que la cabeza acaba de aprender por descenso de gradiente (200 iteraciones, ejecutadas al mover el slider).

Juega. Cada posición del slider lanza los entrenamientos de verdad: si el navegador tarda una fracción de segundo, es el gradiente trabajando. La curva completa se recalcula al cambiar de semilla.

Lee así. Los tres regímenes de la nota se leen sobre esta gráfica: feature extraction es lo simulado; fine-tuning ligero (descongelar las últimas capas con ηb = ηh/10) interpola entre ambas curvas; fine-tuning completo converge a "desde cero pero con buena inicialización" y solo compensa con ≥10⁴ ejemplos.

Mensaje. La receta de 20 líneas del deck (AutoModelForImageClassification con num_labels=10, backbone congelado, Trainer) es exactamente esta slide con ResNet-50 de backbone: hereda lo caro, entrena lo barato.

Términos. Backbone θb: todas las capas conv preentrenadas. Cabeza θh: la capa final específica de tu problema. ImageNet / 𝒟src: el dataset fuente del preentrenamiento. Feature extraction: backbone congelado, solo cabeza.

las ecuaciones de esta slide
pc = ezcΣd ezd,  decisión: auto si máxc pc ≥ τ, humano si no(softmax + umbral)
la CNN devuelve un softmax sobre las categorías de prenda (las pc suman 1, compruébalo en el lector). El umbral de confianza τ decide qué fotos se etiquetan solas y cuáles van a revisión humana.
ℓcost(ŷ, y) = cFN·y (1−ŷ) + cFP·(1−y) ŷ(pérdida ponderada por coste, nota §6)
la métrica de producción no es la accuracy del benchmark: es el coste operacional de cada tipo de error. Aquí lo instanciamos: etiqueta auto errónea = devolución (cerr €), foto enviada a humano = 0.80 € de revisión. El coste total es la función que el slider τ minimiza.
verdad \ pred.camisetasudaderavestido→ humano
guion paso a paso
  1. Pon τ = 0.34 (todo automático). Cobertura ≈100% pero unos 70 errores: cada uno es una devolución de 12 €. Mira la matriz: la mayoría de los errores pasan por la sudadera, la clase intermedia que solapa con las otras dos.
  2. Sube τ despacio hacia 0.95 mirando el panel inferior. El coste primero baja (quitas errores caros) y luego sube (envías a revisión fotos que iban bien): hay un τ* óptimo marcado en la curva.
  3. Sube la dificultad σ a 1.2. Las nubes se mezclan, el τ* óptimo se desplaza hacia arriba y la franja blanca (zona de duda) se traga más fotos: con un modelo peor conviene delegar más en humanos.
  4. Baja cerr a 4 € (el error sale barato). τ* cae: si equivocarse cuesta poco, compensa automatizar casi todo. El umbral óptimo es una decisión de negocio, no de ML.
Comprueba que entiendes: ¿por qué el coste óptimo no está en τ = 0.34 ni en τ = 0.99?
Porque los dos extremos pagan costes distintos: con τ mínimo pagas todas las devoluciones (errores × cerr); con τ máximo pagas 600 × 0.80 € de revisión humana, como si no hubiera modelo. El óptimo equilibra el coste marginal de un error evitado contra el de una revisión añadida, y por eso depende de cerr, de crev y de la calidad del modelo (σ). Es exactamente la lógica de ℓcost de la nota: la accuracy no aparece por ningún lado.

Setup. Catálogo automático de moda (Inditex): una ResNet fine-tuneada etiqueta cada foto como camiseta, sudadera o vestido. Genero 600 fotos sintéticas en un espacio de 2 features (silueta, textura), con nubes gaussianas por categoría; el clasificador calcula logits por distancia a cada centro y un softmax de verdad. Arriba: el mapa de decisión: color de fondo = clase predicha, franja blanca = zona enviada a humano (máx pc < τ); los puntos son las fotos (color = categoría real, hueco = enviado a humano). Abajo: coste total en euros en función de τ, con tu τ (punto dorado) y el óptimo τ* (rombo).

Juega. El lector da cobertura, accuracy de lo automático, errores, coste total y la comparación contra "todo humano" (480 €) y "todo auto". La matriz de confusión se rellena solo con las fotos decididas automáticamente, más la columna de derivadas a humano.

Lee así. La diagonal de la matriz es dinero ahorrado; lo de fuera de la diagonal son devoluciones; la última columna es el sueldo del revisor. Tres números del softmax convertidos en una cuenta de explotación.

Mensaje. El entregable del día no es "una CNN con 92% de accuracy": es una política (modelo + umbral τ*) que minimiza euros. Así se presenta un proyecto de visión a un comité de dirección.

Términos. Softmax: convierte logits en probabilidades que suman 1. Cobertura: fracción de fotos decididas sin humano. Matriz de confusión: cuántas fotos de la clase verdadera j acaban predichas como ℓ. τ*: umbral que minimiza el coste total.

1 — Por qué no un MLP
Slide: MLP vs CNN
"Aplanar la imagen cuesta D·H·W·C pesos solo en la primera capa (1.5·10⁸ a 224px) y rompe la estructura espacial. Localidad + pesos compartidos: la conv cuesta (k²Cin+1)Cout, independiente de la resolución."
↓
2 — La convolución y sus perillas
Slides: Convolución · Pad & stride · Pooling
"Yi,j,o = ΣΣΣ X·K + b: una suma ponderada local que tú mismo has calculado celda a celda. El tamaño de salida es o = ⌊(i+2p−k)/s⌋+1, y el pooling compra invariancia a pequeñas traslaciones perdiendo resolución a propósito."
↓
3 — Jerarquía y campo receptivo
Slides: Jerarquía · Campo recep.
"Dos convs encadenadas detectan lo que ninguna puede sola (borde → esquina), y RFl = RFl−1 + (k−1)Πsi dice cuántas capas hacen falta para ver un objeto entero: ∼25 capas 3×3 para 50 px. La profundidad es geometría, no capricho."
↓
4 — Arquitecturas: LeNet → ResNet
Slide: ResNet
"LeNet (1998) → AlexNet (2012) → VGG (2014) → el muro del gradiente desvanecido → ResNet (2015): y = ℱ(x)+x convierte Πℱ′ (que muere) en Π(1+ℱ′) (que sobrevive) y desbloquea las 50–152 capas."
↓
5 — Transfer learning con Hugging Face
Slide: Transfer
"θ = (θb, θh): congela el backbone de ImageNet, entrena la cabeza con tus ∼10³ fotos. 72 $ de preentrenamiento heredados gratis del Hub; con <50k imágenes, transfer casi siempre."
↓
6 — La decisión de negocio
Slide: Caso retail
"Softmax + umbral τ + costes (cerr, crev) = política auto/humano con coste en euros. La métrica de producción es ℓcost, no la accuracy del benchmark: el entregable es τ*, no un porcentaje."

En una frase. La CNN gana en imágenes porque impone los sesgos inductivos correctos (localidad, pesos compartidos, jerarquía), ResNet permite apilarlos a la profundidad que el campo receptivo exige, el transfer learning te regala todo ese aprendizaje ya hecho, y el umbral de confianza lo convierte en euros: de los píxeles a la decisión de retail.

Garrido-Merchán — ecgarrido@comillas.edu — Deep Learning para Business Analytics — Día 04 · CNN para visión y retail