Hugging Face Transformers

Hugging Face Transformers es actualmente la biblioteca de código abierto de NLP / IA más popular, que ofrece miles de modelos preentrenados y cubre casi todas las tareas de IA como texto, imagen, audio y multimodal.

Su valor principal: encapsula los complejos procesos de carga de modelos, inferencia y entrenamiento en unas pocas líneas de código.

Panorama del ecosistema Hugging Face Hub Más de 400 000 modelos Más de 100 000 conjuntos de datos Transformers Inferencia con modelos preentrenados y marco de ajuste fino Datasets Conjuntos de datos masivos Carga y procesamiento eficiente PEFT Ajuste fino eficiente en parámetros LoRA / QLoRA Accelerate Entrenamiento con múltiples GPU/TPU Aceleración distribuida Tokenizers Tokenizador de alto rendimiento (implementado en Rust) Evaluate Métricas de evaluación de modelos (BLEU/F1, etc.)

Tipos de tareas compatibles

Clasificación de tareas compatibles con Transformers NLP Procesamiento del lenguaje natural Clasificación de texto (análisis de sentimientos) Reconocimiento de entidades nombradas (NER) Sistema de preguntas y respuestas (QA) Generación de resúmenes de texto Traducción automática Generación de texto (diálogo) Completar espacios / modelo de lenguaje CV Visión por computadora Clasificación de imágenes Detección de objetos Segmentación de imágenes Estimación de profundidad Generación de imágenes Clasificación de videos Detección de puntos clave Audio y multimodal Reconocimiento de voz (ASR) Clasificación de audio Conversión de texto a voz (TTS) Coincidencia de imagen y texto (VQA) Generación de descripción de imágenes Preguntas y respuestas sobre documentos (DOC QA) Clasificación de cero disparos (zero-shot)

Principios centrales de la arquitectura Transformer

Antes de usar la biblioteca, comprender la arquitectura subyacente te permitirá saber por qué ajustar los parámetros de esta manera.

Arquitectura general: Encoder-Decoder

Tres grandes familias de modelos

Tres grandes familias de modelos: arquitectura x escenarios de uso x modelos representativos Modelos solo con Encoder Atención bidireccional, comprensión del contexto global Adecuado para: clasificación, NER, preguntas y respuestas (tareas de comprensión) Representantes: BERT, RoBERTa, ALBERT Chino: BERT-wwm, MacBERT Característica: puede ver todas las entradas a la vez Entrada -> [CLS] representa global, [MASK] para preentrenamiento Modelos solo con Decoder Atención causal (solo mira a la izquierda), generación autorregresiva Adecuado para: generación de texto, diálogo, generación de código Representantes: serie GPT, LLaMA, Qwen Chino: ChatGLM, Baichuan Característica: predice la siguiente palabra palabra por palabra Entrada -> predecir la siguiente palabra -> concatenar y predecir de nuevo -> bucle Modelos Encoder-Decoder Tareas de secuencia a secuencia (Seq2Seq) Adecuado para: traducción, resumen, generación de preguntas y respuestas Representantes: T5, BART, mT5 Chino: mT5, PEGASUS-Chinese Característica: codifica la entrada, decodifica para generar la salida Secuencia fuente -> Encoder -> Decoder -> Secuencia objetivo

Instalación y configuración del entorno

Instalación

# 基础安装
pip install transformers

# 完整安装（包含训练依赖）
pip install transformers[torch]       # PyTorch 后端（推荐）
pip install transformers[tf-cpu]      # TensorFlow 后端
pip install transformers[flax]        # JAX/Flax 后端

# 常用配套库
pip install datasets          # HuggingFace 数据集库
pip install evaluate          # 模型评估指标
pip install accelerate        # 多GPU/混合精度训练
pip install peft              # 参数高效微调（LoRA等）
pip install tokenizers        # 高性能分词器
pip install sentencepiece     # 部分模型（T5/LLaMA）需要

# 验证安装
python -c "import transformers; print(transformers.__version__)"

Configuración de variables de entorno

# 设置模型缓存目录（模型下载后缓存到此路径，默认 ~/.cache/huggingface）
export HF_HOME=/data/huggingface_cache

# 国内用户：使用镜像站加速下载（推荐 hf-mirror.com）
export HF_ENDPOINT=https://hf-mirror.com

