Fine Tuning de Modelos de IA: Qué Es y Cómo Hacerlo con Tecnología Red Hat

¿Alguna vez sentiste que el modelo de IA «casi» entiende tu negocio, pero no del todo? Eso tiene solución, y se llama Fine Tuning. Hoy te lo explico con ejemplos reales y te muestro cómo Red Hat te da la plataforma para hacerlo dentro de tu datacenter, sin mandar tus datos sensibles a ningún lado.

¿Qué es el Fine Tuning?

Cuando hablamos de un Large Language Model (LLM) como Llama, Mistral o Granite, ese modelo fue entrenado con billones de tokens de internet. Sabe de todo un poco, pero no sabe nada específico de tu banco, tu aseguradora, o los productos financieros que tú comercializas.

El Fine Tuning es el proceso de tomar ese modelo base ya entrenado y continuar su entrenamiento con datos propios y específicos de tu dominio, para que aprenda a responder mejor en tu contexto.

Piénsalo así:

Un médico recién egresado de la universidad sabe medicina general. Pero un cardiólogo lleva años adicionales de especialización en el corazón. El Fine Tuning es esa especialización.

¿En qué se diferencia del Prompt Engineering y del RAG?

Estas técnicas no son excluyentes. En producción bancaria, lo más poderoso es combinar Fine Tuning + RAG.

¿Cuándo tiene sentido hacer Fine Tuning?

No todo problema requiere Fine Tuning. Aquí los casos donde sí vale la inversión:

• Lenguaje del dominio: Quieres que el modelo hable el lenguaje de tu industria. «TEA», «TCEA», «BCRP», «SBS», «fondos mutuos» deben ser términos que el modelo maneje con naturalidad.
• Tono corporativo consistente: El modelo debe responder como un ejecutivo de tu banco, no como un chatbot genérico.
• Clasificación y extracción precisa: Clasificar reclamos, extraer campos de contratos, categorizar transacciones con alta precisión.
• Reducción de latencia: Un modelo más pequeño y especializado puede ser más rápido que uno gigante generalista.
• Privacidad de datos: Al hacer Fine Tuning on-premise, tus datos nunca salen de tu infraestructura.

El proceso de Fine Tuning paso a paso

El flujo general tiene estas etapas:

Datos crudos → Preparación del dataset → Entrenamiento (Fine Tuning) → Evaluación → Despliegue

1. Preparación del Dataset

Es la etapa más crítica. Necesitas ejemplos en formato instrucción → respuesta (o prompt → completion). Ejemplo para un banco:

{
  "instruction": "El cliente pregunta: ¿Cuál es la diferencia entre una cuenta de ahorros y un depósito a plazo?",
  "output": "Estimado cliente, una cuenta de ahorros le permite disponer de su dinero en cualquier momento con liquidez inmediata, mientras que un depósito a plazo fijo ofrece una tasa de interés mayor a cambio de mantener el monto inmovilizado durante el período pactado. La elección depende de si prioriza liquidez o rendimiento."
}

Calidad > Cantidad. 500 ejemplos bien curados superan a 50,000 ejemplos ruidosos.

2. Técnica de Fine Tuning: LoRA y QLoRA

Entrenar un LLM completo requiere decenas de GPUs y semanas. Por eso hoy se usa LoRA (Low-Rank Adaptation), una técnica que:

• No modifica todos los pesos del modelo (son miles de millones)
• Agrega matrices de adaptación pequeñas que sí se entrenan
• Reduce el costo computacional en 10x a 100x
• El resultado final se puede fusionar con el modelo base

QLoRA añade cuantización (4-bit) para correr en GPUs con menos VRAM.

Modelo Base (congelado) + Adaptadores LoRA (entrenables) = Modelo Especializado

3. Evaluación

Antes de desplegar, evalúas con métricas como:

• BLEU / ROUGE: Calidad del texto generado
• Benchmarks del dominio: Preguntas específicas de tu industria
• Evaluación humana: El equipo de negocio valida respuestas

¿Cómo lo haces con tecnología Red Hat?

Aquí viene la parte que más me emociona contarte. Red Hat tiene una plataforma completa para hacer todo esto on-premise o en nube híbrida, sin depender de APIs externas.

Red Hat OpenShift AI

OpenShift AI es la plataforma MLOps de Red Hat construida sobre OpenShift. Incluye:

• Jupyter Notebooks gestionados con acceso a GPU
• Pipelines de ML (basados en Kubeflow Pipelines)
• Model Serving con vLLM, OpenVINO y Triton Inference Server
• Distributed Workloads con KubeRay para entrenamiento distribuido
• Model Registry para versionado de modelos

InstructLab: El cambio de juego para Fine Tuning

InstructLab es un proyecto open source creado por Red Hat e IBM que democratiza el Fine Tuning. Su gran innovación es el concepto de LAB (Large-scale Alignment for Chatbots):

