Guía de Entrenamiento de Modelos: Fine-Tuning y Transfer Learning

El fine-tuning es el proceso de personalizar modelos pre-entrenados para tareas o dominios específicos. Con las estrategias de fine-tuning adecuadas, se pueden lograr incrementos de rendimiento de hasta un 40% en soluciones de IA empresarial.

Fundamentos del Transfer Learning

El transfer learning es la transferencia del conocimiento aprendido en una tarea hacia otra tarea.

Ventajas del Transfer Learning

1. Eficiencia de Datos: Buenos resultados con menos datos
2. Ahorro de Tiempo: Mucho más rápido que entrenar desde cero
3. Reducción de Costos: Menos recursos de cómputo
4. Rendimiento: Aprovecha el conocimiento pre-entrenado

Pre-entrenamiento vs Fine-tuning

1Pre-training:
2- Large, general dataset (TBs)
3- Learning general language/task understanding
4- Training takes months
5- Cost in millions of dollars
6
7Fine-tuning:
8- Small, domain-specific dataset (MB-GB)
9- Specific task adaptation
10- Training takes hours-days
11- Cost in thousands of dollars

Fine-Tuning Completo

Actualización de todos los parámetros del modelo.

Ventajas

• Capacidad máxima de adaptación
• Mayor rendimiento potencial

Desventajas

• Alta necesidad de memoria
• Riesgo de olvido catastrófico
• Copia de modelo separada para cada tarea

Requerimientos de Hardware

Fine-Tuning Eficiente en Parámetros (PEFT)

Fine-tuning actualizando solo una pequeña parte de los parámetros.

Ventajas de PEFT

• Eficiencia de Memoria: Reducción superior al 90%
• Velocidad: Entrenamiento más rápido
• Modularidad: Un único modelo base, múltiples adaptadores
• Olvido Catastrófico: Riesgo minimizado

LoRA (Low-Rank Adaptation)

El método PEFT más popular.

Teoría de LoRA

Actualización aproximada de la matriz de pesos con matrices de bajo rango:

1W' = W + ΔW = W + BA
2
3Where:
4- W: Original weight matrix (d × k)
5- B: Low-rank matrix (d × r)
6- A: Low-rank matrix (r × k)
7- r: Rank (typical: 8-64)

Ahorro de Parámetros

1Original: d × k parameters
2LoRA: r × (d + k) parameters
3
4Example (d=4096, k=4096, r=16):
5Original: 16.7M parameters
6LoRA: 131K parameters
7Savings: ~127x

Configuración de LoRA

1from peft import LoraConfig, get_peft_model
2
3config = LoraConfig(
4    r=16,                      # Rank
5    lora_alpha=32,             # Scaling factor
6    target_modules=[           # Which layers to apply
7        "q_proj",
8        "k_proj", 
9        "v_proj",
10        "o_proj"
11    ],
12    lora_dropout=0.05,
13    bias="none",
14    task_type="CAUSAL_LM"
15)
16
17model = get_peft_model(base_model, config)

Hiperparámetros de LoRA

Rank (r):

• Bajo (4-8): Tareas simples, pocos datos
• Medio (16-32): Uso general
• Alto (64-128): Adaptación compleja

Alpha:

• Generalmente alpha = 2 × r

Módulos Objetivo:

• Capas de atención: q_proj, k_proj, v_proj, o_proj
• Capas MLP: gate_proj, up_proj, down_proj

QLoRA (Quantized LoRA)

Combinación de LoRA + cuantización de 4 bits.

Características de QLoRA

1. 4-bit NormalFloat (NF4): Formato de cuantización personalizado
2. Doble Cuantización: Cuantización de constantes de cuantización
3. Paged Optimizers: Gestión de desbordamiento de memoria GPU

Comparación de Memoria en QLoRA

Implementación de QLoRA

1from transformers import BitsAndBytesConfig
2import torch
3
4bnb_config = BitsAndBytesConfig(
5    load_in_4bit=True,
6    bnb_4bit_use_double_quant=True,
7    bnb_4bit_quant_type="nf4",
8    bnb_4bit_compute_dtype=torch.bfloat16
9)
10
11model = AutoModelForCausalLM.from_pretrained(
12    "meta-llama/Llama-2-7b-hf",
13    quantization_config=bnb_config,
14    device_map="auto"
15)
16## Otros métodos PEFT
17
18### Prefix Tuning
19
20Agrega prefijos entrenables a las incrustaciones de entrada:
21

Input: [PREFIX_1, PREFIX_2, ..., PREFIX_N, token_1, token_2, ...]

