De logs de API a datos de entrenamiento: usa tu historial de IA en la nube para fine-tuning

Si actualmente usas una API de IA en la nube (OpenAI, Anthropic, Google Gemini), ya estas generando datos de entrenamiento. Cada llamada a la API que haces contiene una entrada (la solicitud del usuario) y una salida (la respuesta del modelo). Eso es un ejemplo de entrenamiento.

Tus logs de API son el camino mas rapido de IA en la nube a IA en el dispositivo. No necesitas crear un dataset desde cero. Ya tienes uno.

Que contienen los logs de API

Una entrada tipica de log de llamada a API:

{
  "timestamp": "2026-03-15T14:22:03Z",
  "model": "gpt-4o-mini",
  "messages": [
    {
      "role": "system",
      "content": "You are the shopping assistant for StyleApp..."
    },
    {
      "role": "user",
      "content": "Find me a blue dress for a summer wedding"
    },
    {
      "role": "assistant",
      "content": "Here are some suggestions for a summer wedding...\n\n1. Floral midi dress in navy blue...\n2. Light blue chiffon maxi dress..."
    }
  ],
  "tokens_used": {"input": 1842, "output": 387},
  "latency_ms": 1203
}

Esta entrada de log ya esta en el formato exacto necesario para fine-tuning. El array messages es una conversacion de entrenamiento.

Pipeline de extraccion

Paso 1: Exporta tus logs

Donde viven tus logs depende de tu arquitectura:

Si registras las llamadas a API tu mismo: Exporta desde tu base de datos (PostgreSQL, MongoDB, etc.) o servicio de agregacion de logs (Datadog, CloudWatch, etc.).

Si usas la API de OpenAI: La API no almacena logs por defecto. Necesitas tu propio middleware de logging. Si no tienes uno, configuralo ahora. Cada futura llamada a API es un ejemplo de entrenamiento potencial.

# Ejemplo simple de middleware de logging
import json
import datetime

def log_api_call(request_messages, response_content, model, tokens):
    log_entry = {
        "timestamp": datetime.datetime.utcnow().isoformat(),
        "model": model,
        "messages": request_messages + [
            {"role": "assistant", "content": response_content}
        ],
        "tokens_used": tokens,
    }
    with open("api_logs.jsonl", "a") as f:
        f.write(json.dumps(log_entry) + "\n")

Paso 2: Filtra por calidad

No toda respuesta de API es buenos datos de entrenamiento. Filtra:

Respuestas fallidas: Errores de timeout, salida malformada, rechazos.

Salidas de baja calidad: Respuestas donde el usuario inmediatamente reintento (indicando insatisfaccion), o donde la salida fue truncada.

Valores atipicos: Respuestas inusualmente largas o cortas que no representan comportamiento tipico.

Interacciones fuera de tarea: Si los usuarios ocasionalmente hacen preguntas fuera de tema, excluyelas a menos que quieras que el modelo las maneje.

def is_quality_example(log_entry):
    messages = log_entry["messages"]
    assistant_msg = next(
        (m for m in reversed(messages) if m["role"] == "assistant"), None
    )
    if not assistant_msg:
        return False

    content = assistant_msg["content"]

    # Filtrar respuestas demasiado cortas
    if len(content) < 50:
        return False

    # Filtrar respuestas de error
    if "I apologize" in content and "I cannot" in content:
        return False

    # Filtrar respuestas truncadas
    if log_entry.get("finish_reason") == "length":
        return False

    return True

Paso 3: Elimina el system prompt (Opcional)

Si estas haciendo fine-tuning, el modelo aprende el comportamiento de los ejemplos de entrenamiento. Puede que no necesites el system prompt en los datos de entrenamiento porque el modelo fine-tuned internalizara las instrucciones.

Dos enfoques:

Mantener el system prompt: El modelo aprende a seguir estas instrucciones especificas. Bueno si tu system prompt es corto y estable.

