Empezando con fast.ai: de cero a un modelo entrenado en minutos

1. Top-down: por qué este curso empieza al revés

Casi toda enseñanza técnica universitaria es bottom-up: fundamentos primero, aplicaciones después — es como aprender música memorizando teoría musical durante años antes de que te dejen tocar una canción. fast.ai apuesta por lo opuesto: mostrar una solución completa, útil, de estado del arte a un problema real en los primeros cinco minutos, y recién después ir bajando capa por capa a entender cómo está hecha esa solución por dentro. Jeremy Howard lo resume así: uno aprende mejor cuando hay un contexto y un propósito que entender intuitivamente, no manipulación de símbolos algebraicos en el vacío.

Esto no es solo una preferencia pedagógica — cambia qué se puede hacer desde el primer día. Con HF LLM Course, entender por qué la atención funciona requería antes entender tokenización, embeddings, matrices de queries/keys/values. Acá, en los primeros minutos vas a entrenar y desplegar un modelo real sin haber visto una sola derivada.

El libro es explícito sobre cómo leerlo: no se aprende deep learning leyendo, se aprende corriendo el código y rompiéndolo. Cada capítulo del libro es un notebook Jupyter (el repositorio fastai/fastbook) pensado para ejecutarse celda por celda, cambiar cosas y ver qué pasa. La recomendación concreta de Howard es leer cada capítulo dos veces: la primera de corrido sin detenerse en lo que no se entiende, la segunda experimentando con cada celda.

2. Qué es deep learning, sin rodeos: el motor mecánico y tensorial

El libro arranca con la definición de machine learning de Arthur Samuel, investigador de IBM que en 1962 formuló el cambio de paradigma frente a la informática tradicional:

• Programación clásica: Escribís reglas explícitas (código con if/else, loops) + datos de entrada → la computadora ejecuta y produce resultados.
• Machine Learning: Le das datos de entrada + ejemplos de resultados esperados → la máquina descubre y calibra los parámetros que mejor resuelven el problema.

El esquema original de Samuel era: inputs + weights → un modelo → resultados → una medida de performance → esa medida ajusta los weights → se repite. Es, literalmente, el training loop completo que hoy corre sobre clusters de GPUs H100 o en tu propia máquina.

Qué ocurre físicamente dentro de una red neuronal

¿Qué es una red neuronal en términos de tensores? Es una función matemática compuesta por una secuencia de capas:

1. Los datos entran como tensores: Una imagen se representa como una matriz tridimensional de números (canales de color, alto, ancho: $[3,224,224]$). Un texto en un LLM entra como una secuencia de vectores de embeddings ($[N,4096]$).
2. Transformación lineal (Pesos y Sesgos): Cada capa multiplica el tensor de entrada $\mathbf{x}$ por una matriz de pesos $\mathbf{W}$ y suma un vector de sesgo (bias) $\mathbf{b}$: $\mathbf{z}=\mathbf{W}\mathbf{x}+\mathbf{b}$. Los valores dentro de $\mathbf{W}$ y $\mathbf{b}$ son los parámetros (los 34 millones en ResNet-34, o los 8 mil millones en Llama-3-8B).
3. No-linealidad (Función de activación): Inmediatamente después de la multiplicación lineal, se aplica una función no lineal elemento a elemento: $\mathbf{a}=\sigma \left(\mathbf{z}\right)$ (como ReLU: $max(0,z)$, GELU o SwiGLU).

   🟢 Por qué la no-linealidad es obligatoria

   Si no hubiera funciones no lineales entre medio, apilar 50 capas lineales colapsaría matemáticamente en una sola: $W_3\left(W_2\right(W_{1}x\left)\right)=\left(W_3{W}_2{W}_1\right)x=W_{\mathrm{total}}x$. Una red profunda de 50 capas sin no-linealidades equivaldría a una simple regresión lineal de una sola capa. La no-linealidad es la bisagra que permite "doblar" el espacio geométrico y aproximar funciones arbitrariamente complejas (el Teorema de Aproximación Universal).

