Llama 3.2 para apps moviles: Fine-tuning y despliegue en el dispositivo

Llama 3.2 de Meta incluye modelos de 1B y 3B disenados especificamente para despliegue movil y edge. No son versiones reducidas de ultimo momento. Fueron construidos a proposito para inferencia en el dispositivo, destilados de los modelos Llama 3.1 mas grandes para retener capacidad mientras caben en presupuestos de memoria movil.

Esta guia cubre el pipeline completo: seleccionar el tamano correcto, fine-tuning con tus datos, exportacion a GGUF y despliegue en iOS y Android.

Por que Llama 3.2 para movil

Llama 3.2 1B y 3B tienen varias ventajas para despliegue movil:

Disenado para movil: A diferencia de modelos mas grandes que se comprimen, estos fueron entrenados desde el inicio con restricciones moviles en mente. La arquitectura esta optimizada para inferencia rapida en hardware limitado.

Fuerte capacidad base: Entrenado con 9 billones de tokens. El modelo 3B obtiene 63.4 en MMLU y 77.4 en IFEval (seguimiento de instrucciones), haciendolo competitivo con modelos 2-3x su tamano de hace solo un ano.

Mayor ecosistema: Llama tiene la comunidad mas grande de cualquier familia de modelos abiertos. Mas guias de fine-tuning, mas conversiones GGUF, mas soporte de herramientas y mas ejemplos de despliegue en produccion que cualquier alternativa.

Contexto de 128K: Tanto 1B como 3B soportan ventanas de contexto de 128K tokens. Para movil, rara vez usaras mas de 2-4K, pero el contexto largo esta ahi si se necesita.

Eligiendo 1B vs 3B

Elige 1B cuando: Tu tarea es clasificacion, etiquetado, autocompletado, sugerencias inteligentes o generacion de formato corto. Quieres maxima cobertura de dispositivos.

Elige 3B cuando: Tu tarea es chat conversacional, resumen, redaccion de contenido o seguimiento de instrucciones complejas. Tus usuarios tienen dispositivos mas nuevos.

Fine-tuning con LoRA

LoRA (Low-Rank Adaptation) es el metodo estandar de fine-tuning para modelos moviles. En lugar de modificar todos los pesos del modelo, LoRA entrena pequenas matrices adaptadoras que ajustan el comportamiento del modelo. El adaptador es de 50-200MB, fusionado en el modelo base antes de la exportacion GGUF.

Formato de datos de entrenamiento

Llama 3.2 usa una plantilla de chat especifica. Tus datos de entrenamiento deben seguir este formato:

{
  "messages": [
    {"role": "system", "content": "Eres un asistente de viajes para la app TripHelper."},
    {"role": "user", "content": "Cual es la mejor epoca para visitar Kioto?"},
    {"role": "assistant", "content": "Marzo-abril para los cerezos en flor o noviembre para el follaje de otono. Ambas son temporadas altas, asi que reserva con 2-3 meses de anticipacion."}
  ]
}

Requisitos de datos

Hiperparametros de LoRA

Configuracion estandar para fine-tuning movil de Llama 3.2:

Exportacion a GGUF

Despues del entrenamiento, el pipeline es:

1. Fusionar el adaptador LoRA en los pesos del modelo base
2. Convertir a formato GGUF
3. Cuantizar a Q4_K_M (o tu nivel objetivo)
4. Validar el modelo cuantizado en tu conjunto de evaluacion

El archivo GGUF es el artefacto final que envias a los dispositivos. Contiene el modelo completo en un solo archivo que llama.cpp puede cargar directamente.

Plataformas como Ertas manejan esto de principio a fin:

Sube datos de entrenamiento, selecciona Llama 3.2 1B o 3B como modelo base, configura parametros LoRA (o usa los predeterminados), entrena en GPUs en la nube y exporta directamente a GGUF. Sin herramientas de linea de comandos, sin configuracion de GPU, sin scripts de conversion.

Despliegue en iOS

Integracion con llama.cpp

Agrega llama.cpp a tu proyecto iOS via Swift Package Manager o como framework compilado. Carga el modelo GGUF y ejecuta inferencia:

import llama

let modelPath = Bundle.main.path(forResource: "model", ofType: "gguf")!
let params = llama_model_default_params()
let model = llama_load_model_from_file(modelPath, params)

// Configurar inferencia
var contextParams = llama_context_default_params()
contextParams.n_ctx = 2048
contextParams.n_threads = 4
let context = llama_new_context_with_model(model, contextParams)

Aceleracion GPU Metal

llama.cpp usa automaticamente Metal en iOS para inferencia acelerada por GPU. Configura n_gpu_layers al conteo total de capas del modelo para descargar toda la computacion a la GPU:

var modelParams = llama_model_default_params()
modelParams.n_gpu_layers = 32 // Descargar todas las capas a Metal

Esto proporciona una mejora de velocidad del 30-50% sobre inferencia solo CPU.

Despliegue en Android

Integracion con llama.android

Usa la libreria llama.android del proyecto llama.cpp. Proporciona bindings Kotlin a traves de JNI:

val model = LlamaModel()
model.load(modelPath, nThreads = 4, nGpuLayers = 32)

// Generar con streaming
model.generate(prompt) { token ->
    runOnUiThread { appendToUI(token) }
}

Aceleracion GPU Vulkan

En Android, llama.cpp soporta Vulkan para aceleracion GPU en Snapdragon, Tensor y otros chipsets. Habilita configurando nGpuLayers al conteo de capas del modelo.

Licenciamiento

Llama 3.2 usa el Llama Community License Agreement de Meta. Puntos clave:

• Uso comercial: Permitido
• Modificacion: Permitida (incluyendo fine-tuning)
• Distribucion: Permitida
• Umbral de 700M MAU: Si tu producto o servicio tiene mas de 700 millones de usuarios activos mensuales, necesitas una licencia especial de Meta
• Atribucion: Requerida

Para la gran mayoria de apps moviles, la licencia es completamente permisiva.

Linea de tiempo de principio a fin

El primer despliegue toma mas tiempo por la integracion de llama.cpp. Despues de eso, las actualizaciones de modelo (re-entrenamiento, re-exportacion GGUF) toman horas, no dias.