Fine-Tuning para Desarrolladores de Apps: Una Guia Sin Necesidad de Ser Ingeniero ML

Construyes grandes apps. Sabes Swift, Kotlin o React Native. Puedes enviar una interfaz pulida, conectar una API REST y depurar una condicion de carrera a las 11pm. Ahora quieres agregar una funcion de AI: algo genuinamente util, no un wrapper delgado sobre GPT-4.

El problema: cada tutorial de fine-tuning asume que sabes lo que es un "gradiente." Abren con importaciones de PyTorch. Referencian "attention heads" como si fuera conocimiento comun. Cierras la pestana.

Esta guia es diferente. Explica el fine-tuning de la forma en que un desarrollador de apps realmente necesita entenderlo: enfocado en el pipeline, las decisiones practicas y lo que cuestan las cosas. No necesitaras entender backpropagation. Necesitaras entender JSON.

Que Es Realmente el Fine-Tuning

La forma mas facil de entender el fine-tuning es pensar en como funciona el autocompletado en tu telefono.

El autocompletado de tu teclado comenzo como un modelo general entrenado en miles de millones de palabras. Con el tiempo, se adapto a ti. Aprendio que escribes "lgtm" al final de revisiones de codigo, que siempre sigues "Hey" con "asi que", y que escribes mal "necesario" de una forma especifica. Esa adaptacion ocurrio porque el modelo vio tus patrones y se ajusto.

El fine-tuning de un modelo de AI es la misma idea, aplicada deliberadamente. Tomas un modelo de proposito general (algo como Llama 3.2, que puede escribir ensayos, responder preguntas y generar codigo) y le muestras cientos de ejemplos de exactamente como quieres que se comporte en tu app. Despues del entrenamiento, responde de esa forma especifica, confiablemente, cada vez.

El resultado es un modelo que hace tu tarea mejor de lo que cualquier cantidad de prompting podria lograr, corre en el dispositivo sin llamadas API, y no te cuesta nada por inferencia.

LoRA: Por Que No Reentrenar Todo el Modelo

Antes de que el fine-tuning se volviera practico para equipos sin experiencia en ML, la unica opcion era el fine-tuning completo: actualizar cada parametro individual en el modelo. Para un modelo de 7 mil millones de parametros, eso significa actualizar 7 mil millones de numeros. El costo computacional era enorme. Una ejecucion de fine-tuning completo requeria hardware costoso y dias de tiempo de entrenamiento. Solo los laboratorios grandes podian pagarlo.

En 2022, investigadores publicaron LoRA (Low-Rank Adaptation, arXiv:2106.09685) en ICLR. El insight clave: no necesitas actualizar todos los parametros para cambiar como se comporta un modelo. Puedes congelar los pesos originales del modelo completamente y agregar un conjunto pequeno de capas nuevas y entrenables encima. Estas nuevas capas se llaman un adaptador LoRA.

Aqui esta el resultado practico:

LoRA entrena solo el 0.1-1% de los parametros que el fine-tuning completo actualizaria
El entrenamiento es dramaticamente mas rapido y barato
El archivo del adaptador es pequeno: tipicamente 50-200MB para un modelo de 7B
El modelo base original queda intacto y reutilizable

Piensa en ello como un plugin para el modelo. El modelo base es la app. Tu adaptador LoRA es la extension que hace que se comporte exactamente como tu caso de uso requiere.

En 2023, QLoRA (arXiv:2305.14314, NeurIPS 2023) llevo esto mas lejos. QLoRA combina LoRA con cuantizacion de 4 bits, que comprime los numeros del modelo para ocupar menos memoria durante el entrenamiento. El resultado: puedes hacer fine-tuning de un modelo de 7 mil millones de parametros en una GPU de consumidor con 6-10GB de VRAM, o en una instancia en la nube que cuesta $3-$10 por ejecucion. Eso esta dentro del presupuesto de un desarrollador de apps individual.

El Pipeline de 4 Pasos

Hacer fine-tuning de un modelo para tu app sigue cuatro pasos. El resto de esta guia recorre cada uno.

Prepara tus datos de entrenamiento como un archivo JSONL
Haz fine-tuning en una GPU en la nube usando LoRA o QLoRA
Exporta a GGUF con cuantizacion para moviles
Integra en tu app iOS o Android usando bindings de llama.cpp

Eso es todo. No se requiere teoria de ML en ningun paso.

Paso 1: Preparar Tus Datos de Entrenamiento