El ciclo de 4 tiempos del aprendizaje

Todo entrenamiento de redes neuronales, desde un clasificador chico hasta el entrenamiento de GPT-4, sigue exactamente cuatro tiempos:

• 1. Forward Pass: Los datos viajan hacia adelante a través de las capas de la red produciendo una predicción cruda (logits).
• 2. Función de Pérdida (Loss Function): Un número escalar derivable que cuantifica qué tan lejos estuvo la predicción del objetivo real (por ejemplo, Cross-Entropy Loss).
• 3. Backward Pass (Autograd): Mediante la regla de la cadena del cálculo multivariable, la GPU calcula el gradiente de la pérdida respecto a cada uno de los millones de pesos: ${\nabla }_{\mathbf{W}}\mathcal{L}=\frac{\partial \mathcal{L}}{\partial \mathbf{W}}$. El gradiente es un vector que apunta en la dirección en que la pérdida sube más rápido.
• 4. Paso de Optimización (SGD / Adam): El optimizador actualiza cada peso empujándolo un pequeño paso en la dirección opuesta al gradiente: $\mathbf{W}\leftarrow \mathbf{W}-\eta {\nabla }_{\mathbf{W}}\mathcal{L}$, donde $\eta$ es la tasa de aprendizaje (learning rate).

Un detalle que vale la pena fijar: el libro cita las visualizaciones de Zeiler y Fergus (2013) sobre qué aprende cada capa de una red profunda entrenada en ImageNet:

• Capa 1: Detecta primitivas de bajo nivel: bordes orientados, contrastes blanco/negro y gradientes de color.
• Capa 2: Combina bordes para detectar esquinas, curvas y rayas.
• Capa 3: Combina esquinas para identificar patrones geométricos, texturas repetidas y mallas.
• Capas 4 y 5: Ensambla partes complejas de objetos: ojos de perros, ruedas de bicicleta, patas de pájaros.

En los LLMs ocurre un fenómeno análogo: las primeras capas de atención aprenden sintaxis local, concordancia y morfología; las capas intermedias capturan relaciones temáticas y estilo; y las capas profundas resuelven razonamiento abstracto, recuperación de hechos y lógica en contexto.

3. El ejemplo insignia: gatos vs. perros en 6 líneas

El primer modelo real del curso clasifica gatos y perros usando el Oxford-IIIT Pet Dataset (7.349 fotos, 37 razas), con una convención de etiquetado simple: si el nombre del archivo empieza con mayúscula, es gato.

from fastai.vision.all import *

path = untar_data(URLs.PETS)/'images'
def is_cat(x): return x[0].isupper()

dls = ImageDataLoaders.from_name_func(
    path, get_image_files(path), valid_pct=0.2, seed=42,
    label_func=is_cat, item_tfms=Resize(224))

learn = vision_learner(dls, resnet34, metrics=error_rate)
learn.fine_tune(1)   # error_rate final: menor a 0.02

Menos de 2% de error en una sola época. Pero en vez de mirar esto como magia enlatada, desarmemos la anatomía física y matemática de lo que ocurrió:

1. La geometría de entrada: por qué Resize(224)

Las GPUs ejecutan operaciones matemáticas a velocidades astronómicas porque procesan datos en lotes (batches) mediante multiplicación paralela de matrices (GEMM). Para que la GPU pueda apilar 64 fotos distintas en un único tensor homogéneo de dimensión $[64,3,224,224]$ (batch, canales RGB, alto, ancho), todas las imágenes deben tener exactamente los mismos píxeles. Resize(224) no es una sugerencia estética: es un requisito geométrico indispensable para que el cómputo matricial funcione.

2. Anatomía de una red preentrenada: Backbone vs. Cabeza (Head)

Cualquier red neuronal moderna para visión o lenguaje se divide en dos piezas estructurales:

