Deployment: de un dataset propio a una app desplegada

1. El pipeline completo: de la búsqueda de imágenes al modelo

El ejemplo del libro es un clasificador de osos (grizzly / negro / teddy), armado con imágenes buscadas y descargadas por código — no un dataset ya empaquetado y limpio como el de la Lección 1. El pipeline:

from fastai.vision.all import *
from fastbook import search_images_ddg      # pip install fastbook

bear_types = 'grizzly', 'black', 'teddy'
path = Path('bears')

# 1. Buscar y descargar (150 imágenes por clase alcanza), una carpeta por clase
for o in bear_types:
    dest = path/o
    dest.mkdir(exist_ok=True, parents=True)
    urls = search_images_ddg(f'{o} bear', max_images=150)
    download_images(dest, urls=urls)

# 2. Verificar y descartar archivos corruptos
fns = get_image_files(path)
failed = verify_images(fns)
failed.map(Path.unlink)
print(f'{len(failed)} archivos rotos borrados')

from duckduckgo_search import DDGS      # pip install duckduckgo_search

def search_images(term, max_images=200):
    print(f"Buscando '{term}'")
    with DDGS() as ddgs:
        return L(ddgs.images(term, max_results=max_images)).itemgot('image')

urls = search_images('grizzly bear photos', max_images=150)

Con menos de 150 imágenes por clase, sin dataset curado de antemano, ya alcanza para entrenar algo útil — el punto es que armar tu propio dataset desde cero no es el cuello de botella que parece. Un consejo del propio libro que sigue vigente: buscá términos variados por clase ("grizzly bear", "grizzly bear shadow", "grizzly bear sun") para que el dataset tenga la variedad que después va a aparecer en producción.

2. La DataBlock API, pieza por pieza

DataBlock es la pieza central de fastai: una plantilla que obliga a responder cuatro preguntas explícitas sobre cualquier dataset, en vez de escribir un Dataset/DataLoader de PyTorch a mano cada vez:

bears = DataBlock(
    blocks=(ImageBlock, CategoryBlock),
    get_items=get_image_files,
    splitter=RandomSplitter(valid_pct=0.2, seed=42),
    get_y=parent_label,
    item_tfms=Resize(128))
dls = bears.dataloaders(path)
dls.valid.show_batch(max_n=4, nrows=1)

• blocks: define los tipos tensoriales de la variable independiente y dependiente (aquí, ImageBlock produce tensores de imagen flotantes, CategoryBlock produce enteros codificados One-Hot o Cross-Entropy targets).
• get_items: la función de pipeline para indexar los archivos en disco.
• splitter: separación determinista de Train/Validation fijando una semilla (seed) para garantizar reproducibilidad exacta.
• get_y: la función de extracción de etiquetas (por ejemplo, el nombre de la carpeta contenedora con parent_label).

La física del pipeline: CPU vs. GPU

El diseño de DataBlock separa estrictamente dos etapas de cómputo con características de hardware opuestas:

1. Etapa CPU (Ítem por ítem — item_tfms):
   En el disco, los archivos JPEG/PNG son secuencias comprimidas de bytes con dimensiones heterogéneas ($1024\times 768$, $500\times 800$, etc.). La GPU no puede procesar tensores con formas variables: su arquitectura SIMD (Single Instruction, Multiple Data) requiere que todos los elementos del lote compartan exactamente las mismas dimensiones de memoria. Por eso, la CPU decodifica cada archivo comprimido, lo convierte en un arreglo RGB y ejecuta Resize o RandomResizedCrop(224). Recién cuando todas las matrices tienen tamaño uniforme $[3,224,224]$, se apilan en memoria RAM fijada (*pinned host memory*) para formar el tensor homogéneo $[64,3,224,224]$.
2. Etapa GPU (Lote completo — batch_tfms):
   Una vez transferido el tensor a la VRAM mediante DMA, se ejecuta el Data Augmentation (rotación, traslación, escala, perspectiva, brillo). En vez de procesar píxel por píxel con loops de CPU, la GPU formula cada transformación como una matriz afín tridimensional $\mathbf{A}\in {\mathbb{R}}^{3\times 3}$. Mediante interpolación bilineal paralelizada en hardware, los núcleos tensoriales recalculan las coordenadas de los millones de píxeles del batch en una fracción de milisegundo. Por esta razón física, hacer data augmentation en GPU es computacionalmente gratuito y no frena el training loop.

bears = bears.new(
    item_tfms=RandomResizedCrop(224, min_scale=0.5),
    batch_tfms=aug_transforms())
dls = bears.dataloaders(path)
dls.train.show_batch(max_n=8, nrows=2, unique=True)   # la misma imagen, 8 augmentations

