Migrando de API en la nube a IA en el dispositivo: la guia completa

Tienes una app movil con funciones de IA impulsadas por una API en la nube. Funciona, pero los costos estan creciendo, la latencia es notable y quieres soporte offline. Esta guia recorre la migracion completa de API en la nube a inferencia en el dispositivo.

La migracion no es una reescritura. Es una transicion gradual donde la IA en el dispositivo reemplaza la API en la nube para funciones especificas, validada en cada paso.

Fase 1: Evaluar (Semana 1)

Inventario de tus funciones de IA

Lista cada funcion que llama a una API de IA en la nube:

Priorizar por valor de migracion

Puntua cada funcion:

• Impacto en costo: Las funciones de alto volumen ahorran mas dinero
• Sensibilidad a latencia: Las funciones donde la velocidad importa mas se benefician mas de en-dispositivo
• Valor offline: Funciones que los usuarios necesitan sin conectividad
• Complejidad: Las tareas simples (clasificacion, generacion corta) migran mas facilmente

Comienza con la funcion de mayor valor y menor complejidad. Clasificacion y respuestas inteligentes son candidatos tipicos iniciales.

Establecer lineas base de calidad

Antes de migrar, mide el rendimiento de tu IA en la nube en cada funcion:

# Conjunto de evaluacion: 200-500 ejemplos con respuestas correctas verificadas por humanos
evaluation_set = load_evaluation_data("eval_set.jsonl")

for example in evaluation_set:
    cloud_response = call_cloud_api(example.input)
    cloud_score = evaluate(cloud_response, example.expected)
    log_baseline(example.id, cloud_score)

La linea base es lo que tu modelo en el dispositivo debe igualar o superar.

Fase 2: Preparar datos de entrenamiento (Semanas 1-3)

Extraer de logs de API

Tus logs existentes de llamadas a API son tu fuente principal de datos de entrenamiento:

1. Exporta logs de API (pares entrada/salida) de tu infraestructura de logging
2. Filtra por calidad (respuestas exitosas, salidas aceptadas por el usuario)
3. Anonimiza (elimina informacion personal)
4. Formatea en el formato estandar de entrenamiento de chat

# Extraer datos de entrenamiento de logs de API
training_examples = []
for log in api_logs:
    if log.status == "success" and log.user_feedback != "negative":
        training_examples.append({
            "messages": [
                {"role": "user", "content": log.user_input},
                {"role": "assistant", "content": log.model_output}
            ]
        })

Complementar con datos sinteticos

Si tus logs de API son insuficientes (menos de 500 ejemplos de calidad), complementa con datos sinteticos:

• Usa la API en la nube para generar variaciones de tus mejores ejemplos
• Crea ejemplos para casos extremos no bien representados en los logs
• Valida ejemplos sinteticos manualmente (muestrea 10-20%)

Tamanos de dataset objetivo

Fase 3: Fine-tuning (Semanas 3-4)

Seleccionar modelo base

Entrenar con LoRA

Sube tus datos de entrenamiento a una plataforma de fine-tuning. Configura parametros de LoRA:

• Rango: 16-32 (1B) o 32-64 (3B)
• Tasa de aprendizaje: 1e-4 a 2e-4
• Epocas: 3-5
• Division de evaluacion: 10%

Plataformas como Ertas manejan la infraestructura de entrenamiento: selecciona tu modelo base, sube datos, configura parametros, entrena en GPUs en la nube y exporta GGUF.

Evaluar contra la linea base

Ejecuta tu conjunto de evaluacion a traves del modelo fine-tuned:

for example in evaluation_set:
    on_device_response = run_local_model(example.input)
    on_device_score = evaluate(on_device_response, example.expected)
    compare_to_baseline(example.id, on_device_score)

Criterio de aprobacion: Precision en dispositivo dentro del 3% de la linea base en la nube en metricas primarias.

Iterar si es necesario

Si el modelo no cumple tu barra de calidad:

1. Agrega mas ejemplos de entrenamiento para categorias con fallos
2. Aumenta el rango LoRA para mas capacidad
3. Prueba un modelo base mas grande (1B a 3B)
4. Ajusta hiperparametros (menor tasa de aprendizaje, mas epocas)

Re-evalua despues de cada cambio. La mayoria de modelos alcanzan calidad de produccion en 2-3 iteraciones de entrenamiento.

Fase 4: Integrar (Semanas 4-5)

Agregar llama.cpp a tu proyecto

Sigue las guias de integracion especificas por plataforma:

• iOS: Swift Package o framework pre-compilado
• Android: Libreria llama.android o build NDK
• React Native: Paquete llama.rn

Construir la abstraccion del proveedor de IA

Crea una interfaz comun que tanto el proveedor nube como en dispositivo implementen:

protocol AiProvider {
    func generate(prompt: String, maxTokens: Int) async throws -> AiResponse
    var isAvailable: Bool { get }
}

class CloudProvider: AiProvider { /* implementacion existente */ }
class OnDeviceProvider: AiProvider { /* nueva implementacion con llama.cpp */ }

Implementar entrega del modelo

Elige bundle o descarga post-instalacion. Configura hosting CDN para el archivo GGUF. Implementa UI de progreso de descarga, verificacion SHA256 y gestion de almacenamiento.

Agregar logica de enrutamiento

Enruta solicitudes a nube o en dispositivo basado en disponibilidad del modelo y cohorte de prueba A/B:

func getProvider(for userId: String) -> AiProvider {
    let cohort = getCohort(userId)

    if cohort == .onDevice && onDeviceProvider.isAvailable {
        return onDeviceProvider
    }
    return cloudProvider
}

Fase 5: Prueba A/B (Semanas 5-7)

Despliegue gradual

• Semana 5: 10% en dispositivo (monitorear crashes, errores)
• Semana 6: Division 50/50 (recopilar metricas de comparacion)
• Semana 7: Analizar resultados

Metricas clave a observar

• Tasa de completacion de tarea (primaria)
• Engagement de funcion (retencion D7)
• Latencia (TTFT y total)
• Tasa de crashes
• Retroalimentacion del usuario (si tienes un mecanismo de feedback)

Criterios de decision

Migrar si la completacion de tarea esta dentro del 3% de la nube y sin aumento en crashes. Iterar si la calidad es menor pero cercana (brecha menor al 5%). Re-entrenar con mas datos. Mantener si la brecha de calidad es significativa (mayor al 5%). Investigar causas raiz.

Fase 6: Migrar (Semanas 7-8)

Despliegue completo

Escala a 100% en dispositivo en 1-2 semanas:

• 75% en dispositivo, 25% nube (1 semana)
• 100% en dispositivo (mantener nube como respaldo)

Mantener nube como respaldo

No elimines la integracion de API en la nube inmediatamente. Mantenla como respaldo para:

• Dispositivos que no pueden ejecutar el modelo (menos de 4GB RAM)
• Fallos de descarga del modelo
• Rollback de emergencia si se descubre un problema de calidad del modelo

Descomisionar nube (Gradualmente)

Despues de 30 dias al 100% en dispositivo con metricas estables:

• Reduce el nivel de API en la nube (baja tu compromiso de rate limit)
• Despues de 90 dias: evalua si mantener la nube como respaldo o eliminar completamente
• Rastrea el uso del respaldo nube. Si es menos del 1% de las solicitudes, es seguro eliminar.

Fase 7: Operar (Continuo)

Pipeline de actualizacion del modelo

Establece un ciclo regular de actualizacion:

1. Recolectar nuevos datos de entrenamiento de interacciones de usuarios
2. Re-entrenar mensual o trimestralmente
3. Evaluar contra la version anterior del modelo
4. Enviar via actualizaciones OTA del modelo
5. Monitorear metricas de calidad despues de cada actualizacion

Monitoreo

Rastrea metricas de salud de IA en el dispositivo:

• Latencia de inferencia (P50, P95)
• Tasa de exito de carga del modelo
• Calidad de generacion (via retroalimentacion/acciones del usuario)
• Uso de memoria y tasas de crash
• Tasa de exito de descarga del modelo

Seguimiento de costos

Documenta los ahorros de costo:

• Factura de API en la nube antes de la migracion
• Factura de API en la nube despues de la migracion (solo respaldo)
• Costos de CDN para distribucion del modelo
• Costos de fine-tuning (por ejecucion de re-entrenamiento)
• Ahorros netos por mes

Resumen de cronograma

Total: 8 semanas desde el inicio hasta migracion completa. Las actualizaciones posteriores del modelo (re-entrenar y desplegar) toman dias, no semanas.

El paso de fine-tuning es donde plataformas como Ertas ahorran mas tiempo. Sube tus datos de logs de API, selecciona tu modelo base, entrena, exporta GGUF. La plataforma maneja la infraestructura GPU, optimizacion de entrenamiento y conversion GGUF. Tu enfoque se mantiene en la calidad de datos y la integracion de la app.