¿Qué es HuggingFace?

1. El problema que resuelve

Hasta aquí, en el laboratorio, entrenaste redes desde cero: creabas los pesos al azar, los ajustabas con backpropagation, y el modelo aprendía desde nada. Eso funciona muy bien para ejemplos didácticos como el XOR. Pero en el mundo real hay un problema enorme:

Y sin embargo, tú también necesitas un modelo que entienda lenguaje. ¿Qué haces?

El único problema con esta solución es que hay literalmente decenas de miles de modelos publicados en distintos formatos, páginas web y repositorios. ¿Cómo los encuentras? ¿Cómo los descargas? ¿Cómo los usas todos con el mismo código? Eso es exactamente lo que resuelve HuggingFace.

2. Qué es HuggingFace — la biblioteca de modelos

HuggingFace es una empresa que construyó tres cosas que hoy son la columna vertebral del trabajo práctico en IA:

Piensa en HuggingFace como el GitHub de los modelos de IA: igual que GitHub es donde los programadores suben y comparten código, HuggingFace es donde los investigadores y empresas suben y comparten modelos entrenados. Y al igual que con GitHub, puedes descargarte el trabajo de otro en segundos.

3. ¿Qué tiene dentro un modelo preentrenado?

Un modelo preentrenado no es más que una red neuronal (como las que estudiaste) con sus pesos ya ajustados después de un entrenamiento masivo. Recuerda del curso de redes neuronales: los pesos son los números dentro de la red que determinan cómo se transforma la información en cada capa.

Un modelo de lenguaje preentrenado, como BERT o LLaMA, es un Transformer (el que estudiaste en el último curso) cuyos pesos fueron ajustados con cientos de gigabytes o terabytes de texto — libros, Wikipedia, código, artículos científicos, conversaciones de internet. Ese proceso de ajuste lo lleva a aprender:

Para darte una idea de la escala: BERT-base tiene 110 millones de parámetros (pesos). GPT-3 tiene 175.000 millones. Cada parámetro es un número de 4 bytes (un float32). Eso significa que solo los pesos de GPT-3 ocupan 700 GB de espacio. La librería de HuggingFace maneja todo eso por ti — descargas, partición en GPUs, conversión de formatos — con una línea.

4. Los tres componentes que usarás siempre

En HuggingFace, cada tarea involucra tres piezas que trabajan juntas. Ya conoces las ideas de los cursos anteriores — ahora les ponemos el nombre que tiene en la librería:

from transformers import AutoTokenizer

tok = AutoTokenizer.from_pretrained("bert-base-uncased")
ids = tok("Hola mundo")
print(ids["input_ids"])

from transformers import AutoModel

model = AutoModel.from_pretrained("bert-base-uncased")
print(model)

from datasets import load_dataset

ds = load_dataset("imdb")         # 50k reseñas de películas etiquetadas
print(ds["train"][0])

5. El Model Hub — cómo encontrar el modelo correcto

En huggingface.co/models hay (al momento de escribir esto) más de 500.000 modelos publicados. Eso puede abrumar. La clave es filtrar por:

El nombre de un modelo sigue el patrón usuario/nombre-del-modelo. Por ejemplo: google-bert/bert-base-uncased es el BERT base (sin diferenciar mayúsculas y minúsculas) publicado por Google BERT. Ese nombre es lo que pones en from_pretrained("...").

6. Tu primer modelo en 3 pasos

Vamos a descargar un modelo real y usarlo. Antes de nada, la instalación. Si tienes el entorno del curso de PyTorch activo, solo te falta la librería de HuggingFace:

# En la terminal (una sola vez):
pip install transformers datasets accelerate

transformers es la librería principal. datasets gestiona los datos. accelerate ayuda a usar múltiples GPUs o la GPU de Google Colab sin complicaciones. Una vez instalado, los tres pasos son siempre los mismos:

PASO 1 — Elegir y cargar el tokenizer (el que convierte texto en números)
PASO 2 — Elegir y cargar el modelo (los pesos del Transformer)
PASO 3 — Tokenizar tu texto y pasarlo por el modelo

Veámoslo con un ejemplo real — clasificación de sentimiento (positivo/negativo):

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# PASO 1: cargar el tokenizer del modelo elegido
tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased-finetuned-sst-2-english")

# PASO 2: cargar el modelo (pesos ya entrenados para clasificar sentimiento)
model = AutoModelForSequenceClassification.from_pretrained(
    "distilbert-base-uncased-finetuned-sst-2-english"
)
model.eval()   # modo evaluación — no queremos calcular gradientes

# PASO 3: tokenizar el texto y obtener la predicción
texto = "I absolutely love this product, it changed my life!"
inputs = tokenizer(texto, return_tensors="pt")   # "pt" = PyTorch tensors

with torch.no_grad():                          # sin guardar gradientes (inferencia)
    logits = model(**inputs).logits            # logits = puntuaciones crudas

prediccion = logits.argmax().item()          # el índice con mayor puntuación
etiquetas = ["NEGATIVO", "POSITIVO"]
print(f"Texto: {texto}")
print(f"Predicción: {etiquetas[prediccion]}")
print(f"Logits brutos: {logits}")

Vamos a entender cada parte sin saltarnos nada:

AutoTokenizer.from_pretrained("...")
→ Descarga el tokenizer específico de ese modelo (cada modelo tiene el suyo).
  El tokenizer sabe qué vocabulario usa ese modelo exacto.

AutoModelForSequenceClassification.from_pretrained("...")
→ Descarga los pesos (más de 66 millones de números para DistilBERT).
  "ForSequenceClassification" significa que la cabeza final produce
  un número por clase (aquí: 2 clases = negativo y positivo).

tokenizer(texto, return_tensors="pt")
→ Convierte el texto en un diccionario con:
  · input_ids: la lista de IDs (cada palabra → un número)
  · attention_mask: qué posiciones son texto real y cuáles son relleno

model(**inputs).logits
→ Pasa los IDs por todas las capas del Transformer.
  "logits" son las puntuaciones crudas antes del softmax.
  Un logit alto positivo → la clase correspondiente es probable.
  Aquí: [-3.46, +3.66] → la clase 1 (POSITIVO) tiene puntuación mucho mayor.

logits.argmax().item()
→ argmax() devuelve el índice del número más alto (0 o 1).
  .item() lo convierte de tensor a número Python normal.

🎮 Pruébalo: simula el proceso de HuggingFace

El código de arriba requiere descargar el modelo (puede tardar minutos la primera vez). Para que lo experimentes ahora, esta demo simula exactamente el mismo proceso en tu navegador, con los mismos pasos: tokenizar → pasar por el modelo → interpretar logits.

7. Por qué se llama "Auto" — la arquitectura unificada

Habrás notado que usamos AutoTokenizer y AutoModelForSequenceClassification con el prefijo "Auto". Eso no es accidental — es uno de los diseños más elegantes de HuggingFace.

Esto significa que puedes cambiar de modelo (por ejemplo, de DistilBERT a RoBERTa) cambiando solo el nombre en from_pretrained("..."). El resto del código queda igual. En el mundo real esto es invaluable: puedes probar 5 modelos distintos en minutos.

8. Lo que aprendiste

En la próxima lección vemos la forma más sencilla de usar un modelo: pipeline() — una función que envuelve tokenizer + modelo + interpretación en una sola llamada, perfecta para cuando solo quieres resultados rápidos sin escribir código de bajo nivel.