Cómo entrenar tu propia IA local paso a paso

Hay una diferencia enorme entre usar una IA y tener una IA entrenada con tus datos. La primera te da respuestas genéricas. La segunda habla tu idioma técnico, conoce tu dominio y responde exactamente como necesitas.

Hace dos años, entrenar un modelo de lenguaje requería un clúster de GPUs de US$50,000 y un equipo de ingenieros de ML. En 2026, una GPU de US$300, 500 ejemplos bien escritos y una tarde son suficientes para especializar un modelo de 8 mil millones de parámetros en tu dominio.

La técnica que lo hace posible se llama QLoRA (Quantized Low-Rank Adaptation). En lugar de modificar los 8 mil millones de parámetros del modelo, modificas solo el 0.5-1% — los suficientes para que el modelo aprenda tu estilo, tu terminología y tus patrones de respuesta.

Antes de empezar: ¿Entrenar, RAG o ambos?

Una confusión común es mezclar entrenamiento con RAG. Son cosas distintas:

Regla simple: si quieres que el modelo sepa algo, usa RAG. Si quieres que el modelo sea algo (un asistente legal, un experto en tu API, un generador de reportes con tu formato), entrénalo.

Requisitos de hardware

¿No tienes GPU? Puedes usar Google Colab (gratis con GPU T4) o servicios como RunPod y Vast.ai por ~US$0.50/hora con GPUs A100. Unsloth tiene notebooks listos para Colab.

Paso 1: Elegir el modelo base

No necesitas empezar de cero. Eliges un modelo pre-entrenado y lo especializas. Para 2026, los mejores modelos base para fine-tuning en hardware de consumo son:

Si es tu primera vez, ve con Llama 3.1 8B. Buen equilibrio entre calidad y requerimientos.

Paso 2: Preparar tu dataset

Esta es la parte más importante. La calidad de tus datos determina la calidad del modelo. Un dataset de 200 ejemplos bien escritos supera a uno de 2,000 ejemplos ruidosos.

El formato estándar en 2026 es ChatML en JSONL — un archivo donde cada línea es una conversación completa:

{"conversations": [{"role": "system", "content": "Eres un asistente experto en derecho laboral peruano."}, {"role": "user", "content": "¿Cuántos días de vacaciones corresponden por ley?"}, {"role": "assistant", "content": "Según el Decreto Legislativo 713, todo trabajador tiene derecho a 30 días calendario de descanso vacacional por cada año completo de servicios. Este derecho se genera después de cumplir un año de trabajo efectivo para el mismo empleador."}]}
{"conversations": [{"role": "system", "content": "Eres un asistente experto en derecho laboral peruano."}, {"role": "user", "content": "¿Se pueden fraccionar las vacaciones?"}, {"role": "assistant", "content": "Sí. Desde la modificación por el Decreto Legislativo 1405, las vacaciones pueden fraccionarse en periodos que no sean menores a 7 días calendario. El trabajador y el empleador deben acordar el fraccionamiento por escrito."}]}

Consejos para armar tu dataset:

• Escribe las respuestas como quieres que el modelo responda — tono, extensión, formato, nivel de detalle.
• Incluye variaciones de la misma pregunta formulada de distintas maneras.
• Agrega ejemplos de lo que el modelo NO debería hacer (ej: "No tengo información suficiente para responder eso con certeza").
• Apunta a 300-500 ejemplos para un buen fine-tune. Con 200 ya se notan resultados.
• Divide 90% para entrenamiento y 10% para validación.

Guarda tu archivo como dataset.jsonl.

Paso 3: Instalar Unsloth

Unsloth es la herramienta más rápida y eficiente para fine-tuning en 2026. Optimiza internamente el uso de memoria y acelera el entrenamiento hasta 2x comparado con el stack estándar de Hugging Face.

# Crear entorno virtual
python -m venv fine-tune-env
source fine-tune-env/bin/activate

# Instalar Unsloth (incluye transformers, peft, trl)
pip install unsloth
pip install datasets

Paso 4: Configurar y lanzar el entrenamiento

Este es el script completo. Copia, ajusta el nombre de tu dataset, y ejecuta:

from unsloth import FastLanguageModel
from trl import SFTTrainer
from transformers import TrainingArguments
from datasets import load_dataset

# === 1. CARGAR MODELO BASE EN 4-BIT ===
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Meta-Llama-3.1-8B-Instruct-bnb-4bit",
    max_seq_length=2048,
    load_in_4bit=True,
)

# === 2. CONFIGURAR LoRA ===
model = FastLanguageModel.get_peft_model(
    model,
    r=16,                  # Rank — 16 es buen punto de partida
    lora_alpha=32,         # Generalmente 2x el rank
    lora_dropout=0.05,
    target_modules=[       # Capas que vamos a entrenar
        "q_proj", "k_proj", "v_proj", "o_proj",
        "gate_proj", "up_proj", "down_proj",
    ],
)

