Redes neuronales y CNNs

En las lecciones anteriores viste que un modelo es una función con parámetros y que entrenar es ajustarlos. Ahora vamos a abrir la caja: ¿qué cuentas hace por dentro?

La pieza más chica es la neurona. Hace tres cosas:

1. 1

   Multiplica cada entrada por su peso

   Recibe varios números de entrada y a cada uno lo multiplica por un número propio, su peso (weight). El peso dice qué tanto le importa esa entrada, y si la cuenta a favor (positivo) o en contra (negativo).

2. 2

   Suma todo y le agrega su sesgo

   Suma esos productos y les agrega otro número propio, el sesgo (bias), que mueve el resultado hacia arriba o hacia abajo.

3. 3

   Pasa el resultado por una activación

   Al final aplica una función sencilla, la activación, que decide qué sale. La más usada es la ReLU: si el número es negativo, sale 0; si no, sale igual.

¿Para qué la activación?

Parece un detalle, pero sin ella nada funcionaría. Sin activación, una neurona solo multiplica y suma: es una función lineal, una recta. Y si apilas rectas, sale otra recta. Por ejemplo, si una capa hace y = 3x + 1 y la siguiente hace z = 2y − 1, juntas hacen z = 2 × (3x + 1) − 1 = 6x + 1. Otra recta. Cien capas sin activación valen lo mismo que una.

La activación dobla la recta. La ReLU la dobla en el 0: todo lo negativo se aplana. Con muchas neuronas, cada una doblada en un lugar distinto, la red puede formar curvas tan complicadas como haga falta, como la frontera entre «foto de tenis» y «foto de bota». Antes se usaban activaciones suaves, como la sigmoide, que aplasta cualquier número entre 0 y 1; la ReLU se impuso en la década de 2010 porque es baratísima y con ella las redes profundas aprenden más rápido.

Lo que una neurona sola no puede: el XOR

Pongamos a una neurona a contestar «sí» o «no» sobre dos entradas que valen 0 o 1. En vez de la ReLU usa una activación de escalón: si la suma pasa de 0 sale 1 («sí»), y si no, 0 («no»). Dos funciones para probarla: el AND vale 1 solo si las dos entradas valen 1; el XOR («o exclusivo») vale 1 si exactamente una vale 1.

La neurona responde 1 cuando w₁x₁ + w₂x₂ + b > 0 y 0 cuando no. La frontera entre las dos respuestas, w₁x₁ + w₂x₂ + b = 0, es una recta: una neurona sola parte el plano en dos con una recta, y nada más.

Pon los cuatro casos como puntos, con x₁ a lo ancho y x₂ a lo alto. En el AND, el único 1 es la esquina (1, 1), y una recta la aparta: con w₁ = 2, w₂ = 1 y b = −2, solo (1, 1) da una suma positiva (2 + 1 − 2 = 1). En el XOR, los unos están en esquinas opuestas, (0, 1) y (1, 0): cualquier recta que los deje del mismo lado deja también a alguno de los ceros. No es que falten pesos buenos: lo que le pides no se puede dibujar con una recta.

Una neurona así, con escalón, es el perceptrón que Frank Rosenblatt publicó en 1958, una de las primeras neuronas artificiales que aprendían solas. Aprendía el AND, pero nunca el XOR; su historia, con código, está en la sección extra «Del perceptrón a la inicialización». La salida es juntar varias neuronas, en capas.

Una neurona sola traza una recta. Se juntan muchas en una capa: todas reciben las mismas entradas, cada una con sus propios pesos, y cada una saca un número. Las salidas de una capa son las entradas de la siguiente. Eso es una red neuronal.

Cuando cada neurona de una capa ve todas las salidas de la anterior, la capa se llama densa (dense o fully connected). Una red de capas densas con activaciones entre ellas es un MLP (multilayer perceptron, perceptrón multicapa), un nombre que viene del perceptrón, aunque ya no usa escalón. Las capas de en medio se llaman capas ocultas (hidden layers).

El XOR, resuelto con una capa oculta

¿Qué hizo la capa oculta? Movió los puntos: con las coordenadas (h₁, h₂), los dos casos que valen 1 caen juntos en (1, 0), y ahí una recta sí los separa de los ceros (el panel de abajo de la figura). Esa es la idea de toda red neuronal: cada capa acomoda los datos para que a la siguiente le sea más fácil.

Aquí los pesos los puse a mano. En una red de verdad los encuentra el entrenamiento, con la backpropagation que viste en «Cómo aprende un modelo»: una forma de repartir la culpa del error entre todas las capas, también las ocultas. Es justo lo que le faltaba a la regla del perceptrón, que solo sabe corregir la neurona que da la respuesta.

