Fine-tuning de LLMs para crear personalidades de IA: tutorial en Python (2026)

Le pides a ChatGPT que escriba "con tu voz" y suelta tres párrafos genéricos. Le pegas un prompt de 800 palabras con ejemplos y reglas, y a la cuarta respuesta se le ha olvidado la mitad. El problema no es que el modelo sea malo. Es que le estás pidiendo a la forma algo que se arregla en los pesos.

Eso es el fine-tuning: dejar de explicarle al modelo cómo hablar en cada prompt y enseñárselo de una vez, entrenándolo con ejemplos de tu estilo hasta que la voz le salga por defecto. Es la herramienta correcta para construir una personalidad de IA propia. Y en 2026 ya no necesitas un clúster ni un máster: cabe en una sola GPU. Vamos a montarlo sin humo.

Qué es el fine-tuning (y cuándo SÍ y cuándo NO)

Un modelo base como Llama o Qwen ya viene preentrenado con medio internet. El fine-tuning no parte de cero: coge ese modelo y lo sigue entrenando con tus ejemplos para inclinarlo hacia un comportamiento concreto. No es magia, es ajustar pesos.

La idea clave que casi nadie te dice claro: el fine-tuning es para la FORMA, no para los datos. Sirve para cambiar cómo suena, cómo estructura la salida y qué vocabulario usa. No sirve para meterle información que cambia cada semana —eso se filtra en una brecha de conocimiento que el fine-tuning no cubre bien.

Los modelos punteros de 2026 siguen fallando en tres cosas que el fine-tuning arregla de raíz:

• Esquema de salida exacto: que devuelva siempre el mismo JSON, el mismo formato, sin desviarse.
• Vocabulario de dominio estrecho: la jerga de tu sector, tus términos, tus convenciones.
• Voz de marca: ese tono concreto que con prompts se diluye respuesta a respuesta.

Justo el tercer punto es el corazón de crear una personalidad de IA. Una voz consistente no se sostiene a base de prompts cada vez más largos; se entrena una vez y se queda.

Cuándo SÍ merece la pena:

• Tienes una tarea estable con una salida predecible (un tono, un formato).
• Has probado prompting y RAG y el modelo se ha estancado.
• Tienes (o puedes reunir) 500+ ejemplos buenos y coherentes.

Cuándo NO:

• Necesitas que el modelo sepa hechos concretos y actualizados → eso es RAG.
• Tu caso cambia cada dos por tres → reentrenar cada semana no escala.
• Aún no has probado a fondo un buen prompt → empieza por ahí, es gratis y reversible.

El proceso de fine-tuning, de un vistazo

Antes del código, el mapa. Estos son los seis pasos que vas a recorrer siempre, independientemente de la herramienta:

Fíjate en que entrenar es solo un paso de seis, y ni siquiera el más importante. Los pasos 1 y 2 —los datos— deciden el 80% del resultado. Lo repetiremos hasta el aburrimiento.

Paso a paso con código (Python + Unsloth)

Vamos a usar Unsloth, que en 2026 es la vía más rápida para entrenar en una sola GPU: sus kernels optimizados reducen el uso de memoria hasta un 74% y aceleran el entrenamiento entre 2 y 5 veces frente a Hugging Face Transformers a pelo. Funciona en la GPU gratis de Google Colab. Si prefieres pipelines por config en YAML sin escribir Python, Axolotl hace lo mismo con un fichero de configuración; y por debajo, ambos se apoyan en el ecosistema de Hugging Face.

1. Instalar el entorno

pip install unsloth
pip install --no-deps trl peft accelerate bitsandbytes

2. Cargar el modelo base en 4 bits (QLoRA)

Cargamos un modelo base pequeño cuantizado a 4 bits para que quepa en poca VRAM, y le enchufamos los adaptadores LoRA.

from unsloth import FastLanguageModel

model, tokenizer = FastLanguageModel.from_pretrained(
  model_name = "unsloth/Meta-Llama-3.1-8B-Instruct",
  max_seq_length = 2048,
  load_in_4bit = True,   # QLoRA: cuantiza el base a 4 bits
)

model = FastLanguageModel.get_peft_model(
  model,
  r = 16,                # rango del adaptador LoRA (8-64 es lo normal)
  lora_alpha = 16,
  target_modules = ["q_proj", "k_proj", "v_proj", "o_proj",
                    "gate_proj", "up_proj", "down_proj"],
)

3. Entrenar

Con el dataset ya formateado (lo vemos en el siguiente apartado), el entrenamiento es estándar. Pocas épocas: con datos limpios, 1-3 pasadas bastan y sobreentrenar es un riesgo real.

from trl import SFTTrainer
from transformers import TrainingArguments

trainer = SFTTrainer(
  model = model,
  tokenizer = tokenizer,
  train_dataset = dataset,         # tu JSONL formateado
  dataset_text_field = "text",
  max_seq_length = 2048,
  args = TrainingArguments(
      per_device_train_batch_size = 2,
      gradient_accumulation_steps = 4,
      num_train_epochs = 2,
      learning_rate = 2e-4,
      output_dir = "outputs",
  ),
)

trainer.train()