• El Cuerpo o Backbone: Son las capas profundas de la red (en ResNet-34, 33 capas convolucionales con millones de parámetros). Su trabajo es tomar datos crudos (píxeles) y transformarlos gradualmente en un vector denso de características abstractas (un embedding latente de 512 números). El backbone no sabe qué tarea específica estás resolviendo hoy: solo sabe "ver" el mundo.
• La Cabeza (Head): Es la última capa lineal (una simple matriz de pesos) conectada al final del backbone. Su único trabajo es proyectar ese vector latente de 512 dimensiones al número de clases que requiere tu problema. En el modelo original entrenado en ImageNet, la cabeza era una matriz de pesos de dimensión $[512,1000]$ para predecir 1.000 categorías.

¿Qué hace vision_learner cuando lo invocás? Hace una cirugía de tensores: toma el backbone de ResNet-34 con sus pesos ya entrenados en ImageNet, arranca la cabeza original de 1.000 clases, y le acopla una cabeza nueva de dimensión $[512,2]$ cuyos pesos están inicializados al azar con números aleatorios.

3. Qué ocurre matemáticamente durante predict()

img = PILImage.create('images/chapter1_cat_example.jpg')
learn.predict(img)

El flujo interno en la GPU para llegar a ese resultado consta de cuatro pasos matemáticos:

1. La imagen pasa por el backbone y sale comprimida como un vector de 512 números continuos.
2. Ese vector de 512 se multiplica por la matriz de la cabeza nueva ($[512,2]$): el resultado son dos números reales sin acotar llamados logits (por ejemplo: [-2.14, 4.65]).
3. Los logits pasan por la función Softmax: $P\left(i\right)=\frac{e^{z_i}}{\sum e^{z_j}}$. Esto transforma los números crudos en probabilidades positivas que suman exactamente 1,0: tensor([0.0011, 0.9989]).
4. Se aplica argmax para seleccionar el índice del valor más alto (índice 1). Ese índice se busca en el vocabulario dls.vocab ([False, True]), devolviendo el string 'True' (es gato).

4. Cómo correr esto hoy, y cómo leer la fuente de fastai

El libro asume Paperspace Gradient o Colab de 2020. Hoy las tres opciones que funcionan sin drama:

# Kaggle / Colab
!pip install -U fastai

# Local, en el entorno donde ya tenés PyTorch 2.x
pip install fastai
python -c "import fastai, torch; print(fastai.__version__, torch.__version__, torch.cuda.is_available())"

Transfer Learning con fundamento: qué hace fine_tune por dentro

Un hábito clave para cualquier ingeniero es no depender de cajas negras. En Jupyter, con learn.fine_tune?? podés inspeccionar el código fuente exacto de la función. Lo que vas a encontrar es revelador:

def fine_tune(self, epochs, base_lr=2e-3, freeze_epochs=1, lr_mult=100,
              pct_start=0.3, div=5.0, **kwargs):
    self.freeze()                                   # 1. Congela el cuerpo pretrained
    self.fit_one_cycle(freeze_epochs, slice(base_lr), pct_start=0.99, **kwargs)  # 2. Entrena solo la cabeza
    base_lr /= 2
    self.unfreeze()                                 # 3. Descongela todo el modelo
    self.fit_one_cycle(epochs, slice(base_lr/lr_mult, base_lr),
                       pct_start=pct_start, div=div, **kwargs)   # 4. Entrena todo, con learning rates por capa

Desarmemos la razón física de cada una de esas cuatro líneas:

• 1. ¿Por qué self.freeze() es indispensable?
  En PyTorch, freeze() recorre todas las capas del backbone y establece param.requires_grad = False. Recordá que la cabeza nueva fue creada hace un segundo con números aleatorios. En el primer batch, el modelo predice basura y la función de pérdida (Loss) da un número gigantesco. Si no congelaras el cuerpo, ese error descomunal mandaría gradientes masivos hacia atrás que destruirían instantáneamente los pesos del backbone (fenómeno conocido como olvido catastrófico). Habrías arruinado semanas de preentrenamiento en una sola pasada. Además, al congelar, la GPU no gasta memoria VRAM ni ciclos en computar gradientes para el 99% de la red.