# 离线模式（网络不可用时，只使用已缓存的模型）
export TRANSFORMERS_OFFLINE=1

# 禁用进度条（CI/CD 环境）
export DISABLE_TQDM=1

Ejemplo

# También se puede configurar en el código
import os
os.environ["HF_ENDPOINT"] = "https://hf-mirror.com"

# Ver el directorio de caché actual
from transformers.utils import TRANSFORMERS_CACHE
print(TRANSFORMERS_CACHE)

Pipeline: corre IA con cinco líneas de código

Pipeline es la abstracción de más alto nivel de Transformers; encapsula la carga del modelo, el preprocesamiento, la inferencia y el postprocesamiento, y permite completar la inferencia con tres a cinco líneas de código.

Flujo de trabajo interno de Pipeline Entrada original Texto / imagen Audio / otros datos Preprocesamiento Tokenización con Tokenizer Convertir a IDs de token Padding/Truncation Inferencia del modelo Propagación hacia adelante Salida de logits o vectores de capas ocultas Postprocesamiento Softmax/Argmax Decodificar token -> texto Salida formateada Resultado Etiquetas / puntuaciones Texto generado Pipeline completa automáticamente todos los pasos; el usuario solo necesita pasar la entrada original y obtener el resultado formateado.

Guía completa de ejemplos rápidos de Pipeline

Ejemplo

from transformers import pipeline

# 1. Análisis de sentimientos (clasificación de texto)
classifier = pipeline("sentiment-analysis")
result = classifier("I love using Hugging Face Transformers!")
# -> [{'label': 'POSITIVE', 'score': 0.9998}]

# 2. Generación de texto
generator = pipeline("text-generation", model="gpt2")
result = generator("Once upon a time in a land far away,",
    max_new_tokens=50, num_return_sequences=1, temperature=0.8)

# 3. Completar espacios (modelo de lenguaje enmascarado)
unmasker = pipeline("fill-mask", model="bert-base-uncased")
result = unmasker("The capital of France is [MASK].")
# -> [{'token_str': 'paris', 'score': 0.9823}, ...]

# 4. Reconocimiento de entidades nombradas (NER)
ner = pipeline("ner", aggregation_strategy="simple")
result = ner("My name is John and I work at Google in New York.")
# -> [{'entity_group': 'PER', 'word': 'John', 'score': 0.998}, ...]

# 5. Preguntas y respuestas extractivas
qa = pipeline("question-answering")
result = qa(question="Who invented Python?",
    context="Python was created by Guido van Rossum in 1991.")
# -> {'answer': 'Guido van Rossum', 'score': 0.9887}

# 6. Resumen de texto
summarizer = pipeline("summarization", model="facebook/bart-large-cnn")
result = summarizer(article, max_length=60, min_length=20)

# 7. Traducción automática
translator = pipeline("translation", model="Helsinki-NLP/opus-mt-en-zh")
result = translator("Hello, how are you today?")
# -> [{'translation_text': 'Hola, ¿cómo estás hoy?'}]

# 8. Clasificación de cero disparos (no requiere entrenamiento específico)
zero_shot = pipeline("zero-shot-classification")
result = zero_shot("I love playing football",
    candidate_labels=["sports", "politics", "technology"])
# -> {'labels': ['sports', ...], 'scores': [0.972, ...]}

Configuración avanzada de Pipeline

Ejemplo

import torch
from transformers import pipeline

# Especificar GPU
pipe = pipeline("text-generation", model="gpt2", device=0)

# Especificar precisión (ahorra memoria de video)
pipe = pipeline("text-generation", model="meta-llama/Llama-2-7b-hf",
    torch_dtype=torch.float16, device_map="auto")

# Procesamiento por lotes (aumenta el rendimiento)
pipe = pipeline("sentiment-analysis", batch_size=32)
results = pipe(large_text_list)    # Inferencia por lotes automática

# Procesamiento de textos largos por bloques
asr = pipeline("automatic-speech-recognition",
    model="openai/whisper-large-v2",
    chunk_length_s=30, stride_length_s=5)
result = asr("long_audio.wav", return_timestamps=True)

Análisis profundo del Tokenizer

El Tokenizer es el primer paso en NLP: convierte el texto original en secuencias numéricas que el modelo puede entender.

Proceso completo de Tokenization