Tus datos de entrenamiento son la parte mas importante del pipeline. Un dataset pequeno y de alta calidad supera a uno grande y desordenado siempre. El proyecto Alpaca de Stanford lo demostro en 2023 (arXiv:2303.16199): 52,000 ejemplos sinteticos y aproximadamente $500 en computo fueron suficientes para hacer que Llama 7B igualara a GPT-3.5 en una amplia gama de tareas. La calidad y el formato importan mas que el volumen.

Cuantos Ejemplos Necesitas?

La propia guia de OpenAI recomienda comenzar con 50-100 ejemplos al hacer fine-tuning de sus modelos. Para modelos open-source con LoRA, 100-500 ejemplos es un rango inicial practico para una tarea enfocada. Mas datos ayudan, pero los retornos decrecientes aparecen rapidamente una vez que el modelo ha visto suficiente variacion para generalizar.

Para tu primera ejecucion de fine-tuning, apunta a 100-300 ejemplos. Siempre puedes agregar mas despues.

El Formato

Los ejemplos de entrenamiento se almacenan en un archivo JSONL (JSON Lines), donde cada linea es un objeto JSON separado. El formato estandar usa mensajes estilo chat:

{"messages": [{"role": "system", "content": "Eres un asistente de cocina que sugiere recetas basadas en ingredientes disponibles."}, {"role": "user", "content": "Tengo pollo, ajo, limon y romero."}, {"role": "assistant", "content": "Aqui tienes dos recetas que puedes hacer ahora mismo:\n\n1. Pollo Asado al Limon con Ajo..."}]}
{"messages": [{"role": "system", "content": "Eres un asistente de cocina que sugiere recetas basadas en ingredientes disponibles."}, {"role": "user", "content": "Tengo huevos, espinaca y queso feta."}, {"role": "assistant", "content": "Tres opciones rapidas:\n\n1. Huevos Revueltos a la Griega..."}]}

Cada linea es un ejemplo de entrenamiento. El mensaje system define el rol del modelo. El mensaje user es la entrada. El mensaje assistant es la salida ideal que quieres que el modelo aprenda.

Consejos para Datos de Entrenamiento de Alta Calidad

Coincide con tus entradas reales. Si los usuarios en tu app envian mensajes cortos y casuales, tus entradas de entrenamiento deben parecer mensajes cortos y casuales. Si envian consultas estructuradas, entrena con consultas estructuradas.

Se consistente en tus salidas. Si algunas respuestas del asistente son dos oraciones y otras son diez parrafos, el modelo no aprendera un patron confiable. Elige un formato y mantente en el.

Cubre los casos limite. Incluye ejemplos donde el usuario pregunta algo fuera del alcance del modelo. Muestra al modelo como responder graciosamente a solicitudes fuera de tema, no solo al camino feliz.

Varia la redaccion. Diez ejemplos que hacen la misma pregunta con redaccion ligeramente diferente ensenan al modelo menos que diez ejemplos que cada uno cubre un escenario diferente.

Guarda tu archivo como training_data.jsonl. Eso es todo lo que necesitas para el siguiente paso.

Paso 2: Fine-Tuning en una GPU en la Nube

No necesitas poseer ningun hardware GPU. Los proveedores de GPU en la nube rentan computo por hora o por ejecucion.

Que Sucede Durante el Fine-Tuning

Subes tu archivo JSONL y eliges un modelo base. El proceso de entrenamiento ejecuta tus ejemplos a traves del modelo repetidamente, midiendo que tan lejos estan las salidas del modelo de tus salidas ideales, y ajustando los pesos del adaptador LoRA para reducir esa brecha. Este proceso se llama una epoca de entrenamiento.

Para 100-300 ejemplos con LoRA, espera:

Tiempo de entrenamiento: 10-30 minutos en una sola GPU
Costo con LoRA (12-16GB VRAM): $5-$15 por ejecucion
Costo con QLoRA (6-10GB VRAM): $3-$10 por ejecucion

Ejecutaras el entrenamiento algunas veces mientras refinas tu dataset. El costo total de fine-tuning para una nueva funcion es tipicamente $20-$50 antes de tener un modelo con el que estes satisfecho.

Elegir un Modelo Base para Moviles

Para despliegue en el dispositivo en iOS y Android, el tamano del modelo es la restriccion principal. El punto optimo practico:

Llama 3.2 1B Q4_K_M: 808MB en disco, corre a aproximadamente 22 tokens por segundo en un iPhone 16 Pro, menos de 100MB de sobrecarga de RAM
Llama 3.2 3B Q4_K_M: 2.02GB en disco, significativamente mas capaz, aun cabe en la mayoria de los dispositivos modernos

