Skip to content
Search
See every article
Hugging Face TransformersWritten by Sage

Transformers de Hugging Face: usar y afinar modelos sin empezar de cero

Transformers es la librería que te deja cargar un modelo entrenado por otros y usarlo en minutos, o seguir entrenándolo con tus propios datos. La diferencia entre entrenar desde cero y afinar (fine-tuning) es la diferencia entre meses de cómputo y una tarde con tu laptop.

Tres clases para entender cualquier modelo

Toda la librería se apoya en tres piezas: la configuración (los atributos del modelo, como el tamaño del vocabulario), el modelo en sí (que devuelve estados ocultos crudos) y el preprocesador (que convierte texto, imágenes o audio en tensores numéricos). Entender esta separación te saca de la magia negra: cuando cargás un modelo con AutoModelForCausalLM no estás invocando un hechizo, estás combinando estas tres piezas según el nombre del checkpoint. La API 'Auto' (AutoTokenizer, AutoModel, etc.) existe para no tener que adivinar qué arquitectura corresponde a qué modelo del Hub: lo infiere por vos a partir del nombre o la ruta. Esto importa porque el mismo patrón mental te sirve tanto para un modelo de texto de 2018 como para uno de visión publicado la semana pasada.

python
from transformers import AutoTokenizer, AutoModelForCausalLM
​
model_name = "openai-community/gpt2"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name, device_map="auto", dtype="auto")
​
inputs = tokenizer("La inteligencia artificial es", return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_new_tokens=30)
print(tokenizer.batch_decode(outputs, skip_special_tokens=True))

Pipeline: la puerta de entrada sin fricción

Antes de tocar tokenizers o tensores a mano, existe Pipeline, la forma más directa de correr inferencia con un modelo pretrained. Elegís una tarea (generación de texto, clasificación, reconocimiento de voz, y más) y la librería se encarga de bajar y cachear un modelo por defecto, o vos le pasás uno específico por nombre. La intuición acá es que un pipeline empaqueta las tres piezas anteriores —config, modelo y preprocesador— en un objeto que solo necesita texto de entrada y te devuelve texto de salida. Es el punto de partida correcto cuando querés probar una idea rápido, y recién cuando necesitás controlar cada parámetro pasás al modelo manual.

python
from transformers import pipeline
​
generator = pipeline("text-generation", model="openai-community/gpt2")
resultado = generator("En un futuro cercano, la inteligencia artificial")
print(resultado[0]["generated_text"])

Fine-tuning: heredar conocimiento, no empezar de cero

Afinar un modelo es continuar su entrenamiento sobre un dataset chico y específico, en vez de arrancar con pesos aleatorios. Por eso requiere una fracción del cómputo, los datos y el tiempo que necesita pretrain: el modelo ya sabe lenguaje en general, vos solo lo empujás hacia tu dominio. El proceso tiene una forma fija: tokenizás el texto, armás un data collator que arma los batches con padding dinámico (solo hasta el largo máximo de cada batch, no de todo el dataset), y le pasás todo a Trainer junto con TrainingArguments para definir épocas, batch size y learning rate. DataCollatorForLanguageModeling con mlm=False es la opción para modelos generativos tipo GPT, donde no enmascarás tokens sino que predecís el siguiente.

python
from transformers import (
AutoTokenizer,
AutoModelForCausalLM,
DataCollatorForLanguageModeling,
TrainingArguments,
Trainer,
)
from datasets import load_dataset
​
dataset = load_dataset("ruta/de/tu/dataset") # debe tener una columna de texto, ej. "horoscope"
tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2")
​
def tokenize(examples):
return tokenizer(examples["horoscope"], truncation=True, max_length=128)
​
tokenized = dataset.map(tokenize, batched=True, remove_columns=["horoscope"])
tokenized = tokenized["train"].train_test_split(test_size=0.1)
​
collator = DataCollatorForLanguageModeling(tokenizer=tokenizer, mlm=False)
model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2")
​
args = TrainingArguments(
output_dir="mi-modelo-afinado",
num_train_epochs=3,
per_device_train_batch_size=8,
learning_rate=2e-5,
)
​
trainer = Trainer(
model=model,
args=args,
train_dataset=tokenized["train"],
eval_dataset=tokenized["test"],
data_collator=collator,
)
​
trainer.train()

Publicar tu modelo en el Hub

Un modelo afinado que se queda en tu disco no le sirve a nadie más, ni siquiera a vos dentro de un mes si cambiás de máquina. Trainer incluye push_to_hub(), que sube los pesos entrenados, la configuración de generación, el tokenizer y el archivo de configuración del modelo, todo versionado como cualquier repositorio. Esto convierte tu experimento de una tarde en algo reproducible: cualquiera (incluido vos) puede cargarlo después con from_pretrained() usando el nombre del repo, exactamente igual que cargaste el modelo original.

python
trainer.push_to_hub()

Modelos que no son solo texto

El mismo patrón de tres clases y from_pretrained() funciona para visión, audio y tareas multimodales, no solo para lenguaje. Un modelo como BLIP combina un procesador de imágenes con un decodificador de texto: le pasás una imagen (y opcionalmente un texto inicial) y te devuelve una descripción generada. La intuición se mantiene idéntica a la de generación de texto: procesás la entrada a tensores, llamás generate(), decodificás la salida. Esto es lo que hace que aprender Transformers una vez te sirva para tareas que a primera vista parecen no tener nada que ver entre sí.

python
import requests
from PIL import Image
from transformers import BlipProcessor, BlipForConditionalGeneration
​
processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base")
​
img_url = 'https://storage.googleapis.com/sfr-vision-language-research/BLIP/demo.jpg'
raw_image = Image.open(requests.get(img_url, stream=True).raw).convert('RGB')
​
inputs = processor(raw_image, return_tensors="pt")
out = model.generate(**inputs)
print(processor.decode(out[0], skip_special_tokens=True))

What you can build with this

Three projects you can finish in an afternoon, each ending in something that runs.

  1. Generador de texto con un prompt fijo

    Un script que carga un modelo de generación con pipeline y produce texto a partir de distintos prompts que vos definís.

    Why it's worth it — Te da la intuición de qué controla la calidad de la generación (el modelo elegido, el prompt) antes de meterte con fine-tuning.

  2. Modelo afinado sobre un dataset de texto propio

    Fine-tuning de un modelo tipo GPT-2 con Trainer sobre un dataset chico (mensajes, reseñas, cualquier columna de texto propia) y publicación del resultado en el Hub.

    Why it's worth it — Es la forma más directa de comprobar en carne propia que afinar cuesta una fracción de lo que cuesta entrenar desde cero.

  3. Descriptor automático de imágenes

    Una app chica que recibe una imagen y devuelve una descripción generada con BLIP, con y sin texto guía.

    Why it's worth it — Muestra que el mismo patrón (procesador + modelo + generate) sirve fuera de texto, para cualquiera que necesite etiquetar imágenes sin entrenar nada desde cero.

What you take away

  • Toda la librería se reduce a tres piezas —config, modelo, preprocesador— combinadas por la API Auto según el nombre del checkpoint.

  • Pipeline es el atajo para probar ideas rápido; AutoModel + AutoTokenizer es el camino cuando necesitás control fino.

  • Fine-tuning con Trainer es entrenamiento normal pero partiendo de pesos ya útiles, por eso cuesta una fracción del tiempo y los datos.

  • El mismo patrón (cargar, procesar, generate, decodificar) funciona para texto, imágenes y tareas multimodales por igual.

This article was written from the official documentation linked below. The code comes from there, not from a model's memory.

Where this came from