3. Limpiar datos usando el propio modelo

La secuencia del libro invierte el orden intuitivo: en vez de limpiar todos los datos a mano antes de entrenar, entrená un modelo simple primero y usalo para encontrar los problemas del dataset.

learn = vision_learner(dls, resnet18, metrics=error_rate)
learn.fine_tune(4)

interp = ClassificationInterpretation.from_learner(learn)
interp.plot_confusion_matrix()
interp.plot_top_losses(5, nrows=1)

from fastai.vision.widgets import *
cleaner = ImageClassifierCleaner(learn)
cleaner   # el widget: elegís categoría y split, marcás cada imagen

# después de marcar: aplicar lo decidido
for idx in cleaner.delete(): cleaner.fns[idx].unlink()
for idx, cat in cleaner.change(): shutil.move(str(cleaner.fns[idx]), path/cat)

La matemática del Loss como detector de anomalías

¿Por qué un modelo todavía imperfecto es el mejor inspector de datos del mundo? La respuesta está en la función de pérdida de Cross-Entropy Loss:

$\mathcal{L}=-logP\left(y_{\text{real}}\right)$

Supongamos que en el dataset descargado de internet, una foto de un oso grizzly salvaje en un río fue etiquetada por error como teddy (oso de peluche). Durante el forward pass, el backbone convolucional extrae bordes de garras, textura de pelaje mojado y colmillos; la cabeza proyecta esos rasgos y el Softmax asigna a la clase real asignada una probabilidad ínfima: $P\left(\text{teddy}\right)\approx 0,0002$. Al calcular la pérdida:

$\mathcal{L}=-log(0,0002)\approx 8,51$

Una imagen normal bien clasificada tiene $P\left(y_{\text{real}}\right)\approx 0,98⟹\mathcal{L}\approx 0,02$. ¡El ejemplo mal etiquetado genera una pérdida 400 veces mayor! Como el optimizador busca minimizar el error promedio, el modelo no memoriza casos aislados contradictorios si la mayoría de los datos son coherentes; en cambio, los "escupe" con un loss descomunal. interp.plot_top_losses() simplemente ordena la matriz de validación por $\mathcal{L}$ descendente, haciendo que el ruido de etiquetas y las imágenes corruptas floten instantáneamente a la superficie.

4. Out-of-domain data, domain shift y feedback loops

Una sección entera del capítulo se llama "How to Avoid Disaster", y su argumento es una verdad física ineludible: ningún modelo generaliza a distribuciones que violan las hipótesis estadísticas de su entrenamiento. En estadística y machine learning existen tres patologías formales que debés saber distinguir:

• Covariate Shift (Cambio en las covariables):
  Ocurre cuando la distribución de las entradas cambia, pero la función objetivo subyacente se mantiene: $P_{\text{train}}\left(X\right)\ne P_{\text{prod}}\left(X\right)$, pero $P(Y\mid X)$ es idéntico. Por ejemplo: entrenaste clasificando fotos de stock nítidas y centradas de día, y en producción la cámara de seguridad envía video infrarrojo granulado de noche. Un oso sigue siendo un oso, pero la variedad geométrica y los valores de píxeles caen fuera del soporte sobre el cual se calcularon las convoluciones.
• Concept Drift (Deriva del concepto):
  La relación causal entre la entrada y la salida cambia con el tiempo: $P_{\text{train}}(Y\mid X)\ne P_{\text{prod}}(Y\mid X)$. Por ejemplo: un clasificador de transacciones fraudulentas o un modelo de scoring financiero. Los patrones que hace un año indicaban solvencia o fraude hoy son usados deliberadamente por actores adversarios para evadir la detección.
• Feedback Loops (Bucles de retroalimentación autodestructivos):
  Cuando las salidas emitidas por el modelo en el tiempo $t$ condicionan o contaminan los datos que recolectás en el tiempo $t+1$. En LLMs, esto se conoce hoy como Model Collapse: si entrenás un modelo usando texto generado sintéticamente por otros LLMs, la cola de la distribución de probabilidad se recorta, la varianza de la atención colapsa y el modelo degenera en textos repetitivos e incoherentes.

La receta de mitigación en producción es siempre el Rollout Gradual:

1. Fase Sombra (Shadow Deployment): El modelo corre en paralelo sobre tráfico real pero sus predicciones no ejecutan acciones; solo se registran métricas.
2. Inspección Humana (Human-in-the-loop): Un operador revisa las predicciones donde la confianza del Softmax sea limítrofe ().
3. Monitoreo de Deriva: Alarmas automáticas que miden la divergencia de Kullback-Leibler (KL) o la distancia de Wasserstein entre los embeddings de producción y los del dataset de validación.