Usar redes con muchas capas es el deep learning (aprendizaje profundo): «profundo» se refiere a la cantidad de capas. Cada capa trabaja sobre lo que encontró la anterior, así que más capas dan más pasos para combinar cosas simples en complicadas. La ResNet-50 de C01 tiene 50 capas con pesos.

Un forward pass con lápiz

Hacer pasar una entrada por todas las capas, de la primera a la última, se llama forward pass (pasada hacia adelante). Es lo que hace el modelo cada vez que responde. Hagamos uno a mano en una red de juguete: 2 entradas → 3 neuronas con ReLU → 2 salidas, una para «Tenis» y otra para «Botas».

Eso es todo lo que hace una red al responder: multiplicar, sumar y aplicar la activación, capa por capa. La ResNet-50 hace lo mismo con la foto de Ana, solo que con unos 4,100 millones de multiplicaciones (cada una con su suma) en lugar de una docena.

Contar parámetros y multiplicaciones

Los parámetros de una red son todos sus pesos y todos sus sesgos. En la red de juguete:

• Capa 1: 2 entradas × 3 neuronas = 6 pesos, más 3 sesgos = 9
• Capa 2: 3 entradas × 2 salidas = 6 pesos, más 2 sesgos = 8
• Total: 9 + 8 = 17 parámetros

La regla sirve para cualquier capa densa: parámetros = entradas × salidas + salidas.

La otra cuenta es cuánto trabajo hace. Cada peso se usa una vez por ejemplo: se multiplica por su entrada y se suma a lo acumulado. Ese par «multiplica y suma» se llama MAC (multiply-accumulate) y es la unidad con que se mide el trabajo de una red. Una capa densa hace entradas × salidas MACs por ejemplo; la red de juguete, 2 × 3 + 3 × 2 = 12.

¿Y si le das la foto entera a un MLP? La calculadora empieza con el clásico de los años 90: dígitos escritos a mano de 28 × 28 píxeles en gris (el dataset MNIST), 128 neuronas ocultas y 10 salidas, una por dígito.

Con los dígitos son 101,770 parámetros. Con la foto de C01 y apenas 128 neuronas ocultas, la primera capa ya tiene 150,528 × 128 + 128 = 19,267,712, tres cuartas partes de la ResNet-50 entera. Y como cada píxel tiene su propio peso, la red tendría que aprender a encontrar el tenis en cada posición por separado. La convolución arregla las dos cosas.

Contar parámetros dice cuánta memoria pide el modelo. Guardado como float32, cada uno ocupa 4 bytes: los 25.6 millones de una ResNet-50 son 25.6 M × 4 B ≈ 102 MB, la primera cuenta de la Ronda en M04 para saber cuánta memoria de GPU necesita.

Contar MACs dice cuánto cálculo pide cada foto: la ResNet-50 hace ≈ 4,100 millones, 4.1 GMACs (G es «giga», mil millones). Cuánto tarda eso en una GPU de verdad lo ves con la T4 de C01 en «En la vida real».

Ya viste el problema del MLP: una foto de 224 × 224 píxeles con 3 colores son 150,528 números, y una sola capa densa de 1,000 neuronas sobre ellos necesitaría 150,528 × 1,000 ≈ 150 millones de pesos, casi 6 veces la ResNet-50 entera. Además desperdicia algo obvio: en una foto lo que importa son los píxeles cercanos entre sí. Un píxel de la esquina tiene poco que decirle a uno del centro.

La solución es la convolución. En vez de que cada neurona vea toda la foto, un filtro chico, por ejemplo de 3 × 3, se va deslizando por la foto. En cada posición mira solo 9 píxeles, los multiplica por sus 9 pesos, suma todo y escribe un número; luego se mueve un lugar y repite.

Nadie programó ese filtro. En una red de verdad, los 9 pesos los encuentra el entrenamiento, y muchos filtros de las primeras capas terminan pareciéndose a detectores de bordes como este.

Canales y mapas de activaciones

Una foto de color no es una cuadrícula sino tres, una por color: rojo, verde y azul. Cada una es un canal. Por eso, un filtro de verdad no es de 3 × 3 sino de 3 × 3 × 3: mira los tres canales a la vez. Son 27 pesos más 1 sesgo = 28 parámetros.

Y una capa no tiene un solo filtro, sino muchos: uno busca bordes verticales, otro horizontales, otro un cambio de color. Cada filtro produce su propia cuadrícula de salida, su mapa de activaciones (feature map), que dice dónde encontró lo que busca. Una capa con 64 filtros produce 64 mapas, y esos son los 64 canales de entrada de la capa siguiente.

