Hugging Face Transformers en 2026: NLP, fine-tuning y preguntas de entrevista

Hugging Face Transformers se ha consolidado como la biblioteca estándar para trabajar con modelos basados en transformers, ya sea en NLP, visión por computadora o procesamiento de audio. Con el lanzamiento de Transformers v5 y más de un millón de checkpoints de modelos en el Hub, dominar este ecosistema es ahora un requisito básico en las entrevistas de data science.

Arquitectura de Transformers v5 y cambios clave en la API

El salto de la v4 a la v5 representa el mayor cambio estructural desde la creación de la biblioteca. Las instalaciones diarias pasaron de 20.000 a más de 3 millones durante los cinco años de vida de la v4, y gran parte del código había acumulado deuda técnica que la v5 corrige de forma directa.

Tres cambios importan más para quienes la usan a diario:

1. Backend solo PyTorch — Se eliminaron las implementaciones de modelos en TensorFlow y Flax. La compatibilidad con JAX se mantiene mediante bibliotecas asociadas, pero todas las definiciones de modelos en Transformers ahora apuntan exclusivamente a PyTorch.
2. Procesador unificado — Los modelos multimodales (visión-lenguaje, audio-lenguaje) antes requerían combinaciones ad hoc de tokenizers y extractores de características. Un único objeto processor ahora gestiona todo el preprocesamiento.
3. Servidor de inferencia integrado — El comando transformers serve expone una API compatible con OpenAI con batching continuo y atención paginada, lo que elimina la necesidad de una infraestructura de serving separada en muchos casos.

# serve_model.py
# Start an OpenAI-compatible inference server from the command line
# transformers serve --model meta-llama/Llama-4-Scout-17B-16E-Instruct --compile

# Or use the Python API directly
from transformers import pipeline

# The pipeline API remains the fastest way to get predictions
classifier = pipeline("sentiment-analysis", model="distilbert-base-uncased-finetuned-sst-2-english")
results = classifier(["Transformers v5 simplifies everything.", "Legacy code migration is painful."])
print(results)
# [{'label': 'POSITIVE', 'score': 0.9998}, {'label': 'NEGATIVE', 'score': 0.9994}]

La API pipeline oculta la tokenización, la carga del modelo y el posprocesamiento tras una única llamada de función. Para cargas de producción, transformers serve ofrece la misma simplicidad con batching y manejo de concurrencia adecuados.

Cargar y usar modelos preentrenados desde el Hub

El Hub de Hugging Face aloja más de un millón de checkpoints de modelos. Cargar cualquiera de ellos requiere solo dos líneas de código, pero saber qué modelo elegir y cómo configurarlo separa a los principiantes de quienes tienen experiencia.

Las clases AutoModel detectan la arquitectura correcta a partir de los metadatos de la tarjeta del modelo. Esto significa que el mismo código de carga funciona para BERT, GPT, T5, Llama o cualquier otra arquitectura:

# load_model.py
from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load tokenizer and model — architecture detected automatically
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
model = AutoModelForSequenceClassification.from_pretrained("bert-base-uncased", num_labels=3)

# Tokenize input text with padding and truncation
inputs = tokenizer(
    "Hugging Face makes NLP accessible.",
    return_tensors="pt",     # Return PyTorch tensors
    padding=True,
    truncation=True,
    max_length=128
)

# Run inference with no gradient computation
with torch.no_grad():
    outputs = model(**inputs)
    predictions = torch.softmax(outputs.logits, dim=-1)
    print(f"Class probabilities: {predictions}")

El método from_pretrained descarga los pesos del modelo, su configuración y el vocabulario del tokenizer en la primera llamada, y luego los almacena en caché localmente. Las llamadas posteriores cargan desde la caché sin peticiones de red.

Fine-tuning con LoRA y la API Trainer

El fine-tuning completo de modelos grandes exige una memoria GPU considerable — un modelo de 7000 millones de parámetros necesita unos 28 GB solo para los pesos en FP32. LoRA (Low-Rank Adaptation) reduce los requisitos de memoria entre un 60 y un 80 % al congelar los pesos preentrenados e inyectar pequeñas matrices entrenables en cada capa.

