El fine-tuning suele ser la primera solución a la que se recurre cuando un modelo se equivoca, y a menudo la equivocada. Cuesta recopilación de datos, etiquetado, ejecuciones de entrenamiento y un modelo que a partir de entonces usted tiene que mantener. Muchos fallos desaparecen con un prompt más claro, con la recuperación del documento adecuado o con una comprobación en código de la salida. Este artículo trata de decidir en qué caso está usted y qué preparar si de verdad necesita un modelo personalizado.
¿Qué problema intenta resolver?
Ponga nombre al fallo antes de ponérselo a la solución. La mayoría de los fallos de los LLM encajan en unos pocos patrones, y cada uno tiene un primer paso más barato:
| Síntoma | Pruebe primero | El fine-tuning ayuda cuando |
|---|---|---|
| Datos incorrectos o desactualizados | Recuperación (RAG) sobre sus documentos | Rara vez; los datos que cambian necesitan recuperación de todos modos |
| Formato incorrecto, JSON roto | Salida estructurada, comprobación del esquema, un reintento | El formato es inusual y los ejemplos en el prompt no bastan |
| Etiquetas o categorías incoherentes | Definiciones claras y ejemplos few-shot | El conjunto de etiquetas es grande o sutil y los ejemplos no caben en el prompt |
| Tono o estilo incorrecto | Una guía de estilo en el prompt de sistema, con ejemplos | Un estilo de la casa debe mantenerse en miles de salidas |
| Términos del dominio mal oídos o mal escritos | Una lista de vocabulario en el prompt, corrección posterior en código | Los modelos de voz oyen mal una y otra vez los mismos nombres, códigos o números |
| Demasiado lento o caro a escala | Un modelo más pequeño, caché de prompts, prompts más cortos | Un modelo pequeño ajustado puede igualar a uno grande en una tarea acotada |
| Idioma o dialecto incorrecto | Instrucciones en el idioma correcto; consulte ingeniería de prompts en árabe | El modelo entiende, pero no escribe en el dialecto que usted necesita |
La propia guía de OpenAI describe el mismo orden: primero escribir evaluaciones, luego iterar sobre los prompts y hacer fine-tuning para algunos casos de uso. Dice que el proceso de ingeniería de prompts “may be all you need in order to get great results.” (Traducción: puede ser todo lo que necesita para obtener grandes resultados). Y enumera lo que el fine-tuning añade frente al prompting: más ejemplos de los que caben en un prompt, prompts más cortos que ahorran tokens, entrenar con datos que no quiere enviar en cada solicitud y hacer que un modelo más pequeño sea bueno en una tarea.
¿Cómo demostrar que el fallo es recurrente?
Con un conjunto de evaluación. Reúna de 100 a 200 entradas reales con salidas correctas conocidas, como en evaluar un LLM antes de cambiar. Puntúe su prompt actual. Luego etiquete cada fallo con una categoría corta: wrong_label, missing_field, dialect, hallucinated_fact, etc.
Un patrón es candidato al fine-tuning solo si se cumplen las tres condiciones:
- Es frecuente. Representa una parte significativa de los fallos, no uno o dos casos raros.
- Sobrevive a las soluciones baratas. Probó instrucciones más claras, ejemplos, recuperación y validación, y la categoría sigue ahí.
- Es coherente. Las personas coinciden en la respuesta correcta. Si dos de sus propios revisores etiquetan el mismo caso de forma distinta, un modelo entrenado con sus etiquetas aprenderá el desacuerdo.
Anote el resultado en una frase corta, como este ejemplo inventado: «En nuestro conjunto de soporte en árabe de 200 casos, el mejor prompt etiqueta mal el 18 % de los tickets de facturación como de entrega; los ejemplos few-shot lo reducen al 15 %». Esa frase es el encargo del fine-tuning y la cifra que hay que superar.
¿Qué cambios más sencillos debe probar primero?
Aplíquelos por orden de costo y vuelva a puntuar después de cada uno:
- Instrucciones. Defina cada etiqueta o campo. Diga qué hacer en caso de duda.
- Ejemplos. Añada de tres a diez ejemplos reales, incluidos los casos difíciles.
- Recuperación. Si las respuestas necesitan datos, recupere el fragmento relevante. Búsqueda RAG en árabe y contexto largo vs. RAG cubren las opciones.
- Restricciones. Use salida estructurada donde el modelo la admita y compruebe la salida en código. Vuelva a preguntar una vez con el error.
- Otro modelo. Puede que otro modelo base ya haga lo que necesita. El mismo conjunto de evaluación se lo dirá en una hora.
Cada paso cuesta horas, no semanas, y cada uno le deja una mejor referencia que un fine-tuning tendría que superar si aún lo necesita.
¿Qué datos necesita y tiene derecho a usarlos?
Antes de la calidad, compruebe los derechos. Los datos de entrenamiento suelen venir de conversaciones con clientes, documentos o grabaciones de llamadas. Necesita una base legal y, a menudo, un consentimiento o una cláusula contractual que cubra el entrenamiento. Revise su propio aviso de privacidad y sus contratos con clientes, y elimine los datos personales que no necesite. No dé por hecho que su proveedor de API los está recopilando por usted: la declaración de privacidad de BroadNet, por ejemplo, dice que no retiene el contenido de inferencia y que no usa los datos de inferencia para entrenar, ajustar ni evaluar modelos.
Después compruebe la calidad. Este script lee un archivo de entrenamiento y uno de evaluación en el formato JSONL de chat habitual (un {"messages": [...]} por línea, que termina con la respuesta del asistente) e informa de problemas que arruinan los fine-tunes en silencio: filas rotas, duplicados, la misma entrada con respuestas distintas, elementos de evaluación filtrados al entrenamiento, el equilibrio de etiquetas y posibles datos personales.
import json, re, sys
from collections import Counter
DIAC = re.compile(r"[ً-ٰٟـ]") # tashkeel, dagger alef, tatweel
PII = {"email": re.compile(r"[\w.+-]+@[\w-]+\.[\w.]+"),
"phone": re.compile(r"(?:\+|00)\d[\d\s-]{7,}\d")}
def norm(s: str) -> str:
s = DIAC.sub("", s.lower())
s = re.sub("[إأآٱ]", "ا", s).replace("ى", "ي")
return " ".join(s.split())
def load(path):
rows, errors = [], []
for i, line in enumerate(open(path, encoding="utf-8"), 1):
try:
ex = json.loads(line)
roles = [m["role"] for m in ex["messages"]]
if roles[-1] != "assistant" or "user" not in roles:
raise ValueError(f"roles {roles}")
rows.append(ex)
except (ValueError, KeyError, IndexError, TypeError) as e:
errors.append(f"line {i}: {e}")
return rows, errors
def key(ex): # the input side, normalised: what the model sees
return norm(" ".join(m["content"] for m in ex["messages"] if m["role"] != "assistant"))
def check(train_path, eval_path):
train, errs = load(train_path)
evals, eval_errs = load(eval_path)
keys = Counter(key(e) for e in train)
labels = Counter(e["messages"][-1]["content"].strip() for e in train)
leaked = {key(e) for e in evals} & set(keys)
pii = Counter(k for e in train for m in e["messages"] for k, rx in PII.items() if rx.search(m["content"]))
conflicts = Counter()
seen = {}
for e in train:
k, a = key(e), e["messages"][-1]["content"].strip()
if k in seen and seen[k] != a:
conflicts[k] += 1
seen.setdefault(k, a)
return {"train_examples": len(train), "parse_errors": errs + eval_errs,
"duplicate_inputs": sum(n - 1 for n in keys.values() if n > 1),
"same_input_different_answer": len(conflicts),
"eval_items_also_in_train": len(leaked),
"answer_distribution": labels.most_common(5),
"examples_with_possible_pii": dict(pii)}
if __name__ == "__main__":
print(json.dumps(check(sys.argv[1], sys.argv[2]), ensure_ascii=False, indent=1))
Lo ejecutamos con un archivo de juguete de siete líneas con tickets de soporte en árabe, inglés y español. Encontró una fila sin respuesta del asistente, dos entradas duplicadas (una solo difería por un diacrítico, que el normalizador elimina, como en normalización de texto árabe), una entrada etiquetada a la vez como billing y other, un elemento de evaluación que también aparecía en el entrenamiento y un número de teléfono. Cada uno de ellos habría hecho que el fine-tuning pareciera mejor o peor de lo que es.
La normalización importa en árabe. Sin ella, “متأخر” y “متأخِّر” cuentan como entradas distintas, y una copia casi idéntica de un elemento de prueba puede colarse en el entrenamiento.
¿Cómo evaluar un fine-tune de forma justa?
Use el mismo conjunto de prueba reservado que usó para la referencia y manténgalo fuera del entrenamiento. Luego compare:
- Con el mejor prompt, no con el primero. Un fine-tune que supera a un prompt débil no demuestra nada.
- Por categoría y por idioma. Una mejora global puede ocultar una caída en árabe mientras mejora el inglés. Informe de cada uno.
- En el comportamiento general. Añada de 20 a 50 solicitudes corrientes que el modelo ya resolvía bien. Un entrenamiento acotado puede degradar el comportamiento fuera de la tarea.
- En costo y latencia. A menudo un fine-tune se justifica porque un modelo más pequeño hace el trabajo. Mida también los tokens y el tiempo por solicitud.
Decida la regla de aprobación antes de ver las cifras, como en el artículo de evaluación: por ejemplo, «al menos 5 puntos mejor en las etiquetas de facturación, ninguna categoría peor en más de 2 puntos, y árabe e inglés aprueban ambos».
¿Qué cambia cuando no puede hacer fine-tuning de modelos alojados?
Menos API alojadas de las que cabría esperar ofrecen fine-tuning de autoservicio. La página de deprecations de OpenAI registra una actualización de su plataforma de fine-tuning de autoservicio: desde el 7 de mayo de 2026, las organizaciones que no habían ejecutado fine-tuning ya no pueden crear trabajos; desde el 2 de julio de 2026, tampoco pueden hacerlo las organizaciones que no habían ejecutado inferencia con un modelo ajustado en los últimos 60 días; y desde el 6 de enero de 2027 los clientes existentes activos ya no podrán crear nuevos trabajos de fine-tuning. Los modelos ajustados existentes siguen disponibles para inferencia hasta que se retiren sus modelos base.
La alternativa habitual es un modelo de pesos abiertos entrenado con un método eficiente en parámetros como LoRA. El artículo de LoRA (Hu et al.) informa que, frente a un fine-tuning completo de GPT-3 175B con Adam, LoRA puede reducir 10,000 veces el número de parámetros entrenables y 3 veces la memoria de GPU necesaria. Después necesita dónde servir el resultado: su propio hardware o un proveedor que aloje pesos personalizados. Modelos de pesos abiertos vs. cerrados trata ese equilibrio.
Dónde encaja BroadNet Inference
BroadRouter es el sitio web de BroadNet. La API de autoservicio de BroadNet Inference no tiene endpoint de fine-tuning: su referencia de la API documenta solo chat completions y transcripción de audio. La misma página dice: “private endpoints, our Arabic fine-tunes and other models on request are reached with a private ID issued with the endpoint.” (Traducción: a los endpoints privados, nuestros fine-tunes en árabe y otros modelos bajo solicitud se accede con un ID privado emitido junto con el endpoint). Las páginas de modelos de BroadNet presentan un fine-tune de BroadNet de Cohere Transcribe Arabic para números, fechas y nombres en audio con ruido, disponible bajo solicitud con un ID de modelo privado por cliente, y dicen que Gemma 4 VL 26B está disponible en un endpoint privado “including our Arabic fine-tunes” (Traducción: incluidos nuestros fine-tunes en árabe). Son consultas a través de la página de contacto, no algo que pueda comprar o entrenar usted mismo; planificar un endpoint privado explica qué enviar.
Para todo lo anterior a ese paso, los modelos públicos bastan para construir su conjunto de evaluación y su referencia: Qwen3.8 27B y GLM 5.3 documentan salida estructurada, Gemma 4 VL 26B funciona con el crédito inicial de $5 y BroadNet Transcribe Arabic procesa voz a $0.0042 por minuto. El contenido de inferencia no se retiene; los metadatos necesarios de cuenta, facturación y seguridad se conservan como se describe en la declaración de privacidad de BroadNet.