Proceso completo de Tokenization: texto -> entrada del modelo Paso 1 Texto original: "Hello, I'm learning Transformers! It's great." Paso 2 Tokenización (Tokenize): ["Hello", ",", "I", "'m", "learning", "Transform", "##ers", "!", ...] Tokenización por subpalabras WordPiece/BPE: las palabras raras se dividen (Transformers -> Transform + ##ers) Paso 3 Agregar tokens especiales: ["[CLS]", "Hello", ",", "I", "'m", "learning", "Transform", "##ers", ... "[SEP]"] [CLS] token de clasificación, [SEP] separador, [PAD] relleno; los tokens especiales difieren según el modelo Paso 4 Convertir a IDs de Token: [101, 7592, 1010, 1045, 1005, 1049, 4083, 19081, 2121, ... 102] Cada token se asigna a un índice entero en el vocabulario y se envía a la capa de Embedding del modelo.

Uso principal del Tokenizer

Ejemplo

from transformers import AutoTokenizer

# Cargar Tokenizer
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")

# Codificación en un solo paso
encoding = tokenizer(
    "Hello, I'm learning Transformers!",
    return_tensors="pt",        # Devuelve tensor de PyTorch
    padding=True,               # Rellenar hasta la secuencia más larga
    truncation=True,            # Truncar cuando excede la longitud
    max_length=128,             # Longitud máxima
)

print(encoding.keys())
# -> dict_keys(['input_ids', 'token_type_ids', 'attention_mask'])

print(encoding["input_ids"][0][:8])
# -> tensor([101, 7592, 1010, 1045, 1005, 1049, 4083, 19081])

print(encoding["attention_mask"][0][:8])
# -> tensor([1, 1, 1, 1, 1, 1, 1, 1]) # 1=token real, 0=relleno

# Decodificación (ID -> texto)
decoded = tokenizer.decode(encoding["input_ids"][0], skip_special_tokens=True)
print(decoded)   # -> "hello, i'm learning transformers!"

# Codificación por lotes (alineación automática con padding)
texts = ["Short.", "This is a much longer sentence for testing."]
batch = tokenizer(texts, padding=True, truncation=True, return_tensors="pt")
print(batch["input_ids"].shape)   # -> torch.Size([2, 10])

# Información del vocabulario
print(f"Tamaño del vocabulario: {tokenizer.vocab_size}")      # -> 30522
print(f"[CLS] ID: {tokenizer.cls_token_id}")     # -> 101
print(f"[SEP] ID: {tokenizer.sep_token_id}")     # -> 102
print(f"Longitud máxima: {tokenizer.model_max_length}")  # -> 512

Comparación de tipos de Tokenizer comunes

Comparación de tres algoritmos de tokenización principales Algoritmo Principio Ejemplo de tokenización Modelos representativos BPE Byte Pair Encoding Combinación estadística de pares de caracteres de alta frecuencia Aprender el vocabulario óptimo de subpalabras "transformers" -> ["transform", "ers"] GPT / RoBERTa WordPiece Maximizar la probabilidad del modelo de lenguaje ## Marcador de prefijo para subpalabras "transformers" -> ["transform", "##ers"] BERT / DistilBERT SentencePiece Unigram / variante de BPE Independiente del idioma, procesamiento directo Bytes sin procesar, con marca de inicio de palabra al principio "transformers" -> ["_transform", "ers"] T5 / LLaMA / Qwen

Carga de modelos e inferencia

AutoClass: selecciona automáticamente la clase de modelo correcta

Cómo funciona AutoClass: empareja automáticamente la arquitectura de modelo correcta Nombre del modelo "bert-base-uncased" o ruta local AutoClass Lee config.json Coincide con el tipo de arquitectura AutoModel / AutoTokenizer / ... Devuelve automáticamente la clase correcta BertForSequenceClassification GPT2LMHeadModel T5ForConditionalGeneration ... Referencia rápida de AutoClass común: AutoTokenizer AutoTokenizer AutoModel Modelo base (salida de estados ocultos) AutoModelForSeqClass Tarea de clasificación de texto AutoModelForCausalLM Tarea de generación de texto

Ejemplo

import torch
from transformers import AutoTokenizer, AutoModelForSequenceClassification

model_name = "bert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(
    model_name, num_labels=2, torch_dtype=torch.float16, device_map="auto"
)