Eliminar el system prompt: El modelo aprende el patron de comportamiento sin instrucciones explicitas. Bueno si tu system prompt es largo (ahorra tokens en entrenamiento) o si quieres que el comportamiento sea intrinseco en lugar de dependiente de instrucciones.

Paso 4: Anonimiza

Elimina informacion personal de los datos de entrenamiento:

import re

def anonymize_message(content):
    # Correos
    content = re.sub(r'\b[\w.-]+@[\w.-]+\.\w+\b', '[EMAIL]', content)
    # Numeros de telefono
    content = re.sub(r'\b\d{3}[-.]?\d{3}[-.]?\d{4}\b', '[PHONE]', content)
    # Numeros de tarjeta de credito
    content = re.sub(r'\b\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b', '[CARD]', content)
    # Direcciones (patron basico)
    content = re.sub(r'\d+\s+[\w\s]+(?:Street|St|Avenue|Ave|Road|Rd|Drive|Dr)\b', '[ADDRESS]', content)
    return content

def anonymize_log(log_entry):
    for msg in log_entry["messages"]:
        msg["content"] = anonymize_message(msg["content"])
    return log_entry

Paso 5: Formatea para entrenamiento

Convierte tus logs filtrados y anonimizados al formato estandar de fine-tuning:

def log_to_training_example(log_entry):
    messages = []
    for msg in log_entry["messages"]:
        if msg["role"] in ("system", "user", "assistant"):
            messages.append({
                "role": msg["role"],
                "content": msg["content"]
            })
    return {"messages": messages}

# Procesar todos los logs
training_data = []
for log_entry in load_logs("api_logs.jsonl"):
    if is_quality_example(log_entry):
        anonymized = anonymize_log(log_entry)
        example = log_to_training_example(anonymized)
        training_data.append(example)

# Escribir archivo de entrenamiento
with open("training_data.jsonl", "w") as f:
    for example in training_data:
        f.write(json.dumps(example) + "\n")

Cuantos logs necesitas?

Asume que 50-70% de las llamadas API crudas sobreviven el filtrado de calidad. A 500 llamadas por dia, acumulas 250-350 ejemplos de calidad diariamente.

Para la mayoria de tareas, 1,000 ejemplos de calidad son suficientes para un modelo fine-tuned de buen rendimiento. Puedes comenzar a entrenar en dias o semanas de configurar el logging.

La ventaja de la destilacion

Cuando haces fine-tuning de un modelo pequeno (1-3B) con salidas de un modelo mas grande (GPT-4o, Claude Sonnet), estas realizando destilacion de conocimiento. El modelo pequeno aprende a reproducir el comportamiento del modelo grande en tu tarea especifica.

El resultado: un modelo 3B fine-tuned que iguala el rendimiento del modelo grande en tus tareas de dominio mientras se ejecuta en el dispositivo. Esto no es teorico. La investigacion y despliegues en produccion consistentemente muestran que modelos pequenos fine-tuned igualan o superan a modelos grandes con prompts en tareas estrechas y especificas de dominio.

Tus logs de API son el dataset de destilacion. El modelo grande ya hizo el trabajo. Solo necesitas ensenarle a un modelo pequeno a replicarlo.

De logs a despliegue

El pipeline completo:

1. Configura logging de API (si no esta implementado)
2. Acumula 1,000+ ejemplos de calidad (dias a semanas)
3. Extrae, filtra, anonimiza y formatea los logs
4. Sube a una plataforma de fine-tuning como Ertas
5. Selecciona un modelo base (Llama 3.2 3B recomendado)
6. Fine-tunea con LoRA (30 min - 3 horas)
7. Exporta GGUF (cuantizacion Q4_K_M)
8. Integra llama.cpp en tu app movil
9. Prueba A/B el modelo en el dispositivo contra tu API en la nube
10. Migra cuando el modelo en el dispositivo cumpla tu barra de calidad

Tus logs de API no son solo un centro de costos. Son el puente hacia IA en el dispositivo.