Para la mayoria de las funciones de app (clasificacion, generacion de formato corto, preguntas y respuestas, resumen), el modelo de 1B despues del fine-tuning en tu tarea especifica superara a un modelo de 3B de proposito general en esa misma tarea. La especializacion a traves del fine-tuning es mas efectiva que la cantidad bruta de parametros para tareas estrechas.

La API Foundation Models de Apple (anunciada en WWDC 2025) da a las apps de terceros acceso a un modelo en el dispositivo de aproximadamente 3B parametros sin necesidad de descarga. Si tu caso de uso encaja dentro de lo que el modelo de Apple soporta, vale la pena explorarlo. Para casos donde necesitas comportamiento personalizado o formato de salida, hacer fine-tuning de tu propio modelo te da un control que una API de plataforma no puede.

Que Observar Durante el Entrenamiento

No necesitas entender profundamente las metricas de entrenamiento, pero dos numeros importan:

La perdida de entrenamiento deberia disminuir con el tiempo. Si se mantiene plana, tus datos pueden tener problemas de calidad.

La perdida de validacion se mide en una pequena porcion reservada de tus datos. Si la perdida de entrenamiento disminuye pero la perdida de validacion aumenta, el modelo esta memorizando tus ejemplos de entrenamiento en lugar de aprender a generalizar. Esto se llama sobreajuste. La solucion es agregar mas ejemplos diversos o reducir el numero de epocas de entrenamiento.

Paso 3: Exportar a GGUF con Cuantizacion

Despues del fine-tuning, tienes un adaptador LoRA. Antes de poder enviarlo en una app movil, necesitas:

Fusionar el adaptador en el modelo base
Cuantizar el modelo fusionado para reducir su tamano
Exportar como archivo GGUF

GGUF (GPT-Generated Unified Format) es el formato de archivo usado por llama.cpp, la biblioteca de inferencia que impulsa la AI en el dispositivo en iOS y Android. Es un solo archivo que contiene todo lo necesario para ejecutar el modelo.

La cuantizacion reduce la precision de los numeros del modelo. En lugar de almacenar cada numero como un float de 32 bits, la cuantizacion los almacena como enteros de 4 bits. Esto reduce el tamano del archivo aproximadamente un 75% y acelera la inferencia, con un pequeno compromiso de calidad.

Entendiendo Q4_K_M

Cuando ves un modelo listado como Q4_K_M, cada parte significa algo:

Q4: cuantizacion de 4 bits (vs 8 bits Q8 o precision completa F16)
K: usa un algoritmo de cuantizacion llamado K-quant que es mas preciso que metodos mas simples
M: variante media (equilibrada entre tamano y calidad; tambien existe S para pequena y L para grande)

Para despliegue movil, Q4_K_M es el nivel de cuantizacion recomendado. Equilibra bien tamano, velocidad y calidad para hardware de consumidor.

Los tamanos de archivo resultantes despues de la cuantizacion con Q4_K_M:

Llama 3.2 1B: 808MB
Llama 3.2 3B: 2.02GB

Ambos caben en una descarga de app, aunque el modelo de 3B puede preferir descargarse despues del primer lanzamiento en lugar de incluirse en la instalacion inicial.

Paso 4: Integrar en iOS y Android

Tienes un archivo .gguf. Ahora necesitas ejecutarlo dentro de tu app.

iOS (Swift)

El proyecto llama.cpp proporciona bindings de Swift via el paquete SPM llama.cpp. Agregalo a tu Package.swift:

.package(url: "https://github.com/ggerganov/llama.cpp", from: "b3000.0.0")

Incluye tu archivo GGUF en los recursos de tu app o descargalo en el primer lanzamiento al directorio Documents de la app. Luego carga y ejecuta el modelo:

import llama

let modelPath = Bundle.main.path(forResource: "my-model.Q4_K_M", ofType: "gguf")!
let params = LlamaContextParams.default
let context = try LlamaContext(modelPath: modelPath, params: params)

let response = try await context.complete(prompt: "Resumir: \(userInput)")

En iPhone 16 Pro, un modelo de 1.5B corre a aproximadamente 22 tokens por segundo via la ruta de CPU. iPhone 17 Pro, con su NPU mejorado (operaciones INT8), marca aproximadamente 136 tokens por segundo. Para la mayoria de las funciones de app, 22 tok/s es suficientemente rapido para respuestas en streaming que se sienten naturales.

Android (Kotlin/NDK)

En Android, llama.cpp se integra via JNI (Java Native Interface) o el NDK. La API de Inferencia LLM de MediaPipe de Google proporciona una abstraccion de nivel mas alto que envuelve llama.cpp y es mas facil de integrar para desarrolladores Android que no quieren gestionar JNI directamente:

