> ## 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.

# Inicio Rápido

> Entrena tu primer modelo de IA en 10 minutos

# Tu Primer Modelo de IA

Entrenemos un modelo simple de clasificación de texto que puede detectar sentimiento positivo vs negativo en texto. Este tutorial toma aproximadamente 10 minutos y funciona en cualquier computadora.

<Note>
  **¿Nuevo en AI Training?** Consulta la [Guía del Asistente Interactivo](/wizard/overview) para un tutorial más detallado, incluyendo cómo elegir modelos, entender tamaños de datasets y usar comandos del asistente.
</Note>

## Antes de Comenzar

Asegúrate de haber [instalado AI Training](/foundations/installation). Deberías poder ejecutar:

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

Si aún no lo has instalado, la forma más rápida es:

```bash theme={null}
# Instala uv si no lo tienes
curl -LsSf https://astral.sh/uv/install.sh | sh  # Mac/Linux
# o
powershell -c "irm https://astral.sh/uv/install.ps1 | iex"  # Windows

# Luego instala AI Training
uv pip install aitraining torch torchvision torchaudio
```

## Elige Tu Camino

Mostraremos la misma tarea de dos formas. Elige la que te resulte más cómoda:

<Tabs>
  <Tab title="Asistente Interactivo">
    ## Usando el Asistente Interactivo

    <Frame>
      <img src="https://mintcdn.com/monostate/wxrUXtMlFqBn3jQK/images/terminal-wizard.png?fit=max&auto=format&n=wxrUXtMlFqBn3jQK&q=85&s=3ed3f118c7139bf61490b543ea9b6c39" alt="AITraining Interactive Wizard" width="1934" height="1620" data-path="images/terminal-wizard.png" />
    </Frame>

    ### 1. Inicia el Asistente

    Abre tu terminal y ejecuta:

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

    El asistente interactivo te guía a través de la configuración.

    ### 2. Selecciona el Tipo de Tarea

    Elige **Text Classification** del menú.

    ### 3. Prepara Tus Datos

    Crea un archivo CSV simple llamado `reviews.csv`:

    ```csv theme={null}
    text,label
    "This product is amazing! Best purchase ever.",positive
    "Terrible quality. Complete waste of money.",negative
    "Great service and fast delivery.",positive
    "Broken on arrival. Very disappointed.",negative
    "Exceeded my expectations!",positive
    "Would not recommend to anyone.",negative
    ```

    ### 4. Sigue las Indicaciones

    El asistente preguntará por:

    * **Data path**: Ingresa `./reviews.csv`
    * **Model**: Elige `bert-base-uncased` (o elige de los modelos populares)
    * **Text column**: Ingresa `text`
    * **Label column**: Ingresa `label`
    * **Output directory**: Ingresa `./my-sentiment-model`

    **Comandos del Asistente:**

    * `:help` - Obtén ayuda para el paso actual
    * `:back` - Regresa al paso anterior
    * `:exit` - Cancela y sale
    * `:search <query>` - Busca modelos/datasets
    * `:sort <option>` - Ordena por trending, downloads, likes

    ### 5. Inicia el Entrenamiento

    Confirma tus configuraciones y el entrenamiento comienza.
    Observa el progreso en la terminal.

    ### 6. Prueba con Chat

    Después del entrenamiento, prueba tu modelo:

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

    Abre tu navegador en `localhost:7860` y prueba tu modelo.
  </Tab>

  <Tab title="Línea de Comandos">
    ## Usando la CLI

    ### 1. Prepara Tus Datos

    Crea un archivo llamado `train.csv`:

    ```csv theme={null}
    text,label
    "This product is amazing! Best purchase ever.",positive
    "Terrible quality. Complete waste of money.",negative
    "Great service and fast delivery.",positive
    "Broken on arrival. Very disappointed.",negative
    "Exceeded my expectations!",positive
    "Would not recommend to anyone.",negative
    ```

    ### 2. Entrena el Modelo

    Ejecuta este comando:

    ```bash theme={null}
    aitraining text-classification \
      --model bert-base-uncased \
      --data-path train.csv \
      --text-column text \
      --target-column label \
      --output-dir ./my-sentiment-model \
      --epochs 3
    ```

    Qué significa cada parte:

    * `text-classification`: El tipo de tarea
    * `--model`: Qué modelo pre-entrenado usar como punto de partida
    * `--data-path`: Tu archivo de datos de entrenamiento
    * `--text-column`: Qué columna tiene el texto
    * `--target-column`: Qué columna tiene las etiquetas
    * `--output-dir`: Dónde guardar el modelo entrenado
    * `--epochs`: Cuántas rondas de entrenamiento

    ### 3. Observa el Entrenamiento

    Verás una salida como:

    ```
    Loading model bert-base-uncased...
    Processing data...
    Training started...
    Epoch 1/3: loss=0.65, accuracy=0.67
    Epoch 2/3: loss=0.42, accuracy=0.83
    Epoch 3/3: loss=0.31, accuracy=0.92
    Model saved to ./my-sentiment-model
    ```

    ### 4. Prueba Tu Modelo

    ```bash theme={null}
    aitraining predict \
      --model-path ./my-sentiment-model \
      --text "This is absolutely fantastic!"
    ```

    Salida:

    ```
    Prediction: positive (confidence: 0.94)
    ```
  </Tab>

  <Tab title="API de Python">
    ## Usando Python

    ### 1. Crea un Script de Python

    Crea un archivo llamado `train_sentiment.py`:

    ```python theme={null}
    from aitraining import TextClassification
    import pandas as pd

    # Create training data
    data = {
        'text': [
            "This product is amazing! Best purchase ever.",
            "Terrible quality. Complete waste of money.",
            "Great service and fast delivery.",
            "Broken on arrival. Very disappointed.",
            "Exceeded my expectations!",
            "Would not recommend to anyone."
        ],
        'label': [
            'positive', 'negative', 'positive',
            'negative', 'positive', 'negative'
        ]
    }

    # Save as CSV
    df = pd.DataFrame(data)
    df.to_csv('train.csv', index=False)

    # Configure training
    trainer = TextClassification(
        model="bert-base-uncased",
        data_path="train.csv",
        text_column="text",
        target_column="label",
        output_dir="./my-sentiment-model",
        epochs=3,
        batch_size=8
    )

    # Start training
    print("Starting training...")
    trainer.train()

    # Test the model
    test_texts = [
        "This is absolutely fantastic!",
        "Complete waste of time and money."
    ]

    predictions = trainer.predict(test_texts)
    for text, pred in zip(test_texts, predictions):
        print(f"Text: {text}")
        print(f"Prediction: {pred['label']} (confidence: {pred['score']:.2f})\n")
    ```

    ### 2. Ejecuta el Script

    ```bash theme={null}
    python train_sentiment.py
    ```

    ### 3. Usa Tu Modelo Más Tarde

    ```python theme={null}
    from aitraining import load_model

    # Load your trained model
    model = load_model("./my-sentiment-model")

    # Make predictions
    result = model.predict("Best product ever!")
    print(result)  # {'label': 'positive', 'score': 0.95}
    ```
  </Tab>
</Tabs>

## ¿Qué Acaba de Pasar?

Has completado exitosamente:

1. **Preparaste datos** - Creaste ejemplos para que la IA aprenda
2. **Configuraste el entrenamiento** - Seleccionaste un modelo y configuraciones
3. **Entrenaste un modelo** - La IA aprendió patrones de tus ejemplos
4. **Probaste predicciones** - Verificaste que el modelo funciona en texto nuevo
5. **Guardaste el modelo** - Puedes usarlo en cualquier momento sin reentrenar

## Entendiendo los Resultados

Tu modelo aprendió a:

* Reconocer palabras y frases positivas
* Identificar patrones de sentimiento negativo
* Hacer predicciones en texto que no ha visto antes

Con solo 6 ejemplos, obtuviste un modelo funcional. Con más datos (cientos o miles de ejemplos), la precisión mejora significativamente.

## Próximos Pasos Comunes

<CardGroup cols={2}>
  <Card title="Agrega Más Datos" icon="database">
    Más ejemplos = mejor precisión. Intenta agregar 50-100 ejemplos por categoría.
  </Card>

  <Card title="Prueba Diferentes Modelos" icon="robot">
    Experimenta con diferentes modelos base como `distilbert-base-uncased` (más rápido) o `roberta-base` (más preciso).
  </Card>

  <Card title="Ajusta Configuraciones" icon="sliders">
    Ajusta epochs, learning rate y batch size para mejores resultados.
  </Card>

  <Card title="Despliega Tu Modelo" icon="rocket">
    Aprende cómo servir tu modelo como API o integrarlo en aplicaciones.
  </Card>
</CardGroup>

## Prueba Otras Tareas

Ahora que entiendes lo básico, prueba estas:

* **Language Generation** - Entrena un chatbot con ejemplos de conversación
* **Image Classification** - Clasifica imágenes en categorías
* **Named Entity Recognition** - Extrae nombres, lugares, fechas del texto
* **Translation** - Convierte entre idiomas

## Solución de Problemas

<AccordionGroup>
  <Accordion title="El entrenamiento es muy lento">
    * Reduce batch size a 4 o 2
    * Usa un modelo más pequeño como `distilbert`
    * Asegúrate de usar GPU si está disponible
  </Accordion>

  <Accordion title="Las predicciones del modelo son incorrectas">
    * Agrega más ejemplos de entrenamiento
    * Asegúrate de que las etiquetas sean consistentes
    * Intenta entrenar por más epochs
    * Verifica si tus datos están balanceados
  </Accordion>

  <Accordion title="Errores de memoria agotada">
    * Reduce batch size
    * Usa un modelo más pequeño
    * Habilita gradient checkpointing
    * Usa LoRA para entrenamiento eficiente
  </Accordion>
</AccordionGroup>

## ¿Qué Sigue?

* **[Entendiendo AI Training](/foundations/understanding-ai-training)** - Aprende cómo funciona el entrenamiento
* **[Eligiendo Tu Interfaz](/foundations/choosing-interface)** - Comparación detallada de UI, CLI y API
* **[Tipos de Modelos](/foundations/model-types)** - Explora diferentes arquitecturas de modelos
* **[Técnicas Avanzadas](/advanced/prompt-distillation)** - Aprende sobre DPO, ORPO y más

***

<Note>
  **Consejo Pro**: Comienza con el asistente interactivo (`aitraining`) para entender los conceptos, luego pasa a CLI para automatización, y prueba tus modelos con la interfaz de Chat (`aitraining chat`).
</Note>