# === 3. CARGAR DATASET ===
dataset = load_dataset("json", data_files="dataset.jsonl", split="train")

# Función para formatear al template de Llama 3
def format_chat(example):
    messages = example["conversations"]
    text = tokenizer.apply_chat_template(
        messages, tokenize=False, add_generation_prompt=False
    )
    return {"text": text}

dataset = dataset.map(format_chat)

# === 4. CONFIGURAR ENTRENAMIENTO ===
trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=2048,
    args=TrainingArguments(
        output_dir="./resultado",
        num_train_epochs=3,            # 3 épocas suele ser suficiente
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        learning_rate=2e-4,
        weight_decay=0.01,
        warmup_steps=10,
        logging_steps=10,
        save_strategy="epoch",
        fp16=True,
        optim="adamw_8bit",
    ),
)

# === 5. ¡ENTRENAR! ===
print("Iniciando entrenamiento...")
trainer.train()
print("¡Entrenamiento completado!")

# === 6. GUARDAR MODELO ===
model.save_pretrained("./mi-modelo-entrenado")
tokenizer.save_pretrained("./mi-modelo-entrenado")

Con un dataset de 300 ejemplos, el entrenamiento toma entre 15-45 minutos en una RTX 4070 Ti. Verás el loss bajar en la consola — si arranca en ~2.0 y termina en ~0.5, vas bien.

Paso 5: Exportar a GGUF para usar con Ollama

El modelo entrenado está en formato Hugging Face. Para ejecutarlo con Ollama necesitas convertirlo a formato GGUF:

# Exportar a GGUF cuantizado en Q4_K_M (buen balance calidad/tamaño)
model.save_pretrained_gguf(
    "./mi-modelo-gguf",
    tokenizer,
    quantization_method="q4_k_m"
)

Esto genera un archivo .gguf de ~4-5 GB que puedes ejecutar con Ollama.

Paso 6: Cargar en Ollama y usar

Crea un archivo llamado Modelfile:

FROM ./mi-modelo-gguf/unsloth.Q4_K_M.gguf

PARAMETER temperature 0.3
PARAMETER top_p 0.9

SYSTEM "Eres un asistente experto en derecho laboral peruano. Responde de manera precisa citando la normativa aplicable."

Luego regístralo en Ollama:

ollama create mi-asistente-legal -f Modelfile

# ¡Probarlo!
ollama run mi-asistente-legal "¿Cuánto es la indemnización por despido arbitrario?"

Tu modelo entrenado ahora corre localmente, sin internet, sin costo por token, con tu expertise incorporado.

Errores comunes y cómo resolverlos

El loss no baja o sube después de la primera época Tu learning rate es demasiado alto. Bájalo a 1e-4 o 5e-5. También revisa que tu dataset no tenga ejemplos contradictorios.

"CUDA out of memory" Reduce per_device_train_batch_size a 1. Baja max_seq_length a 1024. Si persiste, usa un modelo más pequeño (Phi-3 en lugar de Llama 3.1).

El modelo repite la misma frase en bucle Overfitting clásico — estás entrenando demasiado con pocos datos. Reduce num_train_epochs a 1 o 2. Agrega más variedad a tu dataset.

Las respuestas del modelo entrenado son peores que antes Revisa tu dataset. Si los ejemplos son inconsistentes en formato o calidad, el modelo aprende esa inconsistencia. También verifica que no estés demasiadas épocas — el modelo "olvida" conocimiento general (catastrophic forgetting). Mide el MMLU del modelo base vs. el entrenado; si baja más de 3 puntos, reduce épocas.

El modelo no responde en español Asegúrate de que TODO tu dataset esté en español — incluyendo el system prompt. Los modelos multilingües adoptan el idioma predominante en los datos de entrenamiento.

Cuándo entrenar vs. cuándo no entrenar

Entrena cuando:

• Necesitas que el modelo siga un formato específico de respuesta (reportes, JSON, tablas)
• Quieres que adopte terminología técnica de tu industria
• Necesitas un tono o personalidad consistente
• Trabajas con un dominio especializado (legal, médico, técnico)

No entrenes cuando:

• Solo necesitas que el modelo acceda a información actualizada (usa RAG)
• Quieres respuestas sobre un tema puntual (usa prompt engineering)
• Tus datos cambian frecuentemente (RAG es mejor para esto)
• No tienes al menos 200 ejemplos de calidad

Idea clave

Entrenar una IA local ya no es ciencia de cohetes. Con QLoRA, el modelo se comprime a 4 bits, tú solo modificas el 1% de sus parámetros, y el resultado es un asistente que habla tu idioma profesional. La inversión real no es la GPU — son los 200-500 ejemplos de calidad que le enseñan a tu modelo qué es una buena respuesta en tu contexto.

Lo más difícil de entrenar una IA no es el código. Es decidir qué quieres que aprenda.