Guía de entrenamiento de modelos 3: Guía de entrenamiento PT

La esencia del Entrenamiento Previo Incremental (Continual Pre-training / PT) es: sobre la base de que un modelo grande ya posee capacidades generales, se le alimenta con una gran cantidad de documentos de la industria, libros o código (Texto Bruto), y a través de la tarea de **Predicción del Siguiente Token** se le permite al modelo absorber nuevos conocimientos.

Como técnico, solo necesitas recordar: PT está diseñado para que el modelo aprenda la **distribución del lenguaje, la terminología especializada y el contexto lógico** de un dominio específico en texto puro **sin formato de pregunta y respuesta**.

## Preparación de Datos PT (la base más fundamental)

- **Formato de Datos**: Texto Bruto (Raw Text). No se necesitan etiquetas `instruction` o `output`.
- **Formato de Archivo**: Generalmente `.txt` o `.jsonl` (cada línea un `{"text": "..."}`).
- **Lógica de Procesamiento**: El modelo aprenderá este contenido a través de la "predicción del siguiente Token".

## Pasos de Dos Esquemas Prácticos

### 1. LLaMA-Factory

**Escenario de Aplicación**: Entorno con GPU, buscando la máxima eficiencia.

**Pasos**:

1. **Registro de Datos**: Coloca el texto en `data/`, y agrega en `data/dataset_info.json`:

```JSON
"my_corpus": {
  "file_name": "your_data.jsonl",
  "columns": {
    "prompt": "text"
  }
}
```

2. **Escribir `pt_config.yaml`**:

```YAML
stage: pt # Clave: especificar la fase de pre-entrenamiento
model_name_or_path: qwen/Qwen2.5-7B
dataset: my_corpus
finetuning_type: lora # o full (el entrenamiento completo requiere una memoria GPU extremadamente alta)
lora_target: all # Dirigido a todas las capas lineales, PT recomienda cobertura completa
cutoff_len: 1024 # Longitud de truncamiento del contexto
learning_rate: 1e-5 # La tasa de aprendizaje de PT debe ser pequeña
num_train_epochs: 1.0
output_dir: ./pt_output
```

3. **Ejecutar Comando**:

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

### 2. Escribir Código Propio

Basado en la biblioteca Transformers

**Escenario de Aplicación**: Personalización profunda de Loss o Tokenizer.

**Pasos**:

1. **Cargar Modelo**: Usar `AutoModelForCausalLM`.
2. **Lógica Central del Código**:

```Python
from transformers import Trainer, TrainingArguments, DataCollatorForLanguageModeling

# 1. Preparar el organizador de datos (para PT)
# mlm=False indica tarea de modelado de lenguaje causal (Predicción del Siguiente Token)
data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False)

# 2. Configuración de Entrenamiento
training_args = TrainingArguments(
    output_dir="./output",
    per_device_train_batch_size=4,
    learning_rate=1e-5,
    weight_decay=0.01,
    num_train_epochs=1,
    save_steps=500
)

# 3. Iniciar Entrenamiento
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_dataset,
    data_collator=data_collator,
)
trainer.train()
```

## Detalles Técnicos del Entrenamiento PT y Puntos Comunes de Error

1. **Tasa de Aprendizaje (Learning Rate)**: La tasa de aprendizaje de PT debe ser un orden de magnitud menor que la de SFT (generalmente $10^{-5}$ o $10^{-6}$). Debido a que el modelo base ya es muy potente, una tasa de aprendizaje alta destruirá su lógica original.
2. **Calidad de los Datos**: PT es extremadamente sensible a la calidad de los datos. Si tu corpus contiene una gran cantidad de datos duplicados, ilegibles o de páginas web de baja calidad, el modelo rápidamente se volverá "menos inteligente".
3. **Sobre Ollama**: Reitero, **Ollama se utiliza para "ejecutar" modelos, no para "entrenarlos"**. Los pesos que obtengas a través de los esquemas 2 o 3, exportados al formato GGUF, se pueden usar con Ollama.

**Recomendaciones de Resumen**: Primero, ejecuta PT con **LLaMA-Factory**, ya que integra el corte de datos, la carga del modelo y la configuración de LoRA, siendo el método menos propenso a errores.