En lugar de requerir miles de ejemplos, InstructLab usa síntesis de datos con un «teacher model» para generar automáticamente más ejemplos de entrenamiento a partir de pocos ejemplos iniciales que tú aportas.

El flujo con InstructLab es:

1. Defines habilidades y conocimiento en YAML (taxonomy)
2. InstructLab genera sintéticamente más datos de entrenamiento
3. Entrenas el modelo con esos datos
4. Evalúas y validas
5. Sirves el modelo en OpenShift AI

Instalación básica de InstructLab

# Instalar InstructLab
pip install instructlab

# Inicializar
ilab config init

# Descargar modelo base (Granite)
ilab model download

# Servir el modelo localmente para pruebas
ilab model serve

# Chatear con el modelo
ilab model chat

Ejemplo de taxonomy para el dominio financiero

Creas un archivo YAML con el conocimiento que quieres inyectar:

# taxonomy/knowledge/finanzas/peru/qna.yaml
version: 3
domain: finanzas_peru
created_by: buga
seed_examples:
  - context: |
      El sistema financiero peruano está regulado por la Superintendencia de Banca,
      Seguros y AFP (SBS). Las entidades financieras deben cumplir con las normas
      de Basilea III adaptadas por la SBS para gestión de riesgos.
    questions_and_answers:
      - question: ¿Quién regula el sistema financiero en el Perú?
        answer: |
          El sistema financiero peruano es regulado principalmente por la
          Superintendencia de Banca, Seguros y AFP (SBS), que supervisa
          bancos, financieras, cajas municipales, cajas rurales y empresas
          de seguros.
      - question: ¿Qué normas de gestión de riesgos aplican los bancos peruanos?
        answer: |
          Los bancos peruanos aplican las normas de Basilea III adaptadas
          por la SBS, que incluyen requerimientos de capital, liquidez
          y apalancamiento.

Pipeline de Fine Tuning en OpenShift AI

Con OpenShift AI puedes definir el pipeline de entrenamiento como código:

# pipeline_fine_tuning.py
from kfp import dsl
from kfp.kubernetes import use_config_map_as_env

@dsl.component(
    base_image="registry.redhat.io/rhoai/odh-pytorch-notebook-rhel9:latest"
)
def preparar_dataset(
    ruta_datos: str,
    ruta_salida: str
):
    """Prepara y valida el dataset de entrenamiento"""
    import json
    from datasets import Dataset
    
    # Cargar datos propietarios desde storage seguro
    with open(ruta_datos, 'r', encoding='utf-8') as f:
        datos = json.load(f)
    
    # Formatear al estilo instrucción-respuesta
    dataset = Dataset.from_list([
        {
            "text": f"### Instrucción:\n{item['instruction']}\n\n### Respuesta:\n{item['output']}"
        }
        for item in datos
    ])
    
    dataset.save_to_disk(ruta_salida)
    print(f"Dataset preparado: {len(dataset)} ejemplos")


@dsl.component(
    base_image="registry.redhat.io/rhoai/odh-pytorch-notebook-rhel9:latest",
    packages_to_install=["peft", "transformers", "trl", "bitsandbytes"]
)
def ejecutar_fine_tuning(
    modelo_base: str,
    ruta_dataset: str,
    ruta_modelo_salida: str,
    lora_r: int = 16,
    lora_alpha: int = 32,
    epochs: int = 3
):
    """Ejecuta Fine Tuning con LoRA usando TRL"""
    from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments
    from peft import LoraConfig, get_peft_model
    from trl import SFTTrainer
    from datasets import load_from_disk

    # Configuración LoRA
    lora_config = LoraConfig(
        r=lora_r,
        lora_alpha=lora_alpha,
        target_modules=["q_proj", "v_proj"],
        lora_dropout=0.05,
        bias="none",
        task_type="CAUSAL_LM"
    )

    # Cargar modelo base (ej: ibm-granite/granite-3.1-8b-instruct)
    modelo = AutoModelForCausalLM.from_pretrained(
        modelo_base,
        load_in_4bit=True  # QLoRA
    )
    tokenizer = AutoTokenizer.from_pretrained(modelo_base)
    
    modelo = get_peft_model(modelo, lora_config)
    modelo.print_trainable_parameters()

    # Dataset
    dataset = load_from_disk(ruta_dataset)

    # Argumentos de entrenamiento
    args = TrainingArguments(
        output_dir=ruta_modelo_salida,
        num_train_epochs=epochs,
        per_device_train_batch_size=4,
        gradient_accumulation_steps=4,
        warmup_steps=100,
        learning_rate=2e-4,
        fp16=True,
        logging_steps=10,
        save_strategy="epoch"
    )

    # Entrenador
    trainer = SFTTrainer(
        model=modelo,
        train_dataset=dataset,
        dataset_text_field="text",
        args=args,
        max_seq_length=2048
    )

    trainer.train()
    trainer.save_model(ruta_modelo_salida)
    print(f"Modelo guardado en: {ruta_modelo_salida}")