val options = LlmInference.LlmInferenceOptions.builder()
    .setModelPath("/data/local/tmp/my-model.Q4_K_M.gguf")
    .setMaxTokens(512)
    .build()

val llmInference = LlmInference.createFromOptions(context, options)
val result = llmInference.generateResponse(userPrompt)

MediaPipe maneja la aceleracion GPU automaticamente en GPUs Qualcomm y Mali cuando estan disponibles.

React Native

Para apps React Native, la biblioteca llama.rn proporciona un wrapper multiplataforma alrededor de llama.cpp para iOS y Android:

npm install llama.rn

import { initLlama } from 'llama.rn';

const context = await initLlama({
  model: require('./assets/my-model.Q4_K_M.gguf'),
  n_ctx: 2048,
});

const result = await context.completion({
  prompt: userInput,
  n_predict: 256,
});

El modelo corre completamente en el dispositivo. Sin claves API, sin solicitudes de red, sin costo por inferencia.

Lo Que el Fine-Tuning Puede y No Puede Hacer

Esta es la seccion que te salvara de una ejecucion de fine-tuning desperdiciada. El fine-tuning es una herramienta poderosa, pero resuelve un conjunto especifico de problemas.

El Fine-Tuning Es Excelente Para

Aprender un formato. Si necesitas que el modelo siempre responda en JSON, siempre siga una estructura especifica, o siempre aplique un estilo consistente, el fine-tuning es la herramienta correcta. Unos cientos de ejemplos del formato objetivo y el modelo lo seguira confiablemente.

Lenguaje especifico del dominio. Si tu app esta en un dominio especializado (medico, legal, una industria particular), el fine-tuning ensena al modelo la terminologia y convenciones de ese dominio.

Tono y personalidad. Si quieres que tu funcion de AI responda en una voz especifica que coincida con la marca de tu app, el fine-tuning es mas confiable que system prompts extensos.

Especializacion de tareas. Clasificar tickets de soporte, extraer datos estructurados de la entrada del usuario, generar contenido de formato corto en un estilo especifico. Cualquier tarea estrecha y bien definida se beneficia del fine-tuning.

El Fine-Tuning No Puede Agregar Nuevos Hechos

Este es el malentendido mas comun. El fine-tuning no le ensena al modelo nueva informacion sobre el mundo. Le ensena al modelo como comportarse, no que saber.

Si quieres que el modelo responda preguntas sobre tu catalogo de productos, tu pagina de precios o tu documentacion, el fine-tuning es la herramienta equivocada. Hacer fine-tuning con tus docs no hara que el modelo recuerde de forma confiable hechos especificos de esos docs. Solo aprendera el formato y estilo de tus docs.

Para recordar hechos de informacion especifica y cambiante, usa RAG (Retrieval-Augmented Generation) en su lugar. RAG permite que el modelo busque en una base de datos de documentos en tiempo de inferencia y use el texto recuperado como contexto. El fine-tuning y RAG se complementan: fine-tuning para comportamiento y formato, RAG para hechos.

El Fine-Tuning No Puede Expandir la Capacidad de Razonamiento del Modelo

Un modelo de 1B ajustado en tu tarea se desempenara mejor en tu tarea que un modelo de 3B de proposito general. Pero no puede realizar razonamiento complejo de multiples pasos, generar documentos largos coherentes, o resolver problemas que requieren el tipo de capacidad que solo viene de mas parametros. Conoce donde esta el techo de tu modelo y disena tu funcion dentro de el.

Uniendo Todo

Aqui esta el pipeline completo como checklist:

Escribe 100-300 ejemplos de entrenamiento en formato chat JSONL
Revisa la consistencia: formato coincidente, entradas variadas, casos limite cubiertos
Sube a una plataforma de fine-tuning o servicio de GPU en la nube
Entrena con LoRA en modelo base Llama 3.2 1B o 3B
Verifica la perdida de entrenamiento y validacion; re-ejecuta con ajustes si es necesario
Fusiona el adaptador y exporta como model.Q4_K_M.gguf
Agrega el paquete Swift de llama.cpp (iOS), MediaPipe o llama.rn (Android/React Native)
Incluye o descarga el GGUF en el primer lanzamiento
Prueba en hardware de dispositivo real al throughput de tokens objetivo

La cadena de herramientas ha madurado al punto donde un desarrollador de React Native sin experiencia en ML puede completar este pipeline en un fin de semana. La parte dificil no es el entrenamiento ni la integracion. Es recopilar y limpiar un buen dataset.

Comienza con tus datos de entrenamiento. Todo lo demas sigue de ahi.