Saltar al contenido principal

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.

​
Cuándo Usar la API de Python

La API te da control programático completo para construir aplicaciones personalizadas.

​
Mejor Para

  • Aplicaciones personalizadas - Construye tus propias herramientas
  • Flujos de trabajo complejos - Pipelines multi-paso
  • Configuración dinámica - Ajusta sobre la marcha
  • Integración - Conecta con código existente
  • Sistemas de producción - Despliega como servicios

​
Cómo Se Ve

Escribe código Python: 
from aitraining import TextClassification

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

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

​
Ejemplo de Flujo de Trabajo

import pandas as pd
from aitraining import AutoTrainer

# Preprocesamiento personalizado
data = pd.read_csv("raw_data.csv")
data = clean_and_prepare(data)

# Configuración dinámica
config = {
    "model": get_best_model(data),
    "batch_size": calculate_batch_size(),
    "epochs": 5 if len(data) > 1000 else 10
}

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

# Integra en aplicación
@app.route("/predict")
def predict():
    result = trainer.predict(request.json)
    return jsonify(result)

​
Ventajas

  • Control completo - Accede a todo
  • Lógica personalizada - Tu preprocesamiento
  • Integración - Funciona con cualquier biblioteca Python
  • Dinámico - Ajusta basándose en condiciones
  • Probable - Prueba unitaria de tu entrenamiento

​
Limitaciones

  • Más código - Escribes la orquestación
  • Complejidad - Maneja errores tú mismo
  • Solo Python - No agnóstico de lenguaje
  • Dependencias - Gestiona paquetes

​
Cuándo Cambiar

Usa CLI cuando:
  • Necesitas automatización simple
  • Quieres solución agnóstica de lenguaje
  • Prefieres configuración sobre código
  • Trabajas con herramientas no-Python
Usa UI cuando:
  • Necesitas feedback visual
  • Enseñando a otros
  • Experimentos rápidos
  • Exploración de datos

​
Casos de Uso Comunes

​
Servicio Web

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 Datos

def training_pipeline(df):
    # Limpieza personalizada
    df = remove_outliers(df)
    df = normalize_features(df)

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

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

    return trainer

​
Prueba A/B

models = {}

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

# Compara
results = evaluate_all(models, test_data)
best = select_best(results)

​
Callbacks Personalizados

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()])

​
Consejos para Usuarios de API

  1. Maneja excepciones - El entrenamiento puede fallar
  2. Agrega logging - Rastrea qué sucede
  3. Usa type hints - Detecta errores temprano
  4. Escribe tests - Asegura confiabilidad
  5. Documenta código - Otros lo usarán

​
Características Exclusivas de API

Cosas que solo la API puede hacer:
  • Callbacks personalizados durante entrenamiento
  • Selección dinámica de modelo
  • Pipelines de datos complejos
  • Integrado en aplicaciones
  • Ajuste programático de hyperparámetros

​
Patrones Esenciales

# Context manager para recursos
with AITraining() as trainer:
    trainer.train(data)
    # Limpieza automática

# Entrenamiento async
async def train_async():
    await trainer.train_async(data)

# Predicciones streaming
for prediction in trainer.predict_stream(texts):
    process(prediction)

# Composición de modelos
ensemble = Ensemble([
    model1,
    model2,
    model3
])

​
Ejemplos de Integración

# Con pandas
df = pd.read_csv("data.csv")
trainer.train(df)

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

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

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

​
Próximos Pasos

Referencia API

Documentación completa de API

Alternativa CLI

Cuándo los comandos son más simples