> ## Documentation Index
> Fetch the complete documentation index at: https://docs.monostate.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Tutorial de Entrenamiento SFT

> Guía completa paso a paso para entrenar tu primer LLM

# Entrenando Tu Primer LLM con SFT

Este tutorial te lleva a través de cada paso del asistente para entrenar un modelo de lenguaje usando Supervised Fine-Tuning (SFT). SFT es la forma más común de enseñar a un modelo a seguir instrucciones.

## Antes de Comenzar

Asegúrate de tener:

* AITraining instalado (`pip install aitraining`)
* Al menos 8GB de RAM (16GB recomendado)
* Una GPU es útil pero no requerida (¡Apple Silicon funciona muy bien!)

## Paso 0: Iniciar el Asistente

```bash theme={null}
aitraining
```

Verás el banner de bienvenida y las instrucciones.

## Paso 1: Elegir Tipo de Trainer

```
📋 Step 0: Choose Trainer Type

Available trainer types:
   1. Large Language Models (LLM) - text generation, chat, instruction following
   2. Text Classification - categorize text into labels
   3. Token Classification - NER, POS tagging
   ...

Select trainer type [1-10, default: 1]:
```

**Escribe `1` y presiona Enter** para seleccionar entrenamiento LLM.

<Tip>
  Escribe `:help` para ver explicaciones detalladas de lo que hace cada tipo de
  trainer.
</Tip>

## Paso 2: Elegir Método de Entrenamiento

```
📋 Step 1: Choose Training Type

Available trainers:
  1. sft             - Supervised Fine-Tuning (most common)
  2. dpo             - Direct Preference Optimization
  3. orpo            - Odds Ratio Preference Optimization
  4. ppo             - Proximal Policy Optimization (RL)
  5. reward          - Reward model training
  6. distillation    - Knowledge distillation
  7. default         - Generic training (same as SFT)

Select trainer [1-7, default: 1]:
```

**Escribe `1` y presiona Enter** para seleccionar SFT.

<Note>
  `default` y `sft` son idénticos - usan el mismo código de entrenamiento.
  `default` es solo el fallback si no se especifica ningún trainer.
</Note>

### ¿Qué Significan Estos?

| Trainer           | Cuándo Usar                                                                                         |
| ----------------- | --------------------------------------------------------------------------------------------------- |
| **SFT / default** | Enseñar al modelo a seguir instrucciones. Tienes ejemplos de buenas respuestas. **¡Comienza aquí!** |
| **DPO**           | Tienes pares de respuestas buenas vs malas para el mismo prompt                                     |
| **ORPO**          | Como DPO pero funciona con menos datos                                                              |
| **PPO**           | Avanzado: usar un modelo de recompensa para puntuar respuestas                                      |
| **Reward**        | Entrenar un modelo de recompensa para puntuar salidas (usado con PPO)                               |
| **Distillation**  | Transferir conocimiento de un modelo maestro más grande a un estudiante más pequeño                 |

## Paso 3: Nombre del Proyecto

```
📋 Step 2: Basic Configuration

Project name [my-llm-project]:
```

Ingresa un nombre para tu proyecto, como `my-first-chatbot` o presiona Enter para aceptar el predeterminado.

<Warning>
  Si existe una carpeta con ese nombre, el asistente ofrece crear un nombre
  versionado (ej.: `my-project-v2`).
</Warning>

## Paso 4: Selección de Modelo

Este es el paso más importante. El asistente muestra modelos populares de HuggingFace:

```
📋 Step 3: Model Selection

Popular models (trending):
  Sort: [T]rending [D]ownloads [L]ikes [R]ecent
  Filter size: [A]ll [S]mall(<3B) [M]edium(3-10B) [L]arge(>10B) (current: all)

  1. google/gemma-3-270m (270M)
  2. google/gemma-2-2b (2B)
  3. meta-llama/Llama-3.2-1B (1B)
  4. meta-llama/Llama-3.2-3B (3B)
  5. mistralai/Mistral-7B-v0.3 (7B)
  ...

Model (number, HF ID, or command):
```

### Eligiendo el Tamaño Correcto del Modelo

<AccordionGroup>
  <Accordion title="Tengo un MacBook (8-16GB RAM)">
    Usa `/filter` luego `S` para modelos pequeños.

    Recomendado: `google/gemma-3-270m` o `meta-llama/Llama-3.2-1B`

    Estos entrenarán en 15-30 minutos en Apple Silicon.
  </Accordion>

  <Accordion title="Tengo una PC gaming (RTX 3060/3070, 8-12GB VRAM)">
    Usa `/filter` luego `S` o `M`.

    Recomendado: `google/gemma-2-2b` o `meta-llama/Llama-3.2-3B`

    Habilita cuantización más tarde para modelos más grandes.
  </Accordion>

  <Accordion title="Tengo una estación de trabajo (RTX 3090/4090, 24GB+ VRAM)">
    Cualquier modelo hasta 10B funciona bien.

    Recomendado: `meta-llama/Llama-3.2-8B` o `mistralai/Mistral-7B-v0.3`
  </Accordion>

  <Accordion title="Tengo una GPU en la nube (A100, H100)">
    ¡Ve a lo grande!

    Recomendado: `meta-llama/Llama-3.1-70B` con cuantización
  </Accordion>
</AccordionGroup>

### Modelo Base vs Instruction-Tuned

Al seleccionar un modelo, verás dos tipos:

| Nombre del Modelo                  | Tipo                   | Cuándo Usar                                     |
| ---------------------------------- | ---------------------- | ----------------------------------------------- |
| `google/gemma-2-2b`                | Base (preentrenado)    | Propósito general, aprende tu estilo específico |
| `google/gemma-2-2b-it`             | Instruction-tuned (IT) | Ya sigue instrucciones, ajuste fino adicional   |
| `meta-llama/Llama-3.2-1B`          | Base                   | Pizarra limpia para tu caso de uso              |
| `meta-llama/Llama-3.2-1B-Instruct` | Instruction-tuned      | Ya útil, refinarlo                              |

<Note>
  **Regla general**: Usa modelos base si quieres control total. Usa
  instruction-tuned (`-it`, `-Instruct`) si quieres una ventaja inicial.
</Note>

### Seleccionando Tu Modelo

**Opción A**: Escribe un número para seleccionar de la lista:

```
Model (number, HF ID, or command): 1
✓ Model: google/gemma-3-270m
```

**Opción B**: Escribe un ID de HuggingFace directamente:

```
Model (number, HF ID, or command): google/gemma-2-2b
✓ Model: google/gemma-2-2b
```

**Opción C**: Busca modelos específicos:

```
Model (number, HF ID, or command): /search llama
```

## Paso 5: Configuración del Dataset

```
📋 Step 4: Dataset Configuration

Dataset options:
  • Local folder with CSV/JSON/Parquet files (e.g., ./data/my_dataset)
  • HuggingFace dataset ID (e.g., tatsu-lab/alpaca)
  • Choose from popular datasets below

Popular datasets (trending):
  1. tatsu-lab/alpaca — Instruction following dataset (52k)
  2. OpenAssistant/oasst1 — Conversation dataset
  3. HuggingFaceH4/ultrachat_200k — Multi-turn conversations
  ...
```

### Entendiendo el Tamaño del Dataset

<Warning>
  **Crítico**: ¡Combina el tamaño de tu dataset con el tamaño de tu modelo!

  * **Modelos pequeños (\< 1B params)**: Usa 1,000 - 10,000 ejemplos máximo
  * **Modelos medianos (1-7B params)**: 10,000 - 100,000 ejemplos
  * **Modelos grandes (7B+ params)**: 50,000+ ejemplos

  ¿Por qué? Los modelos pequeños hacen overfitting en datasets grandes. Un modelo de 270M entrenando en 52k ejemplos de Alpaca memorizará, no generalizará.
</Warning>

### Opciones de Selección de Dataset

**Usa un dataset preconstruido** (más fácil):

```
Dataset (number, HF ID, or command): 1
✓ Dataset: tatsu-lab/alpaca
🔍 Validating dataset...
✓ Dataset loaded. Columns found: instruction, input, output
```

**Usa tus propios datos**:

```
Dataset (number, HF ID, or command): ./my_data
```

**Usa un dataset de HuggingFace**:

```
Dataset (number, HF ID, or command): username/my-dataset
```

### Análisis de Formato del Dataset

El asistente analiza automáticamente tu dataset:

```
🔄 Dataset Format Analysis:
  Loading dataset sample from HuggingFace: tatsu-lab/alpaca
✓ Detected dataset format: alpaca
  • Your dataset is in alpaca format
  • This can be converted to the standard messages format for better compatibility

Do you want to analyze and convert your dataset to the model's chat format? (y/N):
```

**Escribe `y`** para habilitar la conversión automática. Esto asegura que tus datos funcionen correctamente con el template de chat del modelo.

### Splits de Entrenamiento/Validación

```
Training split name [train]:
```

Presiona Enter para usar el split predeterminado `train`.

```
Validation split name (optional) [none]:
```

Si tu dataset tiene un split de validación (`validation`, `test`), ingrésalo aquí. De lo contrario, presiona Enter para omitir.

### Máximo de Muestras (Pruebas)

```
Maximum samples (optional, for testing/debugging):
```

<Tip>
  **Para tu primer entrenamiento**: Ingresa `100` o `500` para hacer una
  ejecución de prueba rápida. Una vez que funcione, elimina el límite y entrena
  en el dataset completo.
</Tip>

## Paso 6: Configuración Avanzada (Opcional)

```
📋 Step 5: Advanced Configuration (Optional)

Would you like to configure advanced parameters?
  • Training hyperparameters (learning rate, batch size, etc.)
  • PEFT/LoRA settings
  • Model quantization
  • And more...

Configure advanced parameters? [y/N]:
```

Para tu primer entrenamiento, **presiona Enter** para omitir esto y usar valores predeterminados inteligentes.

### Cuándo Configurar Opciones Avanzadas

| Situación                         | Qué Cambiar                                      |
| --------------------------------- | ------------------------------------------------ |
| El entrenamiento es muy lento     | Habilita LoRA (`peft=True`) para reducir memoria |
| Sin memoria                       | Reduce `batch_size` o habilita cuantización      |
| El modelo no está aprendiendo     | Ajusta `lr` (tasa de aprendizaje)                |
| Quieres rastrear el entrenamiento | Habilita logging W\&B                            |

## Paso 7: Revisar e Iniciar

```
📋 Configuration Summary

Basic Configuration:
  • trainer: sft
  • project_name: my-first-chatbot

Dataset:
  • data_path: tatsu-lab/alpaca
  • train_split: train
  • auto_convert_dataset: ✓

Model & Training:
  • model: google/gemma-3-270m

Logging:
  • log: wandb ✓
  • wandb_visualizer: ✓ (LEET panel will open automatically)

✓ Configuration is valid!

🚀 Start training with this configuration? [Y/n]:
```

**Presiona Enter** para iniciar el entrenamiento!

## Qué Sucede Después

1. El modelo se descarga (solo la primera vez)
2. El dataset se carga y convierte
3. El entrenamiento comienza con actualizaciones de progreso
4. El panel W\&B LEET muestra métricas en tiempo real (si está habilitado)
5. Tu modelo entrenado se guarda en la carpeta del proyecto

```
Loading model google/gemma-3-270m...
Processing data...
Training started...
Epoch 1/1: loss=2.45, accuracy=0.52
Step 100/500: loss=1.89
Step 200/500: loss=1.42
...
Model saved to ./my-first-chatbot
```

## Probando Tu Modelo

Después de que el entrenamiento complete:

```bash theme={null}
aitraining chat
```

¡Abre `http://localhost:7860/inference` y carga tu modelo desde `./my-first-chatbot` para probarlo!

## Problemas Comunes

<AccordionGroup>
  <Accordion title="Error de falta de memoria">
    * Usa un modelo más pequeño (filtrar por tamaño)
    * Habilita LoRA en opciones avanzadas
    * Reduce el tamaño del batch
    * Habilita cuantización (`int4`)
  </Accordion>

  {" "}

  <Accordion title="El modelo no está aprendiendo (loss permanece alto)">
    * Verifica el formato de tu dataset - Prueba una tasa de aprendizaje más alta
    * Asegúrate de que tus datos tengan las columnas correctas
  </Accordion>

  <Accordion title="El entrenamiento es muy lento">
    * Habilita precisión mixta (`bf16`) en opciones avanzadas
    * Usa un dataset más pequeño primero
    * Habilita LoRA
  </Accordion>
</AccordionGroup>

## Próximos Pasos

<CardGroup cols={2}>
  <Card title="Entendiendo Modelos" href="/wizard/choosing-models" icon="robot">
    Inmersión profunda en la selección de modelos
  </Card>

  <Card title="Guía de Datasets" href="/wizard/dataset-guide" icon="database">
    Prepara tus propios datos de entrenamiento
  </Card>

  <Card title="Entrenamiento DPO" href="/advanced/dpo-training" icon="scale-balanced">
    Entrena con datos de preferencia
  </Card>

  <Card title="Eficiencia LoRA" href="/advanced/lora-peft" icon="bolt">
    Entrena modelos grandes en hardware limitado
  </Card>
</CardGroup>