# Flujo completo de inferencia manual
text = "Transformers is an amazing library!"

# 1. Codificación
inputs = tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
inputs = {k: v.to(model.device) for k, v in inputs.items()}

# 2. Propagación hacia adelante
with torch.no_grad():
    outputs = model(**inputs)

# 3. Analizar la salida
logits = outputs.logits                       # shape: [1, 2]
probs  = torch.softmax(logits, dim=-1)
pred   = torch.argmax(probs, dim=-1).item()

id2label = model.config.id2label              # {0: 'LABEL_0', 1: 'LABEL_1'}
print(f"Clase predicha: {id2label[pred]}, confianza: {probs)

Extracción de vectores de oraciones

Ejemplo

from transformers import AutoModel, AutoTokenizer
import torch

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

def get_sentence_embedding(text: str) -> torch.Tensor:
    inputs = tokenizer(text, return_tensors="pt", max_length=512, truncation=True)
    with torch.no_grad():
        outputs = model(**inputs)
    # Aplicar mean pooling a todos los tokens
    token_embeddings = outputs.last_hidden_state          # [1, seq_len, 768]
    attention_mask = inputs["attention_mask"].unsqueeze(-1)
    mean_embedding = (token_embeddings * attention_mask).sum(1) / attention_mask.sum(1)
    return mean_embedding  # [1, 768]

vec = get_sentence_embedding("Hello world")
print(vec.shape)  # -> torch.Size([1, 768])

Práctica de diez tareas comunes

Clasificación de texto (análisis de sentimientos)

Ejemplo

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

model_name = "cardiffnlp/twitter-roberta-base-sentiment-latest"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name)

def predict_sentiment(texts):
    inputs = tokenizer(texts, return_tensors="pt", padding=True,
                       truncation=True, max_length=512)
    with torch.no_grad():
        logits = model(**inputs).logits
    probs = torch.softmax(logits, dim=-1)
    results = []
    for i, t in enumerate(texts):
        pid = probs[i].argmax().item()
        results.append({"text": t, "label": model.config.id2label[pid],
                         "score": round(probs[i][pid].item(), 4)})
    return results

print(predict_sentiment(["I love this!", "This is terrible."]))
# -> [{'text': 'I love this!', 'label': 'positive', 'score': 0.9756}, ...]

Generación de texto (diálogo / continuación)

Ejemplo

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_name = "Qwen/Qwen2-1.5B-Instruct"     # Alibaba Tongyi Qianwen (compatible con chino)
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name, torch_dtype=torch.float16, device_map="auto"
)

messages = [
    {"role": "system", "content": "Eres un asistente de IA útil."},
    {"role": "user", "content": "Explica qué es Transformer en tres frases."},
]
text = tokenizer.apply_chat_template(messages, tokenize=False,
                                      add_generation_prompt=True)
inputs = tokenizer(text, return_tensors="pt").to(model.device)

with torch.no_grad():
    output_ids = model.generate(
        **inputs, max_new_tokens=300, temperature=0.7, top_p=0.9,
        do_sample=True, repetition_penalty=1.1,
        pad_token_id=tokenizer.eos_token_id,
    )

new_tokens = output_ids[0][inputs["input_ids"].shape[1]:]
response = tokenizer.decode(new_tokens, skip_special_tokens=True)
print(response)

Reconocimiento de entidades nombradas (NER)

Ejemplo

from transformers import pipeline

ner = pipeline("ner", model="dslim/bert-base-NER", aggregation_strategy="simple")
result = ner("Elon Musk founded SpaceX in 2002 and Tesla Motors in 2003.")
for entity in result:
    print(f"{entity['word']:<20} -> {entity['entity_group']} ({entity['score']:.3f})")

# NER en chino
ner_cn = pipeline("ner", model="hfl/chinese-bert-wwm-ext-ner-msra",
                   aggregation_strategy="simple")
result = ner_cn("Xiaoming estudió en la Universidad de Pekín y luego fue a trabajar a Alibaba.")

Traducción automática

Ejemplo

from transformers import pipeline

# Traducción inglés a chino
translator = pipeline("translation", model="Helsinki-NLP/opus-mt-en-zh")
result = translator("Artificial intelligence is transforming the world.")
print(result[0]["translation_text"])   # -> La inteligencia artificial está cambiando el mundo.