1
2### Prompt Tuning
3
4Aprendizaje de *soft prompts*:
5

[SOFT_PROMPT] + "Actual input text"

1
2### Adapter Layers
3
4Agregar pequeñas redes entre capas *transformer*:
5

Attention → Adapter → LayerNorm → FFN → Adapter → LayerNorm

1
2### (IA)³ - Infused Adapter
3
4Multiplicar activaciones con vectores aprendidos:
5

output = activation × learned_vector

1
2## Preparación de Datos
3
4### Formatos de Datos
5
6**Instruction Format:**
7```json
8{
9  "instruction": "Summarize this text",
10  "input": "Long text...",
11  "output": "Summary..."
12}

Chat Format:

1{
2  "messages": [
3    {"role": "system", "content": "You are a helpful assistant"},
4    {"role": "user", "content": "Question..."},
5    {"role": "assistant", "content": "Answer..."}
6  ]
7}

Calidad de los Datos

Características de buenos datos:

• Diversidad (ejemplos diversos)
• Consistencia (formato consistente)
• Precisión (etiquetas precisas)
• Cantidad suficiente (normalmente 1K-100K ejemplos)

Aumento de Datos

1# Paraphrasing
2augmented_data = paraphrase(original_data)
3
4# Back-translation
5translated = translate(text, "tr")
6back_translated = translate(translated, "en")
7
8# Synonym replacement
9augmented = replace_synonyms(text)

Estrategias de Entrenamiento

Selección de Hiperparámetros

1training_args = TrainingArguments(
2    learning_rate=2e-4,        # Typical for LoRA
3    num_train_epochs=3,
4    per_device_train_batch_size=4,
5    gradient_accumulation_steps=4,
6    warmup_ratio=0.03,
7    lr_scheduler_type="cosine",
8    fp16=True,
9    logging_steps=10,
10    save_strategy="epoch",
11    evaluation_strategy="epoch"
12)

Tasa de Aprendizaje

• Full fine-tuning: 1e-5 - 5e-5
• LoRA: 1e-4 - 3e-4
• QLoRA: 2e-4 - 5e-4

Regularización

1# Weight decay
2weight_decay=0.01
3
4# Dropout
5lora_dropout=0.05
6
7# Gradient clipping
8max_grad_norm=1.0

Evaluación y Validación

Métricas

Perplexity:

PPL = exp(average cross-entropy loss)
Lower = better

BLEU/ROUGE: Calidad de generación de texto

Específicas de la tarea: Accuracy, F1, métricas personalizadas

Detección de Overfitting

1Train loss ↓ + Validation loss ↑ = Overfitting
2
3Solutions:
4- Early stopping
5- More dropout
6- Data augmentation
7- Fewer epochs

Despliegue

Model Merging

Unir el adaptador LoRA con el modelo base:

merged_model = model.merge_and_unload()
merged_model.save_pretrained("merged_model")

Multi-Adapter Serving

Múltiples adaptadores con un único modelo base:

1from peft import PeftModel
2
3base_model = AutoModelForCausalLM.from_pretrained("base")
4model_a = PeftModel.from_pretrained(base_model, "adapter_a")
5model_b = PeftModel.from_pretrained(base_model, "adapter_b")

Pipeline empresarial de Fine-Tuning

1┌─────────────┐     ┌─────────────┐     ┌─────────────┐
2│ Data        │────▶│ Training    │────▶│ Evaluation  │
3│ Preparation │     │ (LoRA/QLoRA)│     │ & Testing   │
4└─────────────┘     └─────────────┘     └──────┬──────┘
5                                                │
6                    ┌─────────────┐     ┌──────▼──────┐
7                    │ Production  │◀────│ Model       │
8                    │ Deployment  │     │ Registry    │
9                    └─────────────┘     └─────────────┘

Problemas Comunes y Soluciones

1. Falta de memoria

Solución: QLoRA, gradient checkpointing, reducir el tamaño del batch

2. Olvido catastrófico

Solución: Tasa de aprendizaje más baja, replay buffer, elastic weight consolidation

3. Overfitting

Solución: Más datos, regularización, early stopping

4. Pobre generalización

Solución: Incrementar la diversidad de datos, diversidad de instrucciones

Conclusión

El fine-tuning es la manera más efectiva de adaptar modelos preentrenados a las necesidades empresariales. Es posible realizar potentes personalizaciones incluso con recursos limitados mediante métodos PEFT como LoRA y QLoRA.

En Veni AI, proporcionamos servicios de consultoría e implementación para proyectos de fine-tuning empresarial. Contáctanos para tus necesidades.