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

# Quando Usar a API

> Integração Python para aplicações personalizadas

# Quando Usar a API Python

A API oferece controle programático completo para construir aplicações personalizadas.

## Melhor Para

* **Aplicações personalizadas** - Construa suas próprias ferramentas
* **Fluxos de trabalho complexos** - Pipelines de múltiplos passos
* **Configuração dinâmica** - Ajuste em tempo real
* **Integração** - Conecte com código existente
* **Sistemas de produção** - Implante como serviços

## Como Parece

Escreva código Python:

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

trainer = TextClassification(
    model="bert-base-uncased",
    learning_rate=2e-5
)

trainer.train(data)
predictions = trainer.predict(texts)
```

## Exemplo de Fluxo de Trabalho

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

# Pré-processamento personalizado
data = pd.read_csv("raw_data.csv")
data = clean_and_prepare(data)

# Configuração dinâmica
config = {
    "model": get_best_model(data),
    "batch_size": calculate_batch_size(),
    "epochs": 5 if len(data) > 1000 else 10
}

# Treinar com callbacks
trainer = AutoTrainer(**config)
trainer.train(
    data,
    callbacks=[
        early_stopping,
        checkpoint_best,
        log_to_wandb
    ]
)

# Integrar em aplicação
@app.route("/predict")
def predict():
    result = trainer.predict(request.json)
    return jsonify(result)
```

## Vantagens

* **Controle total** - Acesse tudo
* **Lógica personalizada** - Seu pré-processamento
* **Integração** - Funciona com qualquer biblioteca Python
* **Dinâmico** - Ajuste com base em condições
* **Testável** - Teste unitário do seu treinamento

## Limitações

* **Mais código** - Você escreve a orquestração
* **Complexidade** - Lide com erros você mesmo
* **Apenas Python** - Não é agnóstico de linguagem
* **Dependências** - Gerencie pacotes

## Quando Mudar

Use CLI quando você:

* Precisa de automação simples
* Quer solução agnóstica de linguagem
* Prefere configuração em vez de código
* Trabalha com ferramentas não-Python

Use UI quando você:

* Precisa de feedback visual
* Está ensinando outros
* Experimentos rápidos
* Exploração de dados

## Casos de Uso Comuns

### Serviço Web

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

app = Flask(__name__)
model = load_model("./trained_model")

@app.route("/api/classify", methods=["POST"])
def classify():
    text = request.json["text"]
    result = model.predict(text)
    return {"label": result}
```

### Pipeline de Dados

```python theme={null}
def training_pipeline(df):
    # Limpeza personalizada
    df = remove_outliers(df)
    df = normalize_features(df)

    # Treinamento condicional
    if df.shape[0] > 10000:
        model = "large-model"
    else:
        model = "small-model"

    # Treinar
    trainer = AutoTrainer(model=model)
    trainer.train(df)

    return trainer
```

### Teste A/B

```python theme={null}
models = {}

# Treinar variantes
for config in experiments:
    trainer = create_trainer(config)
    trainer.train(data)
    models[config.name] = trainer

# Comparar
results = evaluate_all(models, test_data)
best = select_best(results)
```

### Callbacks Personalizados

```python theme={null}
class CustomCallback:
    def on_epoch_end(self, epoch, logs):
        if logs["loss"] < self.threshold:
            send_notification("Training going well!")

        if should_adjust_lr(logs):
            self.trainer.learning_rate *= 0.5

trainer.train(data, callbacks=[CustomCallback()])
```

## Dicas para Usuários de API

1. **Lide com exceções** - Treinamento pode falhar
2. **Adicione logging** - Rastreie o que acontece
3. **Use type hints** - Capture erros cedo
4. **Escreva testes** - Garanta confiabilidade
5. **Documente código** - Outros usarão

## Recursos Exclusivos da API

Coisas que apenas a API pode fazer:

* Callbacks personalizados durante treinamento
* Seleção dinâmica de modelo
* Pipelines de dados complexos
* Incorporado em aplicações
* Ajuste programático de hyperparâmetros

## Padrões Essenciais

```python theme={null}
# Gerenciador de contexto para recursos
with AITraining() as trainer:
    trainer.train(data)
    # Limpeza automática

# Treinamento assíncrono
async def train_async():
    await trainer.train_async(data)

# Previsões em streaming
for prediction in trainer.predict_stream(texts):
    process(prediction)

# Composição de modelo
ensemble = Ensemble([
    model1,
    model2,
    model3
])
```

## Exemplos de Integração

```python theme={null}
# Com pandas
df = pd.read_csv("data.csv")
trainer.train(df)

# Com scikit-learn
from sklearn.model_selection import train_test_split
X_train, X_test = train_test_split(data)

# Com weights & biases
import wandb
wandb.init(project="my-training")
trainer.train(data, callbacks=[WandbCallback()])

# Com FastAPI
@app.post("/train")
async def train_endpoint(data: TrainingData):
    result = await trainer.train_async(data)
    return {"model_id": result.id}
```

## Próximos Passos

<CardGroup cols={2}>
  <Card title="Referência da API" href="/api/launching-interface">
    Documentação completa da API
  </Card>

  <Card title="Alternativa CLI" href="/foundations/cli-when-to-use">
    Quando comandos são mais simples
  </Card>
</CardGroup>