Capítulo 1: Introducción a PEFT

Haciendo el Fine-Tuning Accesible

El Fine-Tuning Eficiente en Parámetros (PEFT) es un conjunto de técnicas que permite ajustar modelos de lenguaje grandes utilizando solo una fracción de los recursos requeridos para un ajuste completo.

---

El Problema que Resuelve PEFT

Desafíos del Fine-Tuning Completo

• Modelo 7B: Necesita ~60-80GB de VRAM para un ajuste completo
• Modelo 13B: Necesita ~110-160GB de VRAM
• Modelo 70B: Necesita ~600GB+ de VRAM

Esto excluye a la mayoría de los profesionales de ajustar modelos más grandes.

---

La Solución PEFT

Idea Clave

La mayor parte del conocimiento del modelo está en los pesos preentrenados. Solo necesitamos hacer pequeños ajustes para nuevas tareas.

Cómo Funciona

En lugar de actualizar todos los parámetros:

# Full Fine-Tuning (all parameters)
for param in model.parameters():
    param.requires_grad = True  # Update everything

# PEFT (only adapters)
for name, param in model.named_parameters():
    param.requires_grad = False  # Freeze base model
    
# Add small trainable adapter
adapter = LoRAAdapter(rank=16)  # ~0.1% of parameters

---

Beneficios de PEFT

1. Reducción Dramática de Memoria

Modelo	Full FT	PEFT	Ahorro
7B	~80GB	~6-14GB	82-92%
13B	~160GB	~10-26GB	84-94%
70B	~600GB	~48-140GB	77-92%

2. Entrenamiento Más Rápido

Full FT: 100% de los parámetros actualizados por paso
PEFT: Menos del 1% de los parámetros actualizados por paso
→ Cálculo de gradientes más rápido
→ Actualización de pesos más rápida
→ Menor ancho de banda de memoria

3. Sin Olvido Catastrófico

# Base model frozen = original knowledge preserved
base_weights = model.get_base_weights()  # Never modified
adapter_weights = model.get_adapter_weights()  # Only these change

4. Múltiples Adaptadores

# One base model, multiple adapters for different tasks
model.load_adapter("customer-support")  # Task 1
model.load_adapter("code-generation")   # Task 2
model.load_adapter("summarization")     # Task 3
# Just swap adapters at runtime!

---

Conceptos Clave

Parámetros Congelados

Parámetros que no reciben actualizaciones de gradiente durante el entrenamiento.

# Freeze a parameter
param.requires_grad = False

# Check trainable parameters
for name, param in model.named_parameters():
    if param.requires_grad:
        print(f"Trainable: {name}")

Parámetros Entrenables

Solo el pequeño conjunto de parámetros que se actualizan durante el entrenamiento con PEFT.

Adaptadores

Módulos adicionales añadidos al modelo congelado que contienen los parámetros entrenables.

---

La Librería PEFT

La librería PEFT de Hugging Face proporciona acceso unificado a todos los métodos principales de PEFT:

from peft import (
    LoraConfig,
    PrefixTuningConfig,
    PromptTuningConfig,
    IA3Config,
    AdaLoraConfig,
    get_peft_model,
    PeftModel,
)

# Configure PEFT
peft_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "v_proj"],
)

# Apply to model
model = get_peft_model(base_model, peft_config)

# Check trainable parameters
model.print_trainable_parameters()
# Output: trainable params: 4,194,304 || all params: 6,742,609,920 || trainable%: 0.0622

Funciones Clave

Función	Propósito
get_peft_model()	Envuelve el modelo base con PEFT
print_trainable_parameters()	Muestra el conteo de parámetros entrenables
save_pretrained()	Guarda solo el adaptador
merge_and_unload()	Fusiona el adaptador en el modelo base
load_adapter()	Carga un adaptador guardado

---

Comparación de Parámetros

from transformers import AutoModelForCausalLM
from peft import LoraConfig, get_peft_model

# Load base model
model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.1-8B")

# Count base parameters
total_params = sum(p.numel() for p in model.parameters())
print(f"Total parameters: {total_params:,}")  # ~8,000,000,000

# Apply LoRA
lora_config = LoraConfig(r=16, lora_alpha=32, target_modules=["q_proj", "v_proj"])
model = get_peft_model(model, lora_config)

# Count trainable
trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
print(f"Trainable: {trainable:,}")  # ~4,000,000
print(f"Percentage: {100 * trainable / total_params:.4f}%")  # ~0.05%

---

Beneficios de Almacenamiento

Guardado Solo del Adaptador

# Full model: ~15GB (7B model in fp16)
model.save_pretrained("./full-model")

# LoRA adapter only: ~10-50MB
model.save_pretrained("./lora-adapter", save_embedding_layers=False)

Múltiples Adaptadores = Almacenamiento Mínimo

Modelo Base:     15GB (compartido)
Adaptador A:     20MB (tarea 1)
Adaptador B:     20MB (tarea 2)
Adaptador C:     20MB (tarea 3)
Total:           15.06GB para 3 modelos especializados

vs Full FT:      45GB para 3 modelos separados

---

Ejemplo Rápido

Entrenamiento completo de PEFT en menos de 50 líneas:

from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import LoraConfig, get_peft_model
from trl import SFTTrainer
from datasets import load_dataset

# Load model and tokenizer
model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.1-8B")
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.1-8B")
tokenizer.pad_token = tokenizer.eos_token

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

# Apply PEFT
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()

# Load dataset
dataset = load_dataset("databricks/dolly-15k", split="train[:1000]")

# Train
trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=512,
)
trainer.train()

# Save adapter
model.save_pretrained("./my-lora-adapter")

---

Puntos Clave

✅ PEFT entrena menos del 1% de los parámetros manteniendo la calidad

✅ Ahorro de memoria del 80-95% comparado con el fine-tuning completo

✅ Los pesos del modelo base permanecen congelados, evitando el olvido

✅ Múltiples adaptadores pueden compartir un solo modelo base

✅ La librería PEFT proporciona acceso unificado a todos los métodos

✅ Los archivos de adaptadores son pequeños (~10-50MB) frente a modelos completos (~15GB+)

---

Próximos Pasos

Continúe a Capítulo 2: PEFT vs Fine-Tuning Completo para comprender los compromisos en detalle.

---

Comprobación Rápida

Antes de continuar, asegúrese de poder responder:

1. ¿Qué porcentaje de parámetros suele entrenar PEFT?
2. ¿Por qué PEFT no causa olvido catastrófico?
3. ¿Cuál es la función principal para crear un modelo PEFT?