• 2. Entrenar la cabeza nueva sola: Durante una época (freeze_epochs=1), solo los parámetros de la matriz $[512,2]$ se actualizan. La cabeza aprende a mapear las features ya existentes hacia las clases gato/perro hasta alcanzar una mínima estabilidad.
• 3. self.unfreeze(): Vuelve a activar requires_grad = True en toda la red. Ahora que la cabeza tiene pesos coherentes, ya es seguro involucrar a todo el modelo.
• 4. Learning Rates discriminativos (slice(base_lr/100, base_lr)): No todas las capas deben aprender a la misma velocidad. Las primeras capas (que detectan bordes y colores) son útiles para cualquier imagen y casi no necesitan cambiar; por eso se les asigna una tasa de aprendizaje 100 veces menor (${\mathrm{lr}}_{\mathrm{base}}/100$). Las capas profundas se entrenan con el learning rate completo para adaptarse a las particularidades del dataset.

5. Terminología que hay que fijar bien: rigor matemático

Varios términos que generan confusión continua si no se entienden desde su fundamento formal:

• Loss vs. Metric: la distinción matemática crucial
  ¿Por qué no le decimos a la GPU que optimice directamente el porcentaje de aciertos (Accuracy o error_rate)?
  Porque el Accuracy es una función escalonada no derivable: si para una imagen la probabilidad predicha de "gato" sube de 0,10 a 0,45, el modelo sigue prediciendo "perro" (la clase mayoritaria). El Accuracy no cambió nada; su derivada matemática es exactamente cero. Un gradiente de cero significa que la GPU no tiene ninguna pista de hacia dónde mover los pesos.
  El Loss (como la Cross-Entropy Loss) es una función continua, suave y derivable que castiga no solo si acertaste, sino con cuánta seguridad acertaste o te equivocaste ($-logp$).
  ¿Por qué el valid_loss puede subir mientras el error_rate sigue bajando? Porque el modelo está acertando más casos límite (baja el error), pero en los pocos casos donde se equivoca, lo hace con un exceso de confianza absurdo (por ejemplo, asignando 99,9% a la clase errónea). La pérdida logarítmica castiga duramente esa arrogancia matemática.
• Train / Validation / Test: la triada anti-autoengaño
  
  • Training Set: El conjunto de datos que la GPU usa para calcular gradientes y actualizar pesos.
  • Validation Set: Un subconjunto apartado (típicamente 20%) que la GPU nunca usa para calcular gradientes. Sirve para evaluar si el modelo generaliza o si simplemente memorizó los ejemplos de entrenamiento (overfitting).
  • Test Set: Un tercer conjunto reservado bajo llave. ¿Por qué hace falta un Test set si ya tenemos Validation? Porque cada vez que vos, como ingeniero, ajustás un hiperparámetro (cambiás la arquitectura, el learning rate o la cantidad de épocas) porque viste que mejoraba en el Validation set, estás sobreajustando el modelo a ese Validation set con tus propias decisiones humanas. El Test set solo se evalúa una vez al final para tener una medición honesta e incorruptible.
• Epoch: Una pasada completa por la totalidad de los datos del Training Set.
• CNN (Convolutional Neural Network): Arquitectura especializada en explotar la localidad espacial (un píxel se relaciona principalmente con sus píxeles vecinos). resnet34 indica una red convolucional con 34 capas de profundidad.

6. Los tres mitos que el curso quiere tirar abajo

El capítulo dedica una sección entera a desmentir tres creencias que, según el libro, alejan innecesariamente a gente capaz del deep learning:

El libro cita incluso a Elon Musk diciendo que "un PhD definitivamente no es requerido" para trabajar en el campo. Vale la pena leer esto con la distancia de 2026: sigue siendo cierto que no hace falta un doctorado para usar deep learning con criterio — pero la barra para entrenar desde cero un modelo de frontera sí subió muchísimo (los LLMs de escala moderna cuestan millones de dólares de cómputo). Lo que el mito desmiente sigue siendo válido para el 95% de los problemas prácticos reales, justo los que este curso enseña a resolver.

7. Errores comunes

