¡Hola!

Si estás aquí, probablemente estés interesado en hacer fine-tuning a modelos de IA de código abierto para aplicarlos a tus propios casos de uso (chatbots, asistentes de codificación, expertos en un dominio, etc.). Aquí tienes una descripción general sencilla para principiantes que puedes usar directamente en el contexto de Laravel y el desarrollo web en general.

1. ¿Qué significa "hacer fine-tuning a un modelo de IA de código abierto"?

El fine-tuning consiste en tomar un modelo pre-entrenado existente (como LLaMA‑2, Mistral o un modelo de Hugging Face) y entrenarlo un poco más con tus propios datos para que:

  • Se adapte a tu dominio (legal, financiero, médico, juegos, etc.)
  • Aprenda tu tono y estilo
  • Mejore en ciertas tareas (QA, codificación, clasificación, soporte, etc.)

En lugar de entrenar desde cero (lo cual es costoso y lleva mucho tiempo), reutilizas un modelo base poderoso y lo especializas.

2. Opciones principales para el fine-tuning

Existen principalmente 3 enfoques que encontrarás:

2.1 Fine-tuning completo

  • Actualiza todos los pesos del modelo.
  • Ventajas: Máxima flexibilidad y rendimiento.
  • Desventajas: Requiere mucho GPU, tiempo y almacenamiento.

Generalmente, esto es excesivo a menos que seas una institución de investigación o una gran empresa.

2.2 LoRA / PEFT (Fine-tuning eficiente en parámetros)

Ventajas:

  • Requisitos de VRAM mucho menores
  • Más rápido
  • Puedes compartir solo los adaptadores, no todo el modelo

Desventajas:

  • Ligeramente menos expresivo que el fine-tuning completo, pero generalmente es suficiente.

2.3 QLoRA (LoRA Cuantificado)

  • Combina cuantización (por ejemplo, 4 bits) con LoRA.
    • Carga el modelo base en baja precisión (int4 o int8).
    • Entrena adaptadores LoRA encima de él.

Ventajas:

  • Puedes hacer fine-tuning de modelos grandes en una sola GPU (incluso una GPU de consumo como una de 24 GB).
  • Muy popular para modelos estilo LLaMA.

Recomendado para la mayoría de los desarrolladores individuales.

3. Selección de un modelo base de código abierto

Dónde encontrar modelos:

Opciones comunes:

  • Chat / Asistente:
    • mistralai/Mistral-7B-Instruct-v0.2
    • meta-llama/Llama-3-8b-instruct (si la licencia y el acceso se ajustan a tu caso de uso)
  • Código:
    • codellama/CodeLlama-7b-Instruct-hf
    • deepseek-ai/deepseek-coder-6.7b-instruct

Cosas para verificar:

  • Licencia (comercial vs no comercial)
  • Tamaño del modelo (7B es un buen punto de partida)
  • Instruction‑tuned vs base: elige un modelo instruct/chat para un chatbot.

4. Preparación de datos para el fine-tuning

El formato de tus datos es más importante de lo que la gente piensa.

4.1 ¿Qué tipo de datos debes usar?

Ejemplos:

  • Registros de chat de atención al cliente
  • Documentos de preguntas frecuentes
  • Artículos de la base de conocimientos
  • Repositorio de código + descripciones
  • Artículos de investigación específicos del dominio

Limpia tus datos:

  • Elimina PII / secretos (claves API, correos electrónicos, contraseñas).
  • Elimina duplicados de texto similares.
  • Corrige problemas de formato obvios.

4.2 Formatos de instrucción comunes

Para modelos de chat, un formato común de Hugging Face es:

{
  "instruction": "Explique brevemente qué es el fine-tuning.",
  "input": "",
  "output": "El fine-tuning consiste en tomar un modelo pre-entrenado existente y entrenarlo más con tus propios datos..."
}

O, un formato más similar al chat:

{
  "messages": [
    {"role": "system", "content": "Eres un asistente útil para preguntas relacionadas con la contabilidad."},
    {"role": "user", "content": "¿Cómo registro el pago de una factura?"},
    {"role": "assistant", "content": "Para registrar el pago de una factura, debes..."}
  ]
}

Guarda como .jsonl (un objeto JSON por línea), .json o como un conjunto de datos de Hugging Face.

5. Ejemplo mínimo: fine-tuning con Hugging Face + LoRA

En general, necesitarás:

  • Python 3.10+
  • GPU (idealmente >= 16 GB VRAM para 7B, 24 GB es más cómodo)
  • Bibliotecas:
    • transformers
    • datasets
    • peft
    • bitsandbytes
    • accelerate

5.1 Instalación de dependencias

pip install "transformers>=4.39.0" "datasets" "accelerate" "peft" "bitsandbytes"

5.2 Script QLoRA simple (concepto)

from datasets import load_dataset
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer
from peft import LoraConfig, get_peft_model
import torch

model_name = "mistralai/Mistral-7B-Instruct-v0.2"
dataset_path = "path_or_hf_dataset"  # Ej: "my-username/my-dataset"

tokenizer = AutoTokenizer.from_pretrained(model_name)
tokenizer.pad_token = tokenizer.eos_token