@dsl.pipeline(name="Fine Tuning Pipeline - Dominio Financiero")
def pipeline_fine_tuning():
    paso1 = preparar_dataset(
        ruta_datos="/mnt/datos/training_data.json",
        ruta_salida="/mnt/modelos/dataset_procesado"
    )
    
    paso2 = ejecutar_fine_tuning(
        modelo_base="ibm-granite/granite-3.1-8b-instruct",
        ruta_dataset=paso1.output,
        ruta_modelo_salida="/mnt/modelos/granite-financiero-v1"
    )

Servir el modelo fine-tuneado en OpenShift AI

Una vez entrenado, registras el modelo y lo sirves con vLLM, que es compatible con la API de OpenAI:

# ServingRuntime para el modelo fine-tuneado
apiVersion: serving.kserve.io/v1alpha1
kind: ServingRuntime
metadata:
  name: granite-financiero-vllm
  namespace: ai-banking
spec:
  containers:
    - name: kserve-container
      image: quay.io/rhoai/vllm:latest
      args:
        - --model=/mnt/models/granite-financiero-v1
        - --tensor-parallel-size=1
        - --max-model-len=4096
      resources:
        limits:
          nvidia.com/gpu: "1"
          memory: "24Gi"
        requests:
          nvidia.com/gpu: "1"
          memory: "16Gi"

Y lo consumes desde tu aplicación Java/Quarkus exactamente igual que cualquier LLM:

// application.properties
quarkus.langchain4j.openai.base-url=https://granite-financiero.apps.openshift.empresa.com/v1
quarkus.langchain4j.openai.api-key=ninguno
quarkus.langchain4j.openai.chat-model.model-name=granite-financiero-v1

// ChatService.java
@RegisterAiService
public interface AsesorFinancieroService {

    @SystemMessage("""
        Eres un asesor financiero virtual del banco. 
        Respondes en español, con tono profesional y empático.
        Solo das información sobre productos del banco.
        """)
    String consultar(@UserMessage String preguntaCliente);
}

Arquitectura de referencia: Fine Tuning on-premise para banca

┌─────────────────────────────────────────────────────────────────┐
│                     OpenShift Cluster                           │
│                                                                 │
│  ┌─────────────────┐    ┌──────────────────────────────────┐   │
│  │  OpenShift AI   │    │         GPU Node Pool            │   │
│  │                 │    │  ┌──────────────────────────┐    │   │
│  │ • Jupyter       │───▶│  │  Fine Tuning Job (LoRA)  │    │   │
│  │ • Pipelines     │    │  │  Granite 3.1 8B / Llama  │    │   │
│  │ • Model Registry│    │  └──────────────────────────┘    │   │
│  │ • Model Serving │    └──────────────────────────────────┘   │
│  └─────────────────┘                                           │
│           │                                                     │
│           ▼                                                     │
│  ┌─────────────────┐    ┌──────────────────────────────────┐   │
│  │  S3 / ODF       │    │    Inference Endpoint (vLLM)     │   │
│  │  (Datos +       │    │    Compatible con OpenAI API     │   │
│  │   Modelos)      │    │    TLS + Auth con RHSSO          │   │
│  └─────────────────┘    └──────────────────────────────────┘   │
│                                    │                            │
└────────────────────────────────────┼────────────────────────────┘
                                     │
                         ┌───────────▼──────────┐
                         │  Aplicaciones        │
                         │  (Quarkus / Spring)  │
                         │  Canal digital       │
                         │  Call center AI      │
                         └──────────────────────┘

Red Hat + IBM Granite: La dupla perfecta para banca

Red Hat y su empresa madre IBM ofrecen los modelos IBM Granite como los modelos de IA empresariales de referencia en la plataforma. Sus ventajas para el sector financiero:

• Transparencia total: Datos de entrenamiento documentados y auditables
• Licencia Apache 2.0: Puedes hacer Fine Tuning y usar comercialmente sin restricciones
• Tamaños optimizados: Desde 3B hasta 34B parámetros, según tu presupuesto de GPU
• Soporte empresarial: Red Hat soporta el stack completo, no solo la infraestructura

¿Cuánto cuesta hacer Fine Tuning on-premise?

Referencia aproximada para un modelo de 8B parámetros con LoRA/QLoRA:

Si ya tienes OpenShift con GPUs para inferencia, el Fine Tuning no requiere inversión adicional en infraestructura.

Conclusión: Tu IA, tus datos, tu control

El Fine Tuning con tecnología Red Hat te da lo mejor de dos mundos:

✅ Modelos del estado del arte (Granite, Llama, Mistral) como punto de partida ✅ Especialización en tu dominio sin exponer datos sensibles ✅ Plataforma MLOps empresarial con soporte Red Hat ✅ Despliegue en el mismo OpenShift donde ya corren tus aplicaciones ✅ APIs compatibles con OpenAI, lo que facilita la integración con Quarkus o Spring

Para los bancos, financieras y aseguradoras en el Perú que buscan implementar IA generativa con control total sobre sus datos, este stack es la respuesta.