# Traducción chino a inglés
translator_zh = pipeline("translation", model="Helsinki-NLP/opus-mt-zh-en")
result = translator_zh("La inteligencia artificial está cambiando el mundo.")
print(result[0]["translation_text"])

Resumen de texto

Ejemplo

from transformers import pipeline

summarizer = pipeline("summarization", model="facebook/bart-large-cnn")
result = summarizer(long_text, max_length=80, min_length=30,
                     do_sample=False, no_repeat_ngram_size=3)
print(result[0]["summary_text"])

Ajuste fino (Fine-tuning)

El ajuste fino consiste en adaptar un modelo preentrenado a tu tarea y datos específicos. Es el escenario de aplicación más importante de Transformers.

Panorama del proceso de ajuste fino

Proceso completo de ajuste fino en Transformers Preparación de datos Carga del conjunto de datos HF datasets o CSV personalizado Codificación con Tokenize Alineación con padding DataLoader Clave: calidad de los datos > Cantidad de datos Cargar modelo AutoModelForTask Especificar num_labels Congelar parámetros de las capas inferiores (Opcional) Ajustar solo las capas superiores Consejo: conjuntos de datos pequeños Primero congelar las capas inferiores Configuración de entrenamiento TrainingArguments Tasa de aprendizaje: 2e-5 Batch：32 Epochs：3~5 Pasos de warmup Decaimiento de pesos Consejo: tasa de aprendizaje Lo más importante Entrenamiento y evaluación Trainer.train() Monitorear la curva de pérdida Evaluación en conjunto de validación Early stopping Guardar el mejor ckpt Atención: sobreajuste Comparar con la línea base Guardar save_model() save_pretrained Subir al Hub Despliegue en producción Inferencia cuantizada Exportación ONNX Usar HuggingFace Trainer simplifica enormemente el flujo de entrenamiento; maneja automáticamente la acumulación de gradientes, precisión mixta, entrenamiento distribuido, etc.

Ejemplo completo de ajuste fino: clasificación de texto

Ejemplo

from datasets import load_dataset
from transformers import (
    AutoTokenizer, AutoModelForSequenceClassification,
    TrainingArguments, Trainer, DataCollatorWithPadding,
    EarlyStoppingCallback,
)
import evaluate, numpy as np

# 1. Cargar el conjunto de datos
dataset = load_dataset("imdb")   # Conjunto de datos público de HF Hub

# 2. Tokenizer + preprocesamiento
MODEL_NAME = "bert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)

def tokenize_fn(examples):
    return tokenizer(examples["text"], truncation=True, max_length=512)

tokenized_ds = dataset.map(tokenize_fn, batched=True,
                           remove_columns=["text"])
tokenized_ds = tokenized_ds.rename_column("label", "labels")
tokenized_ds.set_format("torch")
data_collator = DataCollatorWithPadding(tokenizer=tokenizer)

# 3. Cargar modelo
model = AutoModelForSequenceClassification.from_pretrained(
    MODEL_NAME, num_labels=2,
    id2label={0: "NEGATIVE", 1: "POSITIVE"},
    label2id={"NEGATIVE": 0, "POSITIVE": 1},
)

# 4. Métricas de evaluación
accuracy = evaluate.load("accuracy")
f1 = evaluate.load("f1")
def compute_metrics(eval_pred):
    logits, labels = eval_pred
    preds = np.argmax(logits, axis=-1)
    return {"accuracy": accuracy.compute(predictions=preds, references=labels)["accuracy"],
            "f1": f1.compute(predictions=preds, references=labels, average="binary")["f1"]}

# 5. Parámetros de entrenamiento
training_args = TrainingArguments(
    output_dir="./results", num_train_epochs=3,
    per_device_train_batch_size=16, per_device_eval_batch_size=32,
    gradient_accumulation_steps=2, learning_rate=2e-5,
    weight_decay=0.01, warmup_ratio=0.1,
    evaluation_strategy="steps", eval_steps=500,
    save_strategy="steps", save_steps=500,
    load_best_model_at_end=True, metric_for_best_model="f1",
    fp16=True, logging_steps=100, seed=42,
)