4. Inferir y exportar

Pruebas la personalidad recién entrenada y, si convence, la exportas a GGUF para correrla en local con Ollama.

FastLanguageModel.for_inference(model)
inputs = tokenizer(["¿Qué opinas del hype de la IA?"], return_tensors="pt").to("cuda")
print(tokenizer.decode(model.generate(**inputs, max_new_tokens=128)[0]))

# Exportar para Ollama / llama.cpp
model.save_pretrained_gguf("mi-personalidad", tokenizer, quantization_method="q4_k_m")

Los datos: el dataset que define tu personalidad

Aquí está el verdadero trabajo. El formato estándar de 2026 para fine-tuning supervisado (SFT) es JSONL con un array messages estilo ChatML: cada línea es una conversación. Funciona directo en Unsloth, Axolotl y TRL sin conversiones raras.

{"messages": [
{"role": "system", "content": "Eres Blackdark: directo, práctico, anti-humo. Nada de relleno."},
{"role": "user", "content": "¿Merece la pena pagar ChatGPT Plus?"},
{"role": "assistant", "content": "Depende de cuánto lo uses de verdad. Si abres la app un par de veces por semana, no. Si lo usas a diario para trabajar, los 20 al mes se amortizan el primer día. Lo que no vale es pagarlo 'por si acaso'."}
]}

Las reglas que de verdad importan en el dataset:

• Coherencia de voz: cada respuesta assistant tiene que sonar como la personalidad que quieres. Un solo ejemplo fuera de tono ensucia el aprendizaje.
• El system fija el personaje: úsalo igual en todos los ejemplos. Es el ancla de la identidad.
• Calidad > cantidad: para tono y estilo, 500-2.000 ejemplos curados rinden más que 50.000 ruidosos. Por debajo de ~100 filas, ni lo intentes.
• Variedad de situaciones: cubre distintos tipos de pregunta para que la voz aguante fuera de los ejemplos vistos.

Coste y herramientas, sin sorpresas

La buena noticia: para un modelo de 7-8B con QLoRA, el cómputo es casi gratis. Cabe en unos 8 GB de VRAM, así que entrenas en la GPU gratuita de Colab o alquilas una GPU en la nube por unas pocas horas. El gasto real no está en entrenar, está en preparar el dataset: ahí se va el tiempo.

Las tres herramientas que dominan en 2026:

• Unsloth — la opción si vas en una sola GPU y te importa la velocidad. Kernels optimizados, menos memoria, más rápido. La que hemos usado aquí.
• Axolotl — pipelines definidos en un YAML. Eliges modelo, dataset, método e hiperparámetros en un fichero y lanzas con un comando, sin escribir Python. Ideal para procesos repetibles.
• Hugging Face (Transformers + PEFT + TRL) — la base sobre la que se apoyan las dos anteriores. Más control, más fricción.

Sobre el método: LoRA entrena solo un 0,1-1% de los parámetros con calidad cercana a reentrenar todo el modelo. QLoRA añade cuantización a 4 bits y consigue en torno al 90% de la calidad del fine-tuning completo, a un coste de hardware mucho menor. Para crear una personalidad en casa, QLoRA es el punto dulce.

Errores típicos que arruinan el resultado

• Querer meter datos con fine-tuning. El error nº1. Si necesitas que el modelo sepa hechos actualizados, eso es RAG, no fine-tuning. Mezclar los dos conceptos lleva a modelos que alucinan con seguridad.
• Dataset sucio o incoherente. Ejemplos fuera de tono, formatos inconsistentes, respuestas mediocres. El modelo aprende exactamente lo que le das, defectos incluidos.
• Sobreentrenar. Demasiadas épocas y el modelo memoriza el dataset en vez de generalizar tu voz. Empieza con 1-3 pasadas y mide.
• No evaluar con casos nuevos. Si solo pruebas con ejemplos que estaban en el entrenamiento, te engañas. Evalúa con preguntas que el modelo no ha visto.
• Saltarte prompting y RAG. Si no has agotado lo barato y reversible, estás resolviendo con fine-tuning algo que un buen prompt arreglaba en cinco minutos.

¿Para quién es el fine-tuning?

No es para todo el mundo, y está bien que así sea.

Te interesa si: construyes un producto o agente con una personalidad de marca propia y necesitas que la voz sea idéntica en cada respuesta; tienes un formato de salida que el modelo base no respeta a la primera; trabajas en un dominio con jerga propia; o quieres reducir el coste por petición frente a prompts enormes que repites mil veces al día.

No te interesa si: tu problema es de conocimiento y no de forma (ahí manda RAG); aún no has exprimido un buen prompt de sistema; o tu caso es tan puntual que montar el pipeline cuesta más que el beneficio.

La pregunta honesta no es "¿hago fine-tuning?", sino "¿lo que me falla es la forma o los datos?". Si es la forma —el tono, la voz, el formato—, el fine-tuning es la herramienta correcta y, con QLoRA y un dataset limpio, está al alcance de una sola GPU. Si son los datos, ahórrate el entrenamiento y monta un RAG. Y si todavía no lo sabes, vuelve al prompt: casi siempre la respuesta estaba ahí.