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

# Início Rápido

> Treine seu primeiro modelo de IA em 10 minutos

# Seu Primeiro Modelo de IA

Vamos treinar um modelo simples de classificação de texto que pode detectar sentimento positivo vs negativo em texto. Este tutorial leva cerca de 10 minutos e funciona em qualquer computador.

<Note>
  **Novo no AI Training?** Confira o [Guia do Assistente Interativo](/wizard/overview) para um tutorial mais detalhado, incluindo como escolher modelos, entender tamanhos de datasets e usar comandos do assistente.
</Note>

## Antes de Começar

Certifique-se de ter [instalado o AI Training](/foundations/installation). Você deve conseguir executar:

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

If you haven't installed it yet, the quickest way is:

```bash theme={null}
# Install uv if you don't have it
curl -LsSf https://astral.sh/uv/install.sh | sh  # Mac/Linux
# or
powershell -c "irm https://astral.sh/uv/install.ps1 | iex"  # Windows

# Then install AI Training
uv pip install aitraining torch torchvision torchaudio
```

## Escolha Seu Caminho

Vamos mostrar a mesma tarefa de duas formas. Escolha a que você se sente confortável:

<Tabs>
  <Tab title="Assistente Interativo">
    ## Usando o Assistente Interativo

    <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. Inicie o Assistente

    Abra seu terminal e execute:

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

    O assistente interativo guia você através da configuração.

    ### 2. Selecione o Tipo de Tarefa

    Escolha **Text Classification** no menu.

    ### 3. Prepare Seus Dados

    Crie um arquivo CSV simples chamado `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. Siga os Prompts

    O assistente vai perguntar:

    * **Data path**: Digite `./reviews.csv`
    * **Model**: Escolha `bert-base-uncased` (ou escolha dos modelos em tendência)
    * **Text column**: Digite `text`
    * **Label column**: Digite `label`
    * **Output directory**: Digite `./my-sentiment-model`

    **Comandos do Assistente:**

    * `:help` - Obter ajuda para a etapa atual
    * `:back` - Voltar para a etapa anterior
    * `:exit` - Cancelar e sair
    * `:search <query>` - Buscar modelos/datasets
    * `:sort <option>` - Ordenar por tendência, downloads, curtidas

    ### 5. Inicie o Treinamento

    Confirme suas configurações e o treinamento começa.
    Acompanhe o progresso no terminal.

    ### 6. Teste com Chat

    Após o treinamento, teste seu modelo:

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

    Abra seu navegador em `localhost:7860` e teste seu modelo.
  </Tab>

  <Tab title="Linha de Comando">
    ## Usando a CLI

    ### 1. Prepare Seus Dados

    Create a file called `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. Treine o Modelo

    Execute 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
    ```

    O que cada parte significa:

    * `text-classification`: O tipo de tarefa
    * `--model`: Qual modelo pré-treinado usar como ponto de partida
    * `--data-path`: Seu arquivo de dados de treinamento
    * `--text-column`: Qual coluna tem o texto
    * `--target-column`: Qual coluna tem os rótulos
    * `--output-dir`: Onde salvar o modelo treinado
    * `--epochs`: Quantas rodadas de treinamento

    ### 3. Acompanhe o Treinamento

    Você verá uma saída 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. Teste Seu Modelo

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

    Saída:

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

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

    ### 1. Crie um Script Python

    Crie um arquivo chamado `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. Execute o Script

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

    ### 3. Use Seu Modelo Depois

    ```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>

## O Que Aconteceu?

Você conseguiu com sucesso:

1. **Preparar dados** - Criou exemplos para a IA aprender
2. **Configurar treinamento** - Selecionou um modelo e configurações
3. **Treinar um modelo** - A IA aprendeu padrões dos seus exemplos
4. **Testar previsões** - Verificou que o modelo funciona em novo texto
5. **Salvar o modelo** - Pode usar a qualquer momento sem retreinar

## Entendendo os Resultados

Seu modelo aprendeu a:

* Reconhecer palavras e frases positivas
* Identificar padrões de sentimento negativo
* Fazer previsões em texto que não viu antes

Com apenas 6 exemplos, você obteve um modelo funcional. Com mais dados (centenas ou milhares de exemplos), a precisão melhora significativamente.

## Próximos Passos Comuns

<CardGroup cols={2}>
  <Card title="Adicionar Mais Dados" icon="database">
    Mais exemplos = melhor precisão. Tente adicionar 50-100 exemplos por categoria.
  </Card>

  <Card title="Experimentar Diferentes Modelos" icon="robot">
    Experimente diferentes modelos base como `distilbert-base-uncased` (mais rápido) ou `roberta-base` (mais preciso).
  </Card>

  <Card title="Ajustar Configurações" icon="sliders">
    Ajuste epochs, learning rate e batch size para melhores resultados.
  </Card>

  <Card title="Implantar Seu Modelo" icon="rocket">
    Aprenda como servir seu modelo como uma API ou integrá-lo em aplicações.
  </Card>
</CardGroup>

## Experimente Outras Tarefas

Agora que você entende o básico, experimente estas:

* **Geração de Linguagem** - Treine um chatbot com exemplos de conversação
* **Classificação de Imagens** - Organize imagens em categorias
* **Reconhecimento de Entidades Nomeadas** - Extraia nomes, lugares, datas de texto
* **Tradução** - Converta entre idiomas

## Solução de Problemas

<AccordionGroup>
  <Accordion title="Treinamento está muito lento">
    * Reduza batch size para 4 ou 2
    * Use um modelo menor como `distilbert`
    * Certifique-se de estar usando GPU se disponível
  </Accordion>

  <Accordion title="Previsões do modelo estão erradas">
    * Adicione mais exemplos de treinamento
    * Certifique-se de que os rótulos são consistentes
    * Tente treinar por mais epochs
    * Verifique se seus dados estão balanceados
  </Accordion>

  <Accordion title="Erros de memória esgotada">
    * Reduza batch size
    * Use um modelo menor
    * Habilite gradient checkpointing
    * Use LoRA para treinamento eficiente
  </Accordion>
</AccordionGroup>

## O Que Vem Depois?

* **[Entendendo o AI Training](/foundations/understanding-ai-training)** - Aprenda como o treinamento funciona
* **[Escolhendo Sua Interface](/foundations/choosing-interface)** - Comparação detalhada de UI, CLI e API
* **[Tipos de Modelos](/foundations/model-types)** - Explore diferentes arquiteturas de modelos
* **[Técnicas Avançadas](/advanced/prompt-distillation)** - Aprenda sobre DPO, ORPO e mais

***

<Note>
  **Dica Pro**: Comece com o assistente interativo (`aitraining`) para entender os conceitos, depois mude para CLI para automação, e teste seus modelos com a interface Chat (`aitraining chat`).
</Note>
