📚 Módulo 5: Configuración Práctica — Hiperparámetros, target_modules y Entorno

5.1 Configuración del Entorno (Google Colab)

Para ejecutar QLoRA en Google Colab (gratuito), sigue estos pasos:

# Instalar dependencias
!pip install -q bitsandbytes transformers accelerate peft trl

# Verificar GPU
import torch
print(f"GPU disponible: {torch.cuda.is_available()}")
print(f"Nombre de la GPU: {torch.cuda.get_device_name(0)}")

Nota: En Colab, asegúrate de seleccionar una GPU T4 (Runtime → Change runtime type → GPU).

5.2 Cargar el Modelo con Cuantización de 4 bits

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
import torch

# Configuración de cuantización
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,
)

# Cargar modelo y tokenizer
model_name = "Qwen/Qwen2.5-0.5B-Instruct"

model = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=bnb_config,
    device_map="auto",  # Distribuye automáticamente las capas entre GPU/CPU
    trust_remote_code=True  # Requerido para algunos modelos como Qwen
)

tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)

5.3 Configurar LoRA/QLoRA

from peft import LoraConfig

lora_config = LoraConfig(
    r=8,                         # Dimensión de matriz de rango bajo
    lora_alpha=16,               # Factor de escala (típicamente 2x r)
    target_modules=["q_proj", "v_proj"],  # Módulos donde aplicar LoRA
    lora_dropout=0.05,           # Dropout de regularización
    bias="none",                 # No entrenar sesgos
    task_type="CAUSAL_LM"        # Tipo de tarea: modelado de lenguaje causal
)

# Aplicar PEFT al modelo
from peft import get_peft_model

model = get_peft_model(model, lora_config)
model.print_trainable_parameters()

Salida esperada:
trainable params: 327,680 || all params: 510,550,016 || trainable%: 0.0642

Esto confirma que solo el 0.06% de los parámetros se entrenan — ¡más de 510 millones congelados!

5.4 Elegir target_modules

target_modules son las capas del modelo donde se insertan las matrices LoRA. La selección correcta es crucial para el rendimiento.

En arquitecturas estándar (Llama, Mistral, Qwen):

• Recomendado: ["q_proj", "v_proj"] — Proyecciones de Consulta y Valor en capas de atención.
• Alternativa: ["q_proj", "k_proj", "v_proj", "o_proj"] — Todas las proyecciones de atención (más parámetros, posible mejora en tareas complejas).
• Opcional: Agregar capas MLP densas: ["gate_proj", "up_proj", "down_proj"] (en Llama) o ["fc1", "fc2"] (en otros).

Cómo descubrir nombres de módulos en tu modelo:

# Listar todos los módulos lineales en el modelo
from peft.utils import TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING

# O inspeccionar manualmente
for name, module in model.named_modules():
    if isinstance(module, torch.nn.Linear):
        print(name)

Consejo: Comienza con ["q_proj", "v_proj"]. Si el rendimiento es insuficiente, experimenta agregando más módulos.

5.5 Otros Hiperparámetros Clave

• r (rango): Comienza con 8. Si el modelo no aprende bien, prueba 16 o 32. Si hay sobreajuste, reduce a 4.
• lora_alpha: Generalmente se establece en 2 * r. Si r=8, alpha=16. Controla la "fuerza" de las actualizaciones LoRA.
• lora_dropout: 0.05 o 0.1 para conjuntos de datos pequeños. 0.0 para conjuntos de datos grandes.
• bias: "none" es más común. "all" o "lora_only" rara vez mejoran el rendimiento.