Esa es la diferencia de fondo: en una capa densa cada peso se usa una vez por foto; en una convolución, una vez por posición. Por eso la Ronda, en M04, dice que una CNN en GPU, con batches moderados, suele estar limitada por el cálculo y no por la memoria (compute-bound): la GPU pasa más tiempo haciendo cuentas que esperando números de la memoria, porque cada peso que lee lo usa miles de veces.

Stride y padding: el tamaño de la salida

En el ejemplo, la entrada era de 5 × 5 y la salida de 3 × 3: en una fila de 5, una ventana de 3 cabe en 5 − 3 + 1 = 3 posiciones. Dos perillas cambian esa cuenta:

• El stride (paso): cuántos píxeles salta el filtro de una posición a la siguiente. Con stride 2 salta de dos en dos, y la salida queda más o menos de la mitad de ancho y de alto.
• El padding (relleno): un marco de ceros alrededor de la entrada, para que el filtro también se centre en las orillas y la salida no se encoja.

Con las dos, el lado de la salida es:

lado de salida = (n + 2p − k) ÷ s + 1, redondeando la división hacia abajo

Aquí n es el lado de la entrada, k el del filtro, p el padding (filas de ceros por lado) y s el stride. ¿De dónde sale? Con el marco, la entrada mide n + 2p; la primera ventana ocupa k píxeles y caben (n + 2p − k) ÷ s saltos más antes de salirse, más la posición de arranque. Si la división no es exacta, la última ventana no cabe completa y esas columnas se quedan sin visitar.

El stride es la forma barata de achicar: con stride 2 queda la cuarta parte de las posiciones, así que la capa siguiente hace cuatro veces menos cuentas por filtro.

Pooling: resumir para achicar

La otra forma de achicar es el pooling. El más común, el max pooling de 2 × 2, parte el mapa en cuadritos de 2 × 2 y de cada uno se queda con el número más grande. Su tamaño sale de la misma fórmula, con k = 2, s = 2 y p = 0.

Hoy muchas redes achican con convoluciones de stride 2, porque así el achique también aprende. La ResNet-50 usa un solo max pooling, al principio; el resto lo hace con stride 2, y al final un pooling global promedia cada mapa entero en un número.

Por qué las CNNs sirven tan bien para fotos

Una red hecha de convoluciones, activaciones y pooling es una CNN (convolutional neural network, red neuronal convolucional). Les va bien a las fotos por tres razones:

1. Mira de cerca. Cada filtro mira un pedacito, y en una foto el significado está en los píxeles vecinos: un borde, una textura, una agujeta.
2. Usa el mismo filtro en todas partes. El filtro que encuentra una agujeta la encuentra en la esquina o en el centro. El tenis de Ana puede estar en cualquier lugar de la foto y no hay que aprenderlo una vez por cada lugar. Por eso tiene tan pocos parámetros.
3. Arma lo complicado con lo simple. Las primeras capas encuentran bordes y manchas de color. Las de en medio combinan bordes en texturas y formas (una suela, una costura). Las últimas combinan partes en objetos (un tenis). Funciona porque cada capa ve un pedazo de la foto más grande que la anterior: su campo receptivo crece, como verás en la sección extra que sigue. Nadie programa esa jerarquía: sale del entrenamiento.

Ya tienes todas las piezas: convoluciones, ReLU, stride y pooling. La ResNet-50 de C01 las junta así. Las dos franjas del diagrama son las dos partes de toda CNN que clasifica: el backbone, que convierte la foto en 2,048 números, y la cabeza, la última capa, que decide la categoría (las ves a fondo en la sección que sigue).

El atajo que permitió ir profundo

Durante años, apilar más capas parecía la forma obvia de mejorar. Pero a partir de cierta profundidad, una red más profunda acertaba menos, incluso en las fotos de entrenamiento. No era overfitting (que empeora la validación, no el entrenamiento): la red más profunda simplemente era más difícil de entrenar.

En 2015, Kaiming He y sus colegas de Microsoft Research propusieron una solución sencilla, la ResNet (residual network, red residual). Cada grupo de capas, un bloque, tiene un atajo, la conexión residual (skip connection): la entrada del bloque se le suma a su salida.

salida = bloque(x) + x

¿Por qué ayuda tanto? Dos intuiciones:

• Cada bloque solo aprende una corrección. No tiene que reconstruir todo lo que ya traía la entrada, solo lo que hay que agregarle. Si un bloque no sirve, le basta aprender a sacar casi 0, y la entrada pasa por el atajo sin daño. Agregar bloques ya no puede empeorar tanto las cosas.
• El aprendizaje llega hasta abajo. Al entrenar, la corrección del error viaja de la última capa hacia la primera (es la backpropagation). Con 50 capas apiladas, esa señal se debilita en el camino; los atajos le dan una vía directa.

Con esa idea, el equipo entrenó en ImageNet redes de hasta 152 capas y ganó la competencia de 2015.

La ResNet-50, en números

BatchNorm

Hay dos tipos de capa que se portan distinto al entrenar y al responder. Si se te olvida decirle a la red en qué momento está, en producción da respuestas raras sin ningún error: uno de los bugs más clásicos de llevar un modelo a producción.

La primera vive dentro de cada bloque de la ResNet. Los números pueden crecer o achicarse mucho de capa en capa, y eso hace difícil entrenar. La BatchNorm (batch normalization, Ioffe y Szegedy, 2015) los acomoda: en cada canal les resta su promedio y los divide entre su desviación estándar, para que queden alrededor de 0 con una dispersión de más o menos 1. Después los escala y los mueve con dos parámetros propios, que también se entrenan.

La pregunta clave es: ¿el promedio de qué?

• Al entrenar, el de las fotos del batch actual. Y de paso va guardando, a lo largo de todo el entrenamiento, un promedio de esos promedios y de esas desviaciones (un promedio móvil, que pesa más los batches recientes): sus running stats (estadísticas acumuladas).
• Al responder, debe usar esas estadísticas acumuladas, que ya no cambian.

Dropout

El dropout (Srivastava, Hinton y otros, 2014) es una traba contra el overfitting. Al entrenar, en cada paso apaga al azar una fracción de las neuronas, por ejemplo la mitad, y multiplica las que quedan para compensar (con la mitad apagada, por 2). Así la red no puede depender de unas pocas neuronas que memorizaron algo: tiene que repartir lo que sabe. Al responder no apaga nada.

Si se queda en modo entrenamiento en producción, cada request apaga neuronas distintas: la misma foto, enviada dos veces, da dos respuestas diferentes.

El interruptor: model.eval()

En PyTorch, un modelo tiene un interruptor con dos posiciones: model.train() y model.eval(). En modo eval, la BatchNorm usa sus estadísticas acumuladas y el Dropout no apaga nada. Un modelo recién creado o cargado está en modo train, así que el servidor lo cambia una vez, al arrancar (ilustración: necesita PyTorch y un archivo de pesos):

import torch
from torchvision.models import resnet50

model = resnet50(num_classes=500)
model.load_state_dict(torch.load("pesos.pt", weights_only=True))
model.eval()                      # BatchNorm y Dropout en modo inferencia

with torch.inference_mode():      # y además: no guardes nada para aprender
    logits = model(x)

Lo traicionero de este bug es que nada truena: no hay error, la respuesta tiene el formato correcto y en tu notebook la accuracy se veía bien (porque ahí sí llamaste a model.eval()). Solo baja la calidad, en silencio. Por eso la Ronda insiste en la prueba de paridad: comparar, foto por foto, las respuestas del modelo que se sirve contra las del modelo que se evaluó.

Una CNN que clasifica tiene dos partes:

• El backbone («columna vertebral»): todas las capas convolucionales. Recibe la foto y la convierte en una lista de números que describen lo que hay en ella, sus features. Al final del backbone de la ResNet-50, un pooling global promedia cada uno de sus 2,048 mapas de 7 × 7 en un solo número: salen 2,048 números por foto.
• La cabeza (head): lo que convierte esas features en la respuesta de la tarea. En C01 es una sola capa densa que da un logit por categoría: 500 logits. Luego el softmax los vuelve probabilidades y se toman las 5 más altas.

Separarlo así sirve mucho en producción. El backbone es lo caro y lo que sabe «ver»; la cabeza es chica y es la que sabe de tus categorías. Además, esos 2,048 números sirven solos: fotos parecidas dan listas parecidas, útiles para buscar productos similares. Una lista así, donde lo parecido queda cerca, es un embedding, el tema de la siguiente lección.

¿De dónde sale la diferencia entre los 25.6 millones de parámetros de la ResNet-50 original y los 24.5 de la de C01? Solo de la cabeza. Con 1,000 categorías: 2,048 × 1,000 + 1,000 = 2,049,000. Con 500: 2,048 × 500 + 500 = 1,024,500. La diferencia es 1,024,500: 25,557,032 − 1,024,500 = 24,532,532. El backbone, que es casi todo, es idéntico.