5. Cómo se servía en 2020 — y cómo se sirve hoy

El libro exporta el modelo completo (arquitectura + pesos + la definición del DataLoaders, incluidas las transforms) a un único archivo con learn.export(), y para inferencia usa load_learner(...) + predict. Hasta ahí, el flujo sigue vigente sin cambios:

# en el notebook de entrenamiento
learn.export('export.pkl')     # pickle con modelo + DataLoaders vacíos + transforms

# en otro proceso, sin GPU, sin el dataset
from fastai.vision.all import *
learn_inf = load_learner('export.pkl')
learn_inf.predict('images/grizzly.jpg')
learn_inf.dls.vocab               # ['black', 'grizzly', 'teddy']

Qué empaca realmente learn.export()

El archivo export.pkl no es un simple volcado de pesos; es un paquete autocontenido que resuelve todo el contrato de inferencia:

• State Dict de Parámetros: Las matrices de pesos $\mathbf{W}$ y sesgos $\mathbf{b}$ aprendidas durante el fine-tuning.
• Grafo de la Arquitectura: La definición de capas de PyTorch (Backbone ResNet + Head lineal adaptado).
• Estadísticas de Normalización: Los vectores de media y desviación estándar ($\mathit{\mu },\mathit{\sigma }\in {\mathbb{R}}^3$) con los que se normalizan los canales RGB: ${\mathbf{x}}_{\text{norm}}=(\mathbf{x}-\mathit{\mu })/\mathit{\sigma }$. Si un modelo recibiera píxeles en $[0,255]$ sin esta normalización exacta, los logits saldrían completamente degradados.
• Vocabulario (dls.vocab): La lista ordenada de strings que mapea el índice entero del argmax a la etiqueta legible.

La física de la inferencia: por qué CPU supera a GPU con batch=1

Existe la creencia errónea de que producción siempre requiere GPUs costosas. La física de hardware dicta lo contrario para servicios de usuario:

• Entrenamiento ($B=64$): La GPU domina porque miles de núcleos ALUs multiplican matrices en paralelo saturando los TFLOPs de la tarjeta.
• Inferencia individual ($B=1$): Cada llamada a la GPU paga un peaje de latencia fija:
  • Copia de memoria Host-to-Device (RAM a VRAM vía bus PCIe: ~1–3 ms).
  • Overhead de lanzamiento de kernels CUDA en el driver (~5–10 $\mu \text{s}$ por cada una de las 50 capas).
  • Sincronización y copia Device-to-Host para devolver el resultado a Python.

Un procesador moderno (x86 con instrucciones AVX-512/AMX o ARM NEON) procesa un ResNet-18 para una sola imagen en 5 a 12 milisegundos directamente en memoria caché L2/L3, sin peaje PCIe ni reserva de VRAM. Para clasificaciones visuales o extracción de features con tráfico moderado, servir en CPU es órdenes de magnitud más económico y ofrece menor latencia de cola (P99).

6. El app.py de Gradio para Hugging Face Spaces

Un Space de Gradio es un repositorio git con tres archivos: el modelo exportado, un requirements.txt y un app.py. Este es el app.py completo para el clasificador de la Lección 1 (gato/perro), con la función custom incluida por lo que dice el callout de arriba:

# app.py
from fastai.vision.all import *
import gradio as gr

def is_cat(x): return x[0].isupper()      # la misma función que usó el DataBlock al exportar

learn = load_learner('export.pkl')
labels = learn.dls.vocab                    # [False, True] → los mostramos con nombre
names = {False: 'perro', True: 'gato'}

def predict(img):
    pred, idx, probs = learn.predict(PILImage.create(img))
    return dict(zip([names[l] for l in labels], map(float, probs)))

demo = gr.Interface(
    fn=predict,
    inputs=gr.Image(type='pil'),
    outputs=gr.Label(num_top_classes=2),
    examples=['gato.jpg', 'perro.jpg'],
    title='¿Gato o perro?')

demo.launch()

# requirements.txt (gradio ya viene con el SDK del Space; fastai trae torch)
fastai

Tres detalles que explican por qué está escrito así. gr.Label espera un diccionario {etiqueta: probabilidad} con floats de Python — por eso el dict(zip(labels, map(float, probs))): probs es un tensor y hay que convertir cada elemento. gr.Image(type='pil') le entrega a tu función una imagen PIL, que PILImage.create convierte al tipo que fastai espera. Y demo.launch() en un Space levanta el servidor en el puerto que HF espera; en tu máquina abre http://127.0.0.1:7860. Para publicar: creá el Space (SDK: Gradio), cloná el repo, copiá export.pkl, app.py, requirements.txt y las imágenes de ejemplo, y hacé push — el Space instala y arranca solo. Si export.pkl pesa más de unos MB, activá git-lfs para ese archivo (git lfs track "*.pkl").