model = AutoModelForCausalLM.from_pretrained(
    model_name,
    load_in_4bit=True,
    device_map="auto"
)

dataset = load_dataset(dataset_path, split="train")

def format_example(example):
    user = example["instruction"]
    answer = example["output"]
    prompt = f"User: {user}
Assistant:"
    return {"input_ids": tokenizer(prompt, truncation=True, padding="max_length", max_length=512)["input_ids"],
            "labels":    tokenizer(answer, truncation=True, padding="max_length", max_length=512)["input_ids"]}

tokenized = dataset.map(format_example, remove_columns=dataset.column_names)

lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "v_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)

model = get_peft_model(model, lora_config)

training_args = TrainingArguments(
    output_dir="./mistral-finetuned",
    per_device_train_batch_size=2,
    gradient_accumulation_steps=8,
    learning_rate=2e-4,
    num_train_epochs=3,
    fp16=True,
    logging_steps=10,
    save_steps=500,
    save_total_limit=2,
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized
)

trainer.train()
model.save_pretrained("./mistral-finetuned-lora")
tokenizer.save_pretrained("./mistral-finetuned-lora")

Esta es una referencia simplificada. Para uso en producción, consulta:

6. Integración de un modelo fine-tuned con una aplicación Laravel

Una vez que tengas un modelo fine-tuned, debes servirlo e invocarlo desde Laravel.

6.1 Diferentes formas de servir tu modelo

  1. Microservicio FastAPI / Flask (Python)
    • Ejecuta la inferencia con transformers o vLLM.
    • Expón un punto final /generate.
  2. Text Generation Inference (TGI)
  3. Ollama (para algunos modelos)
    • Ollama se ejecuta en macOS/Linux y proporciona una API HTTP simple.

6.2 Punto final de inferencia básico (ejemplo de Python + FastAPI)

from fastapi import FastAPI
from pydantic import BaseModel
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

app = FastAPI()

model_name = "./mistral-finetuned-lora"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto"
)

class GenerateRequest(BaseModel):
    prompt: str
    max_new_tokens: int = 256
    temperature: float = 0.7

@app.post("/generate")
def generate(req: GenerateRequest):
    inputs = tokenizer(req.prompt, return_tensors="pt").to(model.device)
    output = model.generate(
        **inputs,
        max_new_tokens=req.max_new_tokens,
        temperature=req.temperature,
        do_sample=True,
        pad_token_id=tokenizer.eos_token_id
    )
    text = tokenizer.decode(output[0], skip_special_tokens=True)
    return {"result": text}

Ejecuta esto en una máquina con GPU.

6.3 Invoca el modelo desde Laravel

En Laravel, usa Http::post() (de Illuminate\Support\Facades\Http) para comunicarte con tu servicio Python.

use Illuminate\Support\Facades\Http;

$response = Http::post('http://your-python-host:8000/generate', [
    'prompt' => 'Explique qué es el fine-tuning.',
    'max_new_tokens' => 256,
    'temperature' => 0.7,
]);

$result = $response->json()['result'] ?? null;

Puedes envolver esto en una clase de servicio (por ejemplo, App\Services\AIClient) e invocarla desde tus controladores.

7. Consejos para obtener mejores resultados de fine-tuning

  1. Comienza pequeño: Comienza con un modelo 7B y un conjunto de datos pequeño (1k-10k ejemplos).
  2. Mantén la consistencia del prompt: Usa la misma estructura que usarás en el momento de la inferencia.
  3. Evalúa con frecuencia:
    • Crea un pequeño conjunto de preguntas de evaluación.
    • Verifica las respuestas de cada ejecución de entrenamiento.
  4. Evita el sobreajuste:
    • Usa un conjunto de validación.
    • Verifica si el modelo comienza a memorizar.
  5. Documenta tu configuración:
    • Rango de LoRA, tasa de aprendizaje, épocas, versión del conjunto de datos.
    • Esto te ayudará a reproducir buenas ejecuciones.

8. Herramientas y frameworks comunes que vale la pena explorar

9. Cuándo el fine-tuning podría no ser necesario

A veces puedes obtener lo que necesitas con:

  • Ingeniería de prompts (mejores instrucciones y ejemplos)
  • RAG (Generación Aumentada por Recuperación) – Alimentar documentos externos en el momento de la consulta, sin cambiar los pesos

RAG a menudo es más fácil de mantener y actualizar que el fine-tuning completo, especialmente para conocimientos que cambian rápidamente.

10. Próximos pasos

Si estás empezando:

  1. Elige un modelo instruct de Hugging Face.
  2. Crea un pequeño conjunto de datos de instrucciones de tu propio dominio.
  3. Ejecuta una breve ejecución de fine-tuning usando QLoRA + PEFT.
  4. Sirve el modelo a través de una pequeña API de Python.
  5. Invócalo desde Laravel usando Http::post() y crea una interfaz.

Dime:

  • ¿Qué casos de uso tienes en mente (chatbot, asistente de código, herramienta interna, etc.)?
  • ¿A qué hardware (GPU / RAM) tienes acceso?

Puedo describir un plan de fine-tuning paso a paso adaptado a tu configuración exacta.