Transfer learning y fine-tuning

Entrenar una ResNet-50 desde cero pide muchísimas fotos etiquetadas y mucho tiempo de GPU. Pero hay un atajo: alguien ya la entrenó. ImageNet es un dataset público de fotos etiquetadas; su versión más usada tiene ≈ 1.28 millones de fotos de entrenamiento en 1,000 categorías (perros, coches, frutas, instrumentos…). Un modelo entrenado con ImageNet ya aprendió en su backbone lo que sirve para casi cualquier foto: bordes, texturas, formas, partes de objetos. Y esos pesos se pueden descargar.

Usar lo que un modelo aprendió en una tarea para resolver otra se llama transfer learning (aprendizaje por transferencia). En C01 se hace así:

1. 1

   Partir de un modelo preentrenado

   Se carga la ResNet-50 con los pesos de ImageNet. Su backbone ya sabe «ver».

2. 2

   Cambiar la cabeza

   La cabeza original saca 1,000 logits, uno por cada categoría de ImageNet, que no son las del marketplace. Se quita y se pone una nueva de 2,048 → 500, con pesos al azar.

3. 3

   Seguir entrenando con las fotos propias

   Se entrena con las fotos de C01, con un learning rate chico para no destruir lo que el backbone ya sabía. Eso es el fine-tuning (ajuste fino). En la Ronda, el de C01 usa un learning rate de 0.0003, 8 épocas y batches de 64 fotos, y cabe en una sola GPU en unas horas.

En código, los dos primeros pasos son dos líneas (otra ilustración que necesita PyTorch):

import torch
from torchvision.models import resnet50, ResNet50_Weights

model = resnet50(weights=ResNet50_Weights.IMAGENET1K_V2)   # backbone que ya vio ImageNet
model.fc = torch.nn.Linear(2048, 500)                       # cabeza nueva: 500 categorías

El fine-tuning se puede hacer de dos formas, y se pueden combinar: congelar el backbone (no mover sus pesos) y entrenar solo la cabeza, que es rápido y sirve con pocos datos; o entrenar todo con learning rate chico, que es más lento y suele dar mejor resultado cuando hay muchas fotos, como en C01. Congelado, el entrenamiento solo mueve 1,024,500 de los 24,532,532 parámetros: el 4.2 %.

¿Por qué C01 empieza así? Porque con un modelo preentrenado hacen falta muchas menos fotos y horas de GPU para llegar a una buena top-5. Y como C01 se reentrena cada mes, cada reentrenamiento parte de pesos que ya saben ver.

1. Olvidar model.eval() en el servidor

La BatchNorm normaliza con las estadísticas del batch y el Dropout, si lo hay, apaga neuronas al azar. La misma foto da respuestas distintas según con qué otras llegó, y nada truena.

Cómo evitarlo: que la función que carga el modelo termine en model.eval(), una prueba que revise que model.training sea False y la prueba de paridad de la Ronda (M08).

2. Una normalización distinta a la del entrenamiento

Si en el servidor olvidas dividir entre 255, el rojo de un píxel que vale 236 entra como (236 − 0.485) ÷ 0.229 ≈ 1,028 en vez de (0.925 − 0.485) ÷ 0.229 ≈ 1.92. Si cargas la foto en orden azul-verde-rojo (BGR), los canales se cruzan. El modelo no truena: ve una foto «rara» y se equivoca más, en silencio.

Cómo evitarlo: el mismo código de preprocesamiento al entrenar y al servir (lo contrario es el training-serving skew) y una prueba que compare, número por número, el tensor del servidor con el de la evaluación.

3. Confundir el padding y el redondeo

«Padding 1 deja el mapa igual» solo es cierto con filtro de 3 × 3 y stride 1. Y con stride 2 la salida no siempre es la mitad exacta: una entrada de 56 sale de 28, pero una de 57 sale de (57 + 2 − 3) ÷ 2 + 1 = 29, no de 28.5. Un error de uno en el tamaño basta para que dos ramas que se suman (como el atajo de una ResNet) no cuadren.

Cómo evitarlo: hacer la cuenta con la fórmula antes de escribir la capa y, en código, pasar un tensor de prueba e imprimir su forma (shape) después de cada capa.

4. Contar mal los parámetros

Los resbalones típicos: olvidar los canales de entrada (un filtro de 3 × 3 sobre 64 canales tiene 576 pesos, no 9); poner sesgos donde no hay (las convoluciones de la ResNet no llevan); contar como parámetros las estadísticas acumuladas de la BatchNorm (se guardan con el modelo, pero el gradiente no las ajusta); o confundir parámetros (memoria) con MACs (cálculo).