Lo que el libro proponía con ipywidgets — un botón de upload, una salida con la predicción — es exactamente lo que gr.Interface genera solo a partir de la firma de predict. La API de Gradio de esta página es la de las versiones 4 y 5 (gr.Image, gr.Label como componentes de primer nivel); si ves gr.inputs.Image(shape=...) en algún tutorial viejo, es la API anterior a 2023.

7. Errores comunes

Los problemas de esta lección casi nunca aparecen en el entrenamiento — aparecen en los datos, o recién cuando el modelo sale del notebook.

8. Resumen

1. Armar tu propio dataset desde cero (buscar con DuckDuckGo, descargar, verificar) no es el cuello de botella que parece — 150 imágenes por clase ya alcanzan para un modelo útil. La API de Bing del libro ya no existe.
2. DataBlock formaliza cuatro preguntas (blocks, get_items, splitter, get_y) en vez de escribir Dataset/DataLoader a mano; item_tfms unifica tamaños en CPU, batch_tfms hace augmentation en GPU.
3. La secuencia correcta es entrenar primero, después usar plot_top_losses y el cleaner para encontrar problemas en los datos — no limpiar todo a ciegas antes.
4. Out-of-domain data, domain shift y feedback loops son la razón por la que ningún modelo se despliega de golpe a producción completa — rollout gradual con supervisión humana.
5. learn.export() + load_learner siguen siendo el flujo de inferencia; el pickle no guarda tus funciones custom, así que el proceso que carga tiene que definirlas.
6. El stack de deployment del libro (Voilà/Binder) es historia; hoy es Hugging Face Spaces + Gradio con un app.py de 15 líneas, servido en CPU, exactamente lo que ya viste en el Capítulo 9 de HF.

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 *
from duckduckgo_search import DDGS

def search_images(term, max_images=100):
    with DDGS() as ddgs:
        return L(ddgs.images(term, max_results=max_images)).itemgot('image')

path = Path('mi_dataset')
for o in ['husky', 'malamute', 'samoyed']:
    (path/o).mkdir(parents=True, exist_ok=True)
    download_images(path/o, urls=search_images(f'{o} dog photo'))
failed = verify_images(get_image_files(path)); failed.map(Path.unlink)

dls = DataBlock(blocks=(ImageBlock, CategoryBlock), get_items=get_image_files,
                splitter=RandomSplitter(0.2, seed=42), get_y=parent_label,
                item_tfms=RandomResizedCrop(128, min_scale=0.5),
                batch_tfms=aug_transforms()).dataloaders(path, bs=32)
print({c: len((path/c).ls()) for c in dls.vocab})   # balance de clases
learn = vision_learner(dls, resnet18, metrics=error_rate)
learn.fine_tune(3)
interp = ClassificationInterpretation.from_learner(learn)
interp.plot_confusion_matrix(); interp.plot_top_losses(6, nrows=2)

# en el notebook, después de entrenar con get_y=is_cat (Lección 1)
learn.export('export.pkl')

# cargar.py — versión 1: sin is_cat
from fastai.vision.all import *
learn = load_learner('export.pkl')     # → AttributeError: Can't get attribute 'is_cat'

# cargar.py — versión 2: con is_cat definida antes
from fastai.vision.all import *
def is_cat(x): return x[0].isupper()
learn = load_learner('export.pkl')
print(learn.dls.vocab, next(learn.model.parameters()).device)
print(learn.predict('gato.jpg'))

11. Fuentes y para seguir

• Practical Deep Learning for Coders — Lesson 2: Deployment — la lección en video (2022) donde Jeremy arma el dataset con DuckDuckGo y despliega en HF Spaces con Gradio; la versión vigente de este capítulo.
• fastbook — 02_production.ipynb — el Capítulo 2 como notebook, ya actualizado a search_images_ddg; fuente del pipeline, DataBlock, cleaner y "How to Avoid Disaster".
• Is it a bird? Creating a model from your own data — el notebook de Kaggle de la lección, con la función search_images sobre duckduckgo_search lista para copiar.
• Gradio documentation — referencia de gr.Interface, gr.Image, gr.Label; leela cuando quieras pasar de Interface a Blocks.
• Hugging Face Hub — Spaces — cómo crear un Space con SDK Gradio, hardware, secretos, git-lfs para archivos grandes.
• fastai — Learner (export y load_learner) — la documentación oficial de Learner.export y load_learner, incluido el parámetro cpu.