# 6. Crear el Trainer y entrenar
trainer = Trainer(
    model=model, args=training_args,
    train_dataset=tokenized_ds["train"],
    eval_dataset=tokenized_ds["test"],
    tokenizer=tokenizer, data_collator=data_collator,
    compute_metrics=compute_metrics,
    callbacks=[EarlyStoppingCallback(early_stopping_patience=3)],
)
trainer.train()

# 7. Evaluar y guardar
eval_result = trainer.evaluate()
print(f"Exactitud: {eval_result['eval_accuracy']:.4f}")
print(f"F1: {eval_result['eval_f1']:.4f}")

trainer.save_model("./my-sentiment-model")
tokenizer.save_pretrained("./my-sentiment-model")

LoRA ajuste fino eficiente en parámetros (recomendado)

Principio de LoRA: solo se entrenan matrices de bajo rango, y se congelan los pesos originales. Ajuste fino completo (Full Fine-tuning) W + ΔW Actualiza todas las matrices de pesos Cantidad de parámetros: todos (por ejemplo, entrenar los 7B parámetros completos) Requisito de memoria de video: extremadamente alto (requiere 4x el tamaño del modelo) Costo: caro, se necesitan muchos GPUs Ajuste fino LoRA W (congelado) No participa en el entrenamiento + B x A r << d (matriz de bajo rango) Solo entrenar aquí Cantidad de parámetros: del 0.1% al 1% del original Requisito de memoria de video: bajo (solo se almacenan los gradientes de las matrices de bajo rango) Costo: una sola GPU de 24 GB puede ajustar un modelo de 7B LoRA descompone ΔW en dos matrices de bajo rango, r es mucho menor que d (normalmente r=8~64), lo que reduce en gran medida el costo de entrenamiento.

Ejemplo

from peft import LoraConfig, get_peft_model, TaskType
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments
import torch

model_name = "meta-llama/Llama-2-7b-hf"
model = AutoModelForCausalLM.from_pretrained(
    model_name, torch_dtype=torch.float16, device_map="auto",
    load_in_4bit=True,        # Carga cuantizada de 4 bits (QLoRA), ahorra aún más memoria de video
)

# Configurar LoRA
lora_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM, r=16, lora_alpha=32,
    lora_dropout=0.05,
    target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
)

model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# -> trainable: 4,194,304 || all: 6,742,609,920 || 0.0622%

Ventajas de LoRA: entrena menos del 1% de los parámetros, reduce la memoria de video en 60-70%, es 2-3 veces más rápido, los archivos de pesos ocupan solo unos pocos MB, y se pueden guardar múltiples adaptadores LoRA para el mismo modelo base para diferentes tareas.

Guardado, carga y publicación de modelos

Ejemplo

# Guardar localmente
model.save_pretrained("./my-model")
tokenizer.save_pretrained("./my-model")

# Cargar localmente
model = AutoModelForSequenceClassification.from_pretrained("./my-model")
tokenizer = AutoTokenizer.from_pretrained("./my-model")

# Publicar en HuggingFace Hub
from huggingface_hub import login
login(token="your_hf_token")   # huggingface.co/settings/tokens
model.push_to_hub("your-username/my-sentiment-model")
tokenizer.push_to_hub("your-username/my-sentiment-model")

# Publicar directamente con Trainer
training_args = TrainingArguments(
    output_dir="your-username/my-model",
    push_to_hub=True, hub_strategy="every_save",
)

Consejos de optimización del rendimiento

Panorama de aceleración de inferencia

Pila tecnológica de aceleración de inferencia: de lo simple a la optimización profunda Nivel 1 - Optimización de costo cero Inferencia con torch.no_grad() | precisión media fp16/bf16 | inferencia por lotes | device_map="auto" para asignación automática de dispositivos Aceleración: 1.5~2x Nivel 2 - Cuantización (compresión de modelos) Cuantización de 4/8 bits con bitsandbytes | GPTQ (cuantización post-entrenamiento) | AWQ (cuantización consciente de activaciones) Aceleración: 2~4x, memoria de video reducida a la mitad Nivel 3 - Compilación y optimización en tiempo de ejecución torch.compile()（PyTorch 2.0）| FlashAttention-2 | xFormers | Optimum（TensorRT/ONNX） Aceleración: 3~10x Nivel 4 - Motores de inferencia dedicados vLLM (inferencia de LLM de alto rendimiento) | TGI | TensorRT-LLM | llama.cpp (CPU) Nivel de producción, máximo rendimiento