Cómo evitarlo: contar con las fórmulas y compararlo con lo que dice PyTorch, sum(p.numel() for p in model.parameters()). Para la ResNet-50 debe dar 25,557,032, o 24,532,532 con 500 categorías.

5. Cargar pesos con la cabeza equivocada

Los pesos de un modelo de 1,000 categorías no caben en uno de 500: PyTorch truena con un error de size mismatch en la capa final. Para quitárselo de encima, lo común es borrar la capa final de los pesos guardados y cargar el resto con strict=False, que deja pasar sin avisar las capas cuyos nombres no coinciden (un tamaño distinto sigue tronando). El peligro es que no avisa: si los nombres no coinciden (por ejemplo, porque al guardar se les pegó el prefijo module.), el modelo se queda con sus pesos al azar y responde basura sin un solo error.

Cómo evitarlo: crear el modelo con el número correcto de categorías antes de cargar; si usas strict=False, revisar la lista de capas que no se cargaron, que devuelve la misma función; y evaluar con el golden set después de cargar.

6. Achicar la foto y perder lo chico

El resize del preprocesamiento es parte del modelo, aunque viva en otro archivo. Si un defecto mide 3 píxeles y achicas la foto a menos de la mitad, ya no está cuando la red la ve, y ninguna capa lo recupera.

Cómo evitarlo: antes de elegir el tamaño de entrada, calcula cuántos píxeles mide lo más chico que hay que ver. Si son pocos, no achiques: corta la imagen en tiles (cuadros que la red procesa por separado) a resolución completa.

Resuélvelos con lápiz antes de abrir la solución; los de tamaños y parámetros se pueden comprobar con las calculadoras.

1. 1Fácil

   Una neurona tiene entradas 1, 2 y 3, pesos 0.5, −1 y 1, y sesgo 0.5. ¿Qué sale después de la ReLU? ¿Y si el sesgo fuera −3?

   Ver la solución paso a paso

   • Productos: 1 × 0.5 = 0.5, 2 × (−1) = −2 y 3 × 1 = 3.
   • Suma con el sesgo: 0.5 − 2 + 3 + 0.5 = 2. No es negativo: la ReLU deja salir 2.
   • Con sesgo −3: 0.5 − 2 + 3 − 3 = −1.5, negativo: sale 0. El sesgo decide qué tan fácil se activa la neurona.
2. 2Fácil

   Un MLP para dígitos de 28 × 28 en gris tiene 784 entradas, una capa oculta de 128 neuronas y 10 salidas. ¿Cuántos parámetros tiene y cuántas MACs hace por imagen?

   Ver la solución paso a paso

   • Capa oculta: 784 × 128 + 128 = 100,352 + 128 = 100,480.
   • Capa de salida: 128 × 10 + 10 = 1,290.
   • Parámetros: 100,480 + 1,290 = 101,770.
   • MACs: una por peso, 784 × 128 + 128 × 10 = 100,352 + 1,280 = 101,632 por imagen.
3. 3Fácil

   Una entrada de 32 × 32 pasa por una convolución de 5 × 5 sin padding y con stride 1. ¿De qué tamaño sale? ¿Qué padding necesitas para que salga de 32 × 32?

   Ver la solución paso a paso

   • Sin padding: (32 + 0 − 5) ÷ 1 + 1 = 28, como en la primera capa de LeNet-5, la CNN de dígitos de 1998.
   • Para 32: (32 + 2p − 5) + 1 = 32, así que 2p = 4 y p = 2: la regla (k − 1) ÷ 2.
4. 4Fácil

   Un max pooling de 2 × 2 con stride 2 recibe 256 mapas de 56 × 56. ¿Qué sale y cuántos parámetros tiene?

   Ver la solución paso a paso

   • Lado: (56 + 0 − 2) ÷ 2 + 1 = 28. Salen 256 mapas de 28 × 28: el pooling actúa en cada mapa por separado y no cambia la cantidad de canales.
   • Números: de 802,816 a 200,704, cuatro veces menos.
   • Parámetros: 0. Solo toma el máximo.
5. 5Medio

   Una convolución de 3 × 3 recibe 64 canales, tiene 128 filtros, no lleva sesgo y su salida es de 28 × 28. ¿Cuántos parámetros tiene, cuántas MACs hace y cuántas veces se usa cada peso?

   Ver la solución paso a paso

   • Pesos por filtro: 3 × 3 × 64 = 576. Parámetros: 576 × 128 = 73,728.
   • MACs: 28 × 28 posiciones × 128 filtros × 576 = 784 × 128 × 576 = 57,802,752, unos 58 millones.
   • Cada peso se usa una vez por posición: 784 veces, y por eso hay 784 veces más MACs que parámetros.
