Como Hacer Fine-Tuning de Gemma 4 con LoRA (Paso a Paso)

Gemma 4 ya es impresionante de fabrica, pero ¿que pasa si necesitas que hable como tu marca, siga tu formato de salida especifico o domine un dominio de nicho donde los modelos generales tropiezan? Ahi es donde entra el fine-tuning.

La buena noticia: ya no necesitas un cluster de A100s. Con LoRA y una herramienta llamada Unsloth, puedes hacer fine-tuning de Gemma 4 en una sola GPU en menos de una hora. Vamos a recorrer todo el proceso.

¿Por Que Hacer Fine-Tuning?

Antes de invertir el esfuerzo, asegurate de que el fine-tuning es realmente lo que necesitas. Aqui tienes una guia rapida de decision:

Si la ingenieria de prompts y RAG no son suficientes, el fine-tuning es tu siguiente movimiento. Antes de lanzarte, prueba nuestros mejores prompts para Gemma 4 — podrias resolver el problema solo con mejores prompts. Para una vision mas amplia de lo que puede hacer Gemma 4 antes de empezar a personalizarlo, ve nuestra guia de casos de uso.

LoRA y QLoRA Explicados (Simplemente)

LoRA (Low-Rank Adaptation) no modifica los pesos del modelo original. En su lugar, entrena un pequeno conjunto de pesos adaptadores que se situan encima del modelo base. Piensalo como poner una lente personalizada en una camara en lugar de reconstruir la camara.

• Modelo base: congelado, intacto
• Adaptador: diminuto (generalmente 1-5% del tamano del modelo base)
• Resultado: calidad cercana a un fine-tune completo a una fraccion del costo

QLoRA va un paso mas alla — carga el modelo base en forma cuantizada de 4 bits, reduciendo el uso de memoria aproximadamente a la mitad. Obtienes mas del 90% de la calidad de LoRA mientras se ajusta en GPUs mucho mas pequenas.

Configurando Unsloth

Unsloth es la forma mas rapida de hacer fine-tuning de Gemma 4 con LoRA. Parchea el modelo para un entrenamiento 2x mas rapido y 60% menos uso de memoria comparado con HuggingFace vanilla.

# Crear un entorno virtual
python -m venv gemma4-finetune
source gemma4-finetune/bin/activate

# Instalar Unsloth (incluye todas las dependencias)
pip install unsloth

# Para QLoRA en GPUs mas antiguas, tambien instala:
pip install bitsandbytes

Verifica tu configuracion:

import torch
print(f"CUDA available: {torch.cuda.is_available()}")
print(f"GPU: {torch.cuda.get_device_name(0)}")
print(f"VRAM: {torch.cuda.get_device_properties(0).total_mem / 1e9:.1f} GB")

Preparando Tus Datos de Entrenamiento

Tus datos deben estar en formato JSONL, con cada linea conteniendo una conversacion. Aqui tienes la estructura que Gemma 4 espera:

{"messages": [{"role": "user", "content": "What's the return policy?"}, {"role": "assistant", "content": "Our return policy allows returns within 30 days of purchase with original receipt."}]}
{"messages": [{"role": "user", "content": "Do you ship internationally?"}, {"role": "assistant", "content": "Yes, we ship to 45 countries. Shipping takes 7-14 business days."}]}
{"messages": [{"role": "system", "content": "You are a medical coding assistant."}, {"role": "user", "content": "Code: Patient presents with acute bronchitis"}, {"role": "assistant", "content": "ICD-10: J20.9 - Acute bronchitis, unspecified"}]}

Consejos de calidad de datos:

• 500-1000 ejemplos es un punto dulce para la mayoria de tareas
• Mas no siempre es mejor — 500 ejemplos de alta calidad superan a 5000 descuidados
• Incluye casos limite y ejemplos negativos
• Mantén las respuestas consistentes en formato y tono
• Valida tu JSONL antes de entrenar:

import json

def validate_jsonl(filepath):
    valid = 0
    errors = 0
    with open(filepath, 'r') as f:
        for i, line in enumerate(f, 1):
            try:
                data = json.loads(line)
                assert "messages" in data, "Missing 'messages' key"
                assert len(data["messages"]) >= 2, "Need at least 2 messages"
                valid += 1
            except (json.JSONDecodeError, AssertionError) as e:
                print(f"Line {i}: {e}")
                errors += 1
    print(f"\nValid: {valid}, Errors: {errors}")

validate_jsonl("training_data.jsonl")

Configuracion de Entrenamiento

Aqui tienes un script de entrenamiento completo usando Unsloth:

from unsloth import FastLanguageModel
import torch

# Load model with QLoRA (4-bit)
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="google/gemma-4-e4b",
    max_seq_length=4096,
    dtype=None,           # Auto-detect
    load_in_4bit=True,    # QLoRA
)

# Add LoRA adapters
model = FastLanguageModel.get_peft_model(
    model,
    r=16,                  # Rank — higher = more capacity, more VRAM
    target_modules=[
        "q_proj", "k_proj", "v_proj", "o_proj",
        "gate_proj", "up_proj", "down_proj",
    ],
    lora_alpha=16,
    lora_dropout=0,        # Unsloth optimized — keep at 0
    bias="none",
    use_gradient_checkpointing="unsloth",
)

# Load training data
from datasets import load_dataset
dataset = load_dataset("json", data_files="training_data.jsonl", split="train")

# Training arguments
from trl import SFTTrainer
from transformers import TrainingArguments

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    max_seq_length=4096,
    args=TrainingArguments(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        warmup_steps=10,
        num_train_epochs=3,
        learning_rate=2e-4,
        fp16=not torch.cuda.is_bf16_supported(),
        bf16=torch.cuda.is_bf16_supported(),
        logging_steps=10,
        output_dir="outputs",
        optim="adamw_8bit",
        seed=42,
    ),
)

# Train
trainer.train()

# Save LoRA adapter
model.save_pretrained("gemma4-finetuned-lora")
tokenizer.save_pretrained("gemma4-finetuned-lora")

Parametros clave a ajustar:

• r=16: Rango LoRA. Comienza con 16, sube a 32 o 64 si la calidad no esta ahi
• num_train_epochs=3: Generalmente 2-5 es suficiente. Cuidado con el sobreajuste
• learning_rate=2e-4: El valor por defecto funciona bien. Baja a 1e-4 si el entrenamiento es inestable
• per_device_train_batch_size=2: Aumenta si tienes margen de VRAM

Exportando a GGUF

Una vez que tu adaptador esta entrenado, probablemente quieras ejecutarlo localmente con Ollama. Eso significa convertir a formato GGUF. Para un desglose detallado de opciones de cuantizacion y sus compromisos, ve nuestra guia GGUF.

# Merge adapter and export to GGUF (Q4_K_M quantization)
model.save_pretrained_gguf(
    "gemma4-finetuned-gguf",
    tokenizer,
    quantization_method="q4_k_m",
)

# Or export at multiple quantization levels
for method in ["q4_k_m", "q5_k_m", "q8_0"]:
    model.save_pretrained_gguf(
        f"gemma4-finetuned-{method}",
        tokenizer,
        quantization_method=method,
    )

Desplegando con Ollama

Crea un Modelfile para llevar tu modelo con fine-tuning a Ollama:

# Modelfile
FROM ./gemma4-finetuned-gguf/gemma4-finetuned-q4_k_m.gguf

PARAMETER temperature 0.7
PARAMETER top_p 0.9

SYSTEM "You are a helpful assistant fine-tuned for customer support."

Luego construye y ejecuta:

# Crear el modelo personalizado
ollama create my-gemma4 -f Modelfile

# Probarlo
ollama run my-gemma4 "What's your return policy?"

# Verificar que esta listado
ollama list

Tu modelo con fine-tuning ahora se ejecuta exactamente como cualquier otro modelo de Ollama. Puedes usarlo con la API de Ollama, construir apps sobre el, o compartirlo con tu equipo.

Problemas Comunes y Soluciones

Falta de memoria durante el entrenamiento: Reduce per_device_train_batch_size a 1, habilita gradient_checkpointing, o cambia a un modelo base mas pequeno.

El modelo produce basura despues del fine-tuning: Tus datos probablemente tienen problemas de formato, o entrenaste por demasiadas epocas. Reduce las epocas y valida tu JSONL.

La exportacion a GGUF falla: Asegurate de tener suficiente espacio en disco (3-5x el tamano del modelo durante la conversion) y que tu version de Unsloth esta actualizada.

La perdida de entrenamiento no disminuye: La tasa de aprendizaje podria ser demasiado baja. Prueba 5e-4. Tambien verifica que tus datos realmente tienen los patrones que quieres que el modelo aprenda.

Siguientes Pasos

• Explora los tamanos de modelo de Gemma 4 para elegir el mejor modelo base para fine-tuning
• Configura un pipeline de despliegue adecuado para tu modelo con fine-tuning
• Aprende sobre salida JSON estructurada para combinar fine-tuning con formatos de salida confiables
• Verifica los requisitos de hardware para planificar tu configuracion de entrenamiento