Casi todos los tropiezos de la primera semana con fastai son conceptuales, no de código — y por eso conviene fijarlos ahora, antes de que el pipeline se complique.

8. Resumen

1. fast.ai enseña top-down: un sistema funcional completo primero, la descomposición teórica después. Pero comprender la física de los tensores y gradientes es lo que te permite anticipar problemas y tomar decisiones de ingeniería.
2. Deep learning es una máquina de 4 tiempos: Forward pass (multiplicaciones de matrices + no-linealidades) → Loss function (escalar derivable) → Backward pass con Autograd (gradientes vía regla de la cadena) → Optimizador (SGD/Adam moviendo pesos en dirección opuesta al gradiente).
3. Las no-linealidades (ReLU, GELU, SwiGLU) son obligatorias: sin ellas, cualquier cantidad de capas profundas colapsaría en una sola matriz lineal.
4. Todo modelo preentrenado se divide en Backbone (extractor universal de características) y Head (proyección lineal a la tarea). Transfer learning consiste en reemplazar la cabeza y conservar el backbone.
5. fine_tune congela el cuerpo (freeze()) para evitar que los gradientes salvajes de la cabeza aleatoria destruyan el conocimiento previo (olvido catastrófico). Luego descongela con learning rates discriminativos. Esta misma filosofía es la que hace posible LoRA y PEFT en LLMs modernos.
6. Arquitectura ≠ modelo; Loss (función continua que optimiza la máquina) ≠ Metric (indicador para humanos); Validation ≠ Test.

9. Ponete a prueba

Respondé antes de abrir cada respuesta. Si fallás una, volvé a la sección indicada.

10. Para practicar

from fastai.vision.all import *
path = untar_data(URLs.PETS)/'images'
def is_cat(x): return x[0].isupper()
dls = ImageDataLoaders.from_name_func(path, get_image_files(path), valid_pct=0.2, seed=42,
                                      label_func=is_cat, item_tfms=Resize(224))
learn = vision_learner(dls, resnet34, metrics=error_rate)
learn.fine_tune(1)

print(dls.vocab)
for f in ['gato.jpg', 'perro.jpg', 'taza.jpg']:
    cls, idx, probs = learn.predict(PILImage.create(f))
    print(f, cls, idx.item(), probs.tolist())

learn2 = vision_learner(dls, resnet34, metrics=error_rate)
learn2.fine_tune??          # leé la fuente primero

learn2.freeze()
learn2.fit_one_cycle(1, slice(2e-3), pct_start=0.99)
learn2.unfreeze()
learn2.fit_one_cycle(1, slice(1e-3/100, 1e-3), pct_start=0.3, div=5.0)

for tfm in [Resize(224), Resize(224, method='squish'), RandomResizedCrop(224, min_scale=0.5)]:
    d = ImageDataLoaders.from_name_func(path, get_image_files(path), valid_pct=0.2, seed=42,
                                        label_func=is_cat, item_tfms=tfm, bs=8)
    d.show_batch(max_n=8, nrows=1)

11. Fuentes y para seguir

• Practical Deep Learning for Coders — Lesson 1: Getting started — la lección en video (edición 2022) con el notebook "Is it a bird?" en Kaggle; la versión vigente de lo que cubre esta página.
• fastbook — 01_intro.ipynb — el Capítulo 1 del libro como notebook ejecutable; es la fuente directa de todo el código de acá.
• fastai documentation — la referencia oficial de vision_learner, fine_tune, ImageDataLoaders; cada página tiene el link "source" al código.
• Deep Residual Learning for Image Recognition (He et al., 2015) — el paper de ResNet, la arquitectura que usás en resnet34. Leelo cuando llegues a la lección de convoluciones.
• Visualizing and Understanding Convolutional Networks (Zeiler & Fergus, 2013) — las visualizaciones por capa que el libro reproduce para explicar por qué funciona el transfer learning.
• The Oxford-IIIT Pet Dataset — el dataset del ejemplo insignia, con la descripción de las 37 razas y la convención de nombres.