6. 6Medio

   Alguien olvida el center crop y le pasa a la ResNet-50 fotos de 256 × 256. ¿De qué tamaño sale la primera capa (7 × 7, padding 3, stride 2) y después el max pooling (3 × 3, padding 1, stride 2)? ¿De qué tamaño queda el último mapa? ¿Truena el modelo?

   Ver la solución paso a paso

   • Primera capa: (256 + 6 − 7) ÷ 2 = 127.5, que baja a 127; más 1: 128.
   • Max pooling: (128 + 2 − 3) ÷ 2 = 63.5, que baja a 63; más 1: 64.
   • Último mapa: con salto 32, 256 ÷ 32 = 8: mapas de 8 × 8 en vez de 7 × 7.
   • No truena: el pooling global promedia cada mapa, sea de 7 × 7 o de 8 × 8, y la cabeza recibe siempre 2,048 números. Por eso es peligroso: la respuesta cambia un poco y nada avisa, un caso de training-serving skew.
7. 7Medio

   (Usa la sección extra del campo receptivo.) Cuatro capas de 3 × 3: la segunda tiene stride 2 y las demás stride 1. ¿Cuál es el campo receptivo de una neurona de la cuarta capa? ¿Y si las cuatro tuvieran stride 1?

   Ver la solución paso a paso

   • Empieza con r = 1 y j = 1. Capa 1 (k = 3, s = 1): r = 1 + 2 × 1 = 3, j = 1.
   • Capa 2 (s = 2): r = 3 + 2 × 1 = 5, y el salto pasa a j = 2.
   • Capa 3: r = 5 + 2 × 2 = 9. Capa 4: r = 9 + 2 × 2 = 13.
   • Todas con stride 1: 1 + 4 × 2 = 9. El stride de en medio le ganó 4 píxeles al campo.
8. 8Reto

   (Usa el salto de la sección extra del campo receptivo y el caso C03.) Una cámara de inspección cubre 300 mm con 2,448 píxeles y hay que ver defectos de 0.3 mm. (a) ¿Cuántos píxeles mide un defecto? (b) Si la red recibe tiles de 512 y su backbone tiene salto 32, ¿qué fracción del ancho de una celda del último mapa ocupa el defecto? (c) ¿Qué cambiarías para verlo mejor?

   Ver la solución paso a paso

   • (a) 300 ÷ 2,448 ≈ 0.1225 mm por píxel, así que 0.3 ÷ 0.1225 ≈ 2.45 píxeles. Menos que la fisura de C03.
   • (b) 2.45 ÷ 32 ≈ 7.7 % del ancho de una celda de 32 × 32. Y el tile de 512 tiene 16 × 16 = 256 celdas.
   • (c) Primero la óptica: un campo de visión más chico (por ejemplo, dos cámaras de 150 mm) duplica los píxeles por defecto. Después, no achicar la imagen; usar mapas de salto 8, donde el defecto ocupa ≈ 31 % del ancho de una celda; y calificar cada posición y tomar el máximo en vez de promediar.
9. 9Reto

   La capa final de la ResNet-50 de C01 guarda ≈ 4 % de los parámetros pero hace ≈ 0.025 % de las MACs; la primera capa tiene 9,408 parámetros pero hace 118 millones de MACs. Explica las dos cosas con números: ¿cuántas veces se usa cada peso en cada capa?

   Ver la solución paso a paso

   • Capa final, densa: cada peso se usa una vez por foto, así que sus MACs (1,024,000) son casi sus parámetros (1,024,500); contra ≈ 4,100 millones del modelo, son ≈ 0.025 %.
   • Primera capa, convolucional: cada peso se usa en cada posición de la salida, 112 × 112 = 12,544 veces; 9,408 × 12,544 = 118,013,952 MACs.
   • La conclusión: los parámetros dicen cuánta memoria pide un modelo y las MACs cuánto cálculo. En una CNN no van de la mano, porque cada peso se reutiliza miles de veces.

En la Ronda:

