Guía ampliada para el entrenamiento de modelos: Introducción a LLaMA-Factory

En pocas palabras, **LLaMA-Factory** es actualmente la **“caja de herramientas de ajuste fino de proceso completo”** más popular y fácil de usar en la industria de modelos grandes. Si comparamos el entrenamiento de modelos con cocinar, escribir código tú mismo (biblioteca Transformers) es equivalente a comenzar desde la fundición de ollas y la siembra de verduras; mientras que LLaMA-Factory es como una **cocina integrada totalmente automática**, que encapsula el código de bajo nivel complejo. Solo necesitas introducir los “datos”, seleccionar opciones en la interfaz y completar todo el proceso, desde el **preentrenamiento incremental (PT)** hasta el **ajuste fino de instrucciones (SFT)** y luego la **alineación (DPO)**.

## Valor central (¿por qué los ingenieros lo están usando?)

1. **Totalmente integrado:** Admite casi todos los modelos de código abierto populares (Qwen, Llama, Baichuan, Yi, Mistral, Gemma, etc.).
2. **Proceso completo:** Cubre:
   - **PT** (Preentrenamiento incremental)
   - **SFT** (Ajuste fino supervisado)
   - **RLHF/DPO** (Alineación de preferencias humanas)
   - **Evaluation** (Evaluación del modelo)
   - **Export** (Fusión y exportación del modelo)
3. **Amigable con la memoria de la GPU:** Integra **LoRA, QLoRA, DeepSpeed, GaLore** y otras técnicas de ahorro de memoria de la GPU. Una 4090 con 24 GB de memoria de la GPU puede ejecutar el ajuste fino de modelos de 7B e incluso 13B.
4. **Visualización:** Proporciona una interfaz web llamada **LLaMA Board**, donde puedes ajustar los parámetros directamente en el navegador y ver las curvas de pérdida (Loss).

## Flujo de trabajo de entrenamiento (tomando el preentrenamiento incremental PT como ejemplo)

En LLaMA-Factory, no necesitas escribir scripts de entrenamiento Python complejos. Principalmente, se realiza modificando un **archivo de configuración YAML** o operando en la **WebUI**.

### 1. Preparación del entorno

```Bash
git clone https://github.com/hiyouga/LLaMA-Factory.git
cd LLaMA-Factory
pip install -e .[metrics,bitsandbytes,qwen]
```

### 2. Preparación de datos

Necesitas colocar tu corpus de texto sin formato en el directorio `data/` y registrarlo en `dataset_info.json`.

Para **PT (preentrenamiento incremental)**, el formato de los datos suele ser simple:

```JSON
[
  {"file_name": "your_corpus.txt"}
]
```

### 3. Iniciar WebUI (la forma más intuitiva)

```Bash
llamafactory-cli webui
```

Luego, abre `localhost:7860` en tu navegador:

- **Etapa de entrenamiento:** Selecciona `Pre-Training` (Preentrenamiento).
- **Ruta del modelo:** Introduce tu modelo base (por ejemplo, `Qwen/Qwen2.5-7B`).
- **Método de entrenamiento:** Selecciona `LoRA` o `Full`.
- **Tasa de aprendizaje:** Establece en `1e-5`.
- **Iniciar:** Haz clic en “Iniciar entrenamiento” y el controlador se ejecutará automáticamente en segundo plano.

### 4. Iniciar desde la línea de comandos (recomendado para entornos de producción)

Escribe un archivo `train_pt.yaml` con el siguiente contenido resumido:

```YAML
### Parámetros centrales
stage: pt # La etapa es preentrenamiento
model_name_or_path: qwen/Qwen2.5-7B
dataset: your_custom_data # Corresponde al conjunto de datos que registraste
cutoff_len: 1024 # Longitud de truncamiento de texto

### Técnicas de entrenamiento
finetuning_type: lora # Usa LoRA para ahorrar memoria de la GPU
lora_target: all # Ajusta todas las capas lineales

### Hiperparámetros
learning_rate: 0.00002
num_train_epochs: 3.0
per_device_train_batch_size: 4
gradient_accumulation_steps: 4
```

Luego, ejecuta:

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

## ¿Qué problemas resuelve LLaMA-Factory?

1. **Evita el código engorroso:** No necesitas manejar `model.backward()`, `optimizer.step()` o problemas de interbloqueo de nivel inferior en el entrenamiento distribuido (Distributed Data Parallel).
2. **Unifica el formato de los datos:** Proporciona un estándar. Siempre que conviertas tus datos al formato JSON, podrás adaptarlos a todos los modelos.
3. **Fusión con un clic:** Para los pesos de LoRA entrenados (decenas de MB), proporciona una función `export_model` que te permite fusionarlos con el modelo original en un modelo completo (varios GB) con un solo clic, listo para implementar.

## Resumen

**LLaMA-Factory es actualmente el “andamiaje de entrenamiento de modelos” más eficiente.** Tu mejor opción es:

1. **Usar el modo PT de LLaMA-Factory** para introducir tu corpus original del escenario de negocio.
2. **Usar el modo SFT de LLaMA-Factory** para introducir tus datos de diálogo de compañía que mencionaste anteriormente.
3. **Finalmente, usar su exportación GGUF o Safetensors** para la implementación.