Guía de entrenamiento de modelos 4: Guía de entrenamiento SFT

En el dominio del aprendizaje incremental (PT) para "infundir conocimiento", el **SFT (Ajuste Fino Supervisado)** es el paso más importante en la práctica. Su esencia es la **"alineación de instrucciones"**, es decir, enseñar al modelo a aprender: cuando un usuario pregunte de esta manera, el modelo debe responder en qué formato y tono.

## Preparación central de SFT

### 1. ¿Qué tipo de datos preparar?

SFT requiere **pares de preguntas y respuestas (QA)** (también conocidos como datos de Instrucción).

**Formato:** Generalmente `JSONL`.

**Estructura del contenido:**

- `instruction`: La instrucción/pregunta del usuario (por ejemplo: "Me siento muy triste hoy").
- `input`: Información de contexto opcional (por ejemplo: "El usuario acaba de perder su trabajo").
- `output`: La respuesta estándar del modelo (por ejemplo: "Te abrazo, sé cómo te sientes ahora...").

**Cantidad de datos:** Los negocios de compañía suelen requerir **500 - 5,000** pares de diálogos de múltiples rondas de alta calidad, que se ajusten a una personalidad específica.

### 2. ¿Qué software y frameworks se necesitan?

**Hardware:** Tarjeta gráfica con más de 24 GB de memoria (por ejemplo, 3090/4090/A100).

**Sistema:** Linux (Ubuntu 20.04+) es el mejor, Windows requiere WSL2.

**Frameworks centrales:**

- `PyTorch`: Base de aprendizaje profundo.
- `Transformers`: Producto de HuggingFace, biblioteca central para la carga y el entrenamiento de modelos.
- `PEFT`: Biblioteca para el ajuste fino ligero como LoRA.
- `DeepSpeed`: Manejo del paralelismo de múltiples GPU y la optimización de la memoria.

## Pasos operativos de dos esquemas

### 1. LLaMA-Factory

Este es el esquema **práctico** más recomendado en la actualidad, que equilibra la flexibilidad y la facilidad de uso.

1. **Registro de datos:** Coloca tu `sft_data.json` en la carpeta `data/`. Modifica `data/dataset_info.json` para agregar la descripción de tu conjunto de datos.
2. **Iniciar el entrenamiento (modo de línea de comandos):** Escribe un archivo de configuración `sft.yaml`:

```YAML
stage: sft # Establecer en la etapa SFT
model_name_or_path: qwen/Qwen2.5-7B
preprocessing_num_workers: 8
finetuning_type: lora # Usar LoRA para mejorar la eficiencia
template: qwen # ¡Clave! Debe ser consistente con el modelo base
dataset: my_sft_data # El nombre de tu conjunto de datos registrado
output_dir: ./sft_output # Ubicación para guardar los pesos del modelo
per_device_train_batch_size: 4
gradient_accumulation_steps: 4
learning_rate: 5e-5 # La tasa de aprendizaje de SFT suele ser más alta que la de PT
num_train_epochs: 3.0
plot_loss: true # Generar un gráfico de la curva de pérdida
```

3. **Ejecutar el comando:**

```Bash
llamafactory-cli train sft.yaml
```

4. **Combinación de modelos:** El entrenamiento produce pesos de LoRA. Ejecuta `llamafactory-cli export` con el archivo de configuración para combinarlos con el modelo original.

### 2. Escribir código por ti mismo

Esta es la opción más "hardcore", basada en el `SFTTrainer` de la biblioteca `Transformers`.

1. **Cargar el modelo y el tokenizador:**

```Python
from trl import SFTTrainer
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments
from peft import LoraConfig

model_id = "qwen/Qwen2.5-7B"
tokenizer = AutoTokenizer.from_pretrained(model_id)
tokenizer.pad_token = tokenizer.eos_token # Establecer el token de relleno
```

2. **Configurar los parámetros de LoRA:**

```Python
peft_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules="all-linear",
    task_type="CAUSAL_LM"
)
```

3. **Definir el entrenador:**

```Python
args = TrainingArguments(
    output_dir="./my_sft_model",
    per_device_train_batch_size=4,
    max_steps=1000,
    learning_rate=5e-5,
    fp16=True # Activar la precisión media para ahorrar memoria
)

trainer = SFTTrainer(
    model=model_id,
    args=args,
    train_dataset=my_dataset, # El objeto Dataset procesado previamente
    dataset_text_field="text", # Especificar el campo correspondiente en el conjunto de datos
    peft_config=peft_config,
    max_seq_length=1024,
)
```

4. **Iniciar el entrenamiento:**

```Python
trainer.train()
trainer.save_model()
```

## Resumen y recomendaciones

- **Si buscas eficiencia:** Utiliza directamente **LLaMA-Factory**. Te ayuda a resolver el problema de la plantilla de diálogo (Chat Template). *Nota: Durante el entrenamiento de SFT, si la plantilla de diálogo (como las etiquetas `<|im_start|>` etc.) es incorrecta, el modelo se volverá directamente inútil.*
- **Si solo tienes CPU o quieres una solución sin código:** Elige **阿里百炼 (Ali Bai Lian)**.
- **Si estás escribiendo un artículo o realizando investigación académica:** Escribe el código tú mismo (esquema 3), lo que te facilitará la modificación de la función de pérdida.