• M03 · Latencia y capacidad hace el chequeo de cordura de esta lección: 8.2 GFLOPs por foto contra ≈ 65 TFLOPS de una T4, un techo de ≈ 7,900 fotos por segundo.
• M04 · Hardware para inferencia arranca con la cuenta de los parámetros: 25.6 M × 4 bytes ≈ 102 MB en float32 (la Ronda le dice FP32) y ≈ 51 MB en float16 (FP16); para C01, ≈ 49 MB en float16. Ahí verás también por qué una CNN suele estar limitada por el cálculo, y cuánto pesan YOLOv8m (≈ 25.9 M parámetros) y ViT-B/16 (≈ 86 M).
• M07 · Servidores de modelos carga el modelo una vez al arrancar, con model.eval() y torch.inference_mode(): sin lo primero, la BatchNorm usa las estadísticas del batch.
• M08 · Optimización muestra que algunas herramientas que capturan el modelo para acelerarlo (torch.export, torch.compile) conservan la BatchNorm en modo train si olvidaste eval(), mientras que la exportación a ONNX (un formato estándar para guardar el modelo y correrlo fuera de PyTorch) te protege; y que al convertir el modelo a un formato rápido la BatchNorm se «pliega» dentro de la convolución anterior.
• Los casos. C01 da el modelo por hecho («ResNet-50 con una capa final de 500 clases»); C02 usa un detector a 640 × 640 con NMS; C03, 20 tiles con un backbone y dos cabezas; C04, una U-Net sobre tiles que se enciman. Ahora sabes qué quiere decir cada palabra.

En el Dojo: la estación 7, Empaquetado, usa la cuenta de esta lección, 25.6 M parámetros × 2 bytes ≈ 51 MB, para decidir que el modelo puede ir dentro del paquete del servidor (la imagen de Docker). Cuando abran las estaciones 3 (Entrenamiento) y 5 (Export, engine y paridad), ahí vas a practicar el fine-tuning y la prueba de paridad con model.eval().

En Sensei: la siguiente lección, «Embeddings: el significado como coordenadas», usa los 2,048 números del backbone. «Transformers y LLMs» explica la atención que usa el ViT. Más adelante, «Cómo guarda números una computadora» explica float32 y float16, y «Matrices, FLOPs y qué tan rápido calcula una GPU» convierte las MACs de esta lección en milisegundos.

Estos son los conceptos que presentó esta lección. Cada uno tiene su tarjeta con la definición completa.

Intenta responder en tu cabeza antes de abrir cada respuesta.

1. 1¿Por qué un perceptrón no puede aprender el XOR, y qué lo resuelve?Ver respuesta

   Una neurona con escalón separa el plano con una recta, y en el XOR los dos casos que valen 1 están en esquinas opuestas: ninguna recta los aparta de los ceros. Lo resuelve una capa oculta (un MLP), que mueve los puntos para que una recta sí sirva.

2. 2¿Cuántos parámetros tiene una capa densa con 2,048 entradas y 500 salidas, y cuántas MACs hace por foto?Ver respuesta

   2,048 × 500 pesos + 500 sesgos = 1,024,500 parámetros, y 2,048 × 500 = 1,024,000 MACs: cada peso se usa una vez. Es la capa final de la ResNet-50 de C01.

3. 3¿Por qué una CNN necesita tan pocos parámetros comparada con una red densa sobre los mismos píxeles?Ver respuesta

   Porque cada filtro mira solo un pedacito y se usa en todas las posiciones de la foto. Una capa de 64 filtros de 3 × 3 × 3 tiene 1,792 parámetros; una densa de 1,000 neuronas sobre los mismos 150,528 números tendría ≈ 150 millones.

4. 4Una entrada de 56 × 56 pasa por una convolución de 3 × 3 con padding 1 y stride 2. ¿De qué tamaño sale?Ver respuesta

   (56 + 2 − 3) ÷ 2 = 27.5, que baja a 27; más 1: 28. Con stride 1 habría salido de 56.

5. 5¿Qué hace la conexión residual de una ResNet?Ver respuesta

   Le suma al bloque su propia entrada: salida = bloque(x) + x. Cada bloque solo aprende una corrección y la señal del aprendizaje llega bien hasta las primeras capas; eso permitió entrenar en ImageNet redes de hasta 152 capas.

6. 6En producción, la misma foto da respuestas distintas según qué otras fotos venían en su batch. ¿Qué revisas primero?Ver respuesta

   Que el modelo esté en modo eval (model.eval()). En modo train, la BatchNorm normaliza con las estadísticas del batch actual, así que la respuesta depende de las otras fotos.

7. 7¿Por qué C01 parte de una ResNet-50 preentrenada en ImageNet en vez de entrenar desde cero?Ver respuesta

   Porque su backbone ya aprendió a ver bordes, texturas y formas con ≈ 1.28 millones de fotos. Basta cambiar la cabeza a 500 categorías y hacer fine-tuning, con muchas menos fotos y horas de GPU.