La biblioteca PEFT se integra directamente con Transformers para que el fine-tuning con LoRA sea sencillo:

# finetune_lora.py
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer
from peft import LoraConfig, get_peft_model, TaskType
from datasets import load_dataset

# Load base model and tokenizer
model_name = "Qwen/Qwen3-0.6B"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto")

# Configure LoRA — only 0.5-2% of parameters become trainable
lora_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    r=16,                   # Rank of the low-rank matrices
    lora_alpha=32,          # Scaling factor
    lora_dropout=0.05,      # Dropout for regularization
    target_modules=["q_proj", "v_proj"],  # Which attention layers to adapt
)

# Wrap the model with LoRA adapters
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# trainable params: 1,572,864 || all params: 631,000,000 || trainable%: 0.25

# Load and tokenize dataset
dataset = load_dataset("tatsu-lab/alpaca", split="train[:5000]")

def tokenize(example):
    return tokenizer(example["text"], truncation=True, max_length=512, padding="max_length")

tokenized = dataset.map(tokenize, batched=True, remove_columns=dataset.column_names)

# Configure training
training_args = TrainingArguments(
    output_dir="./lora-qwen",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,  # Effective batch size = 16
    learning_rate=2e-4,
    bf16=True,                      # Use bfloat16 mixed precision
    logging_steps=50,
    save_strategy="epoch",
)

# Train
trainer = Trainer(model=model, args=training_args, train_dataset=tokenized)
trainer.train()

Los adaptadores LoRA se guardan por separado del modelo base (normalmente de 10 a 50 MB frente a varios GB). Se pueden intercambiar varios adaptadores en el momento de la inferencia sin recargar los pesos base, lo que hace que LoRA sea especialmente útil para servir varios modelos especializados desde un único despliegue.

Construir un pipeline de NLP: de la tokenización a la inferencia

Cada tarea de NLP en Transformers sigue el mismo patrón de tres pasos: tokenizar la entrada, pasarla por el modelo y decodificar la salida. Comprender este flujo es esencial para depurar sistemas de producción y responder preguntas de entrevista sobre la arquitectura transformer.

La tokenización convierte el texto en bruto en identificadores numéricos que el modelo entiende. Cada familia de modelos usa una estrategia de tokenización distinta — BERT usa WordPiece, los modelos GPT usan BPE y T5 usa SentencePiece:

# tokenization_demo.py
from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
text = "Transformers handle tokenization automatically."

# Step-by-step tokenization
tokens = tokenizer.tokenize(text)          # Split into subwords
print(f"Tokens: {tokens}")
# ['transformers', 'handle', 'token', '##ization', 'automatically', '.']

ids = tokenizer.convert_tokens_to_ids(tokens)  # Convert to numeric IDs
print(f"IDs: {ids}")
# [19081, 5765, 19204, 6032, 8073, 1012]

# The encode method does both steps plus adds special tokens
encoded = tokenizer.encode(text, add_special_tokens=True)
print(f"Encoded with special tokens: {encoded}")
# [101, 19081, 5765, 19204, 6032, 8073, 1012, 102]
# 101 = [CLS], 102 = [SEP]

El token ##ization ilustra la tokenización en subpalabras — las palabras poco frecuentes se dividen en subpalabras conocidas, que es como los modelos manejan vocabulario no visto durante el preentrenamiento sin recurrir a un repliegue a nivel de carácter.

Cuantización para un despliegue eficiente

La cuantización reduce el tamaño del modelo y la latencia de inferencia al convertir los pesos desde coma flotante de 32 bits a formatos de menor precisión. El enfoque más práctico en 2026 usa bitsandbytes para la cuantización de 4 bits, que hace que un modelo de 7000 millones de parámetros entre en unos 4 GB de memoria GPU:

# quantize_model.py
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
import torch

# Configure 4-bit quantization
quant_config = BitsAndBytesConfig(
    load_in_4bit=True,                      # Use 4-bit precision
    bnb_4bit_compute_dtype=torch.bfloat16,  # Compute in bfloat16
    bnb_4bit_quant_type="nf4",              # NormalFloat4 quantization
    bnb_4bit_use_double_quant=True,         # Quantize the quantization constants
)