Ejemplo

# Carga cuantizada de 4 bits (un modelo de 13B solo necesita unos 7GB de memoria de video)
from transformers import BitsAndBytesConfig, AutoModelForCausalLM
import torch

quant_config = BitsAndBytesConfig(
    load_in_4bit=True, bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_use_double_quant=True, bnb_4bit_quant_type="nf4",
)
model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-2-13b-hf",
    quantization_config=quant_config, device_map="auto",
)

# Aceleración con FlashAttention-2 (requiere pip install flash-attn)
model = AutoModelForCausalLM.from_pretrained(
    "mistralai/Mistral-7B-v0.1",
    attn_implementation="flash_attention_2",
    torch_dtype=torch.bfloat16, device_map="auto",
)

# torch.compile (PyTorch 2.0+)
model = torch.compile(model, mode="reduce-overhead")

Solución de problemas comunes

Referencia rápida de errores comunes y soluciones Mensaje de error Causa y solución CUDA out of memory Memoria de video insuficiente Reducir batch_size; añadir gradient_accumulation_steps; usar fp16/4-bit; usar un modelo más pequeño OSError: model not found Error en el nombre del modelo o problema de red Verificar la ortografía; configurar el espejo HF_ENDPOINT; si ya se descargó, usar la ruta local ValueError: num_labels mismatch Al cargar el modelo, especificar explícitamente num_labels=tu número de clases tensors on different devices inputs = {k: v.to(model.device) for k, v in inputs.items()} loss = NaN / loss no disminuye Verificar la tasa de aprendizaje (si es demasiado grande, NaN); verificar el rango de labels (0~N-1); añadir gradient_clipping slow tokenizer / lento pip install tokenizers instala la versión rápida en Rust; usar use_fast=True (por defecto)

Resumen y ruta de aprendizaje

Ruta de aprendizaje de Transformers y puntos clave de conocimiento Primera fase Introducción (1 semana) pip install configurar entorno Ejecutar 5 tareas con Pipeline Entender el flujo del Tokenizer Inferencia manual con AutoModel Entender Encoder/Decoder Comprender la estructura de salida del modelo Segunda fase Avanzado (2 semanas) Cargar modelos del Hub Práctica de fine-tuning de clasificación de texto Uso fluido de la API Trainer Procesamiento de conjuntos de datos personalizados Evaluación con compute_metrics Guardar y publicar en el Hub Tercera fase Avanzado (3 semanas) Fine-tuning con LoRA / PEFT Cuantización (4-bit/8-bit) Uso de modelos multimodales Bucle de entrenamiento personalizado Accelerate con múltiples GPUs Aceleración con FlashAttention Cuarta fase Experto (continuo) Arquitectura de modelo personalizada Preentrenamiento desde cero Despliegue en producción con vLLM Alineación RLHF/DPO Contribuir con modelos de código abierto Investigación de artículos de vanguardia Cada fase debe incluir práctica: busca un conjunto de datos real y completa el flujo de entrenamiento -> evaluación -> publicación

Referencia rápida de API clave

Ejemplo

# 1. Cargar el tokenizador
tokenizer = AutoTokenizer.from_pretrained("model_name")

# 2. Codificar el texto
inputs = tokenizer(text, return_tensors="pt", truncation=True, max_length=512)

# 3. Cargar el modelo
model = AutoModelForSequenceClassification.from_pretrained("model_name", num_labels=N)

# 4. Inferencia
with torch.no_grad():
    outputs = model(**inputs)

# 5. Pipeline
pipe = pipeline("task_name", model="model_name")

# 6. Configuración del entrenamiento
args = TrainingArguments(output_dir="./out", num_train_epochs=3, learning_rate=2e-5)

# 7. Entrenamiento
trainer = Trainer(model=model, args=args, train_dataset=ds, compute_metrics=fn)

# 8. Guardar
model.save_pretrained("./my-model")
tokenizer.save_pretrained("./my-model")

# 9. Conjunto de datos
dataset = load_dataset("dataset_name")
dataset = dataset.map(tokenize_fn, batched=True)

# 10. LoRA
config = LoraConfig(r=16, lora_alpha=32, target_modules=["q_proj","v_proj"])
model = get_peft_model(model, config)

Recursos de referencia

Otras extensiones