# Load quantized model — fits in ~4GB VRAM instead of ~14GB
model = AutoModelForCausalLM.from_pretrained(
    "mistralai/Mistral-7B-Instruct-v0.3",
    quantization_config=quant_config,
    device_map="auto",  # Automatically distribute across available GPUs
)

tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-Instruct-v0.3")

# Inference works identically to the non-quantized model
inputs = tokenizer("Explain quantization in one sentence:", return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_new_tokens=50)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

La cuantización de 4 bits suele reducir la calidad en menos de un 1 % en los benchmarks estándar mientras recorta el uso de memoria en un 75 %. Combinada con LoRA, permite hacer fine-tuning en una sola GPU de consumo de modelos que de otro modo requerirían configuraciones multi-GPU — una técnica conocida como QLoRA.

Preguntas frecuentes de entrevista sobre Hugging Face y respuestas

Las entrevistas de data science en 2026 evalúan cada vez más el conocimiento práctico de Transformers junto con la comprensión teórica. Las siguientes preguntas aparecen con frecuencia en los filtros técnicos para puestos de ingeniero de ML y data scientist.

¿Qué es la self-attention y cómo la extiende la atención multi-cabeza?

La self-attention calcula una representación ponderada de cada token según su relación con todos los demás tokens de la secuencia. Para cada token, el modelo produce tres vectores: query (Q), key (K) y value (V). La puntuación de atención entre dos tokens es igual al producto escalar de la query de uno con la key del otro, escalado por la raíz cuadrada de la dimensión de la key, y luego pasado por una softmax. La salida es la suma ponderada de los vectores value.

La atención multi-cabeza ejecuta este proceso varias veces en paralelo con distintas proyecciones aprendidas. Cada "cabeza" puede aprender a atender a distintos tipos de relaciones — la estructura sintáctica en una cabeza, la correferencia en otra, la proximidad posicional en una tercera. Las salidas se concatenan y se proyectan de nuevo a la dimensión del modelo.

¿Por qué los transformers necesitan codificación posicional?

A diferencia de las RNN y las LSTM, los transformers procesan todos los tokens de forma simultánea en lugar de secuencial. Sin información de posición, el modelo trata la entrada como una bolsa de tokens sin noción de orden. Las codificaciones posicionales (funciones sinusoidales fijas o embeddings aprendidos) se suman a los embeddings de tokens antes de la primera capa de atención. Los modelos modernos como LLaMA y Qwen usan Rotary Position Embeddings (RoPE), que codifican posiciones relativas en lugar de absolutas y generalizan mejor a secuencias más largas que las vistas durante el entrenamiento.

¿Cuándo conviene preferir LoRA al fine-tuning completo?

LoRA es la mejor opción cuando la memoria GPU es limitada, cuando el modelo base es grande (7000 millones de parámetros o más) o cuando se necesitan servir varios adaptadores específicos de tareas desde un único modelo base. El fine-tuning completo produce resultados marginalmente mejores en los benchmarks (normalmente entre un 0,5 y un 2 % más de precisión) pero requiere de 4 a 8 veces más memoria y crea una copia completa del modelo para cada tarea. En la práctica, LoRA logra una calidad comparable en la mayoría de las tareas posteriores mientras reduce de forma significativa el tiempo de entrenamiento y los costos de infraestructura.

¿Cuál es la diferencia entre modelos solo encoder, solo decoder y encoder-decoder?

| Arquitectura | Ejemplos | Ideal para | Patrón de atención | |---|---|---|---| | Solo encoder | BERT, RoBERTa, DeBERTa | Clasificación, NER, embeddings | Bidireccional (ve todo el contexto) | | Solo decoder | GPT, LLaMA, Mistral, Qwen | Generación de texto, chat, código | Causal (solo de izquierda a derecha) | | Encoder-decoder | T5, BART, mBART | Traducción, resumen | Cross-attention entre encoder y decoder |

Los modelos solo encoder destacan en tareas de comprensión porque la atención bidireccional permite que cada token atienda a todos los demás tokens. Los modelos solo decoder dominan las tareas de generación porque el enmascaramiento causal produce de forma natural un token a la vez. Los modelos encoder-decoder combinan ambas capacidades pero han sido en gran medida superados por los modelos solo decoder, que logran resultados comparables con arquitecturas más simples.

¿Cómo maneja la API Trainer el entrenamiento distribuido?

La clase Trainer detecta automáticamente las GPU disponibles y configura el paralelismo de datos. Para el entrenamiento multinodo, se integra con el DistributedDataParallel de PyTorch y admite las etapas ZeRO 1 a 3 de DeepSpeed mediante un único archivo de configuración. Establecer deepspeed="ds_config.json" en TrainingArguments basta para habilitar el offloading ZeRO-3, que fragmenta los estados del optimizador, los gradientes y los parámetros del modelo entre las GPU y, opcionalmente, los delega a la RAM de la CPU.

¿Qué métricas importan al evaluar un modelo de NLP?

La elección depende de la tarea. Para clasificación: accuracy, F1-score (especialmente macro-F1 para clases desbalanceadas), precisión y recall. Para generación: BLEU, ROUGE y cada vez más BERTScore, que correlaciona mejor con el juicio humano. Para recuperación y embeddings: recall@k, NDCG y mean reciprocal rank. Los sistemas de producción también deben monitorear la latencia de inferencia (p50/p99), el rendimiento (tokens/segundo) y el uso de memoria junto con las métricas de calidad.

Prepararse para entrevistas de Hugging Face y NLP

La preparación técnica para entrevistas de data science enfocadas en NLP se beneficia más de la práctica directa con la biblioteca Transformers que del estudio puramente teórico. El enfoque más eficaz combina tres elementos:

• Construir proyectos de extremo a extremo — un clasificador de sentimientos, un reconocedor de entidades nombradas o un pipeline de resumen. Cada uno obliga a tomar decisiones sobre preprocesamiento, selección de modelo y evaluación que los entrevistadores indagan directamente.
• Leer las tarjetas de modelo — las tarjetas de modelo del Hub documentan los datos de entrenamiento, el uso previsto, las limitaciones y los resultados de evaluación. Los entrevistadores esperan que los candidatos evalúen las tarjetas de modelo de forma crítica en lugar de elegir a ciegas el checkpoint más descargado.
• Perfilar memoria y latencia — entender los compromisos entre la inferencia FP32, FP16, BF16 e INT4 en distintas configuraciones de hardware separa a los candidatos senior de los junior.

El módulo de práctica de NLP y Hugging Face de SharpSkill cubre estos temas mediante preguntas de entrevista específicas con explicaciones detalladas. Para una preparación más amplia sobre los mecanismos de atención de los transformers y los fundamentos de deep learning, la ruta de data science ofrece itinerarios de práctica estructurados.

Conclusión

• Transformers v5 consolida la biblioteca en torno a PyTorch, elimina los backends heredados e introduce serving integrado con transformers serve para la inferencia en producción.
• Las API AutoModel y pipeline siguen siendo el camino más rápido de cero a predicciones funcionales — dos líneas de código cargan cualquiera de los más de un millón de modelos del Hub.
• El fine-tuning con LoRA mediante PEFT reduce los requisitos de memoria GPU entre un 60 y un 80 % manteniéndose dentro del 1-2 % de la calidad del fine-tuning completo en la mayoría de las tareas.
• La cuantización de 4 bits con bitsandbytes hace que los modelos de 7000 millones de parámetros entren en 4 GB de VRAM, y QLoRA combina ambas técnicas para el fine-tuning en GPU de consumo.
• Las preguntas de entrevista se centran en tres áreas: conocimiento de la arquitectura (self-attention, codificación posicional, encoder vs decoder), habilidades prácticas (fine-tuning, cuantización, selección de modelo) y diseño de sistemas (entrenamiento distribuido, serving, optimización de memoria).
• Entender el funcionamiento interno de la tokenización (WordPiece, BPE, SentencePiece) y saber depurar el comportamiento de un tokenizer es un factor diferenciador en las entrevistas que suele subestimarse.