Finetuning en IA: ¿Fin de una era o evolución hacia modelos más eficientes?

Introducción

El 11 de mayo de 2026, OpenAI anunció la descontinuación de sus APIs de finetuning, una decisión que sacudió a la industria de IA. Durante años, esta funcionalidad fue presentada como la forma más accesible de adaptar modelos como GPT-4o o o1 a casos de uso específicos, prometiendo «rendimiento de o1 a precio de 4o». Sin embargo, tras el anuncio, antropic superó por primera vez a OpenAI en valoración, y el finetuning pasó a engrosar la lista de víctimas de la «masacre del Side Quest 2026» —junto a proyectos como Sora—. La razón técnica detrás de este cambio no es trivial: el cuello de botella ya no es el ajuste fino de modelos, sino la disponibilidad de GPU y la escalabilidad de los sistemas de inferencia.

Pero aquí hay un matiz clave: no es el fin del finetuning, sino su evolución. Empresas como Cursor y Cognition —con rondas de $25 mil millones recientemente anunciadas— incrementaron su inversión en Reinforcement Learning from Human Feedback (RLHF) con modelos abiertos. Incluso hay evidencia de que arquitecturas como los Custom ASIC (chips diseñados específicamente para inferencia) podrían depender de finetunes personalizados. Sin embargo, alternativas como los prompts extremadamente largos (ej: la «Constitución» de Claude) o la disgregación de inferencia (separar pre-procesamiento, prellenado y decodificación) están ganando terreno. Para equipos de DevOps e infraestructura, esto implica repensar no solo cómo desplegar modelos, sino cómo optimizar el stack completo de IA en producción.

Qué ocurrió

El anuncio de OpenAI no fue un evento aislado, sino la cúspide de una tendencia que se venía gestando desde 2023, cuando Jeremy Howard —fundador de fast.ai— cuestionó públicamente la utilidad del finetuning tradicional en podcasts técnicos. Para mayo de 2026, los datos ya eran contundentes:

1. Deprecación de APIs clave:

– Según Latent Space, el 80% de los proyectos de IA en producción ya habían migrado hacia enfoques basados en Retrieval-Augmented Generation (RAG) o Long Context Prompting (LCP).

1. Cambio en el paradigma de entrenamiento:

– Medmarks v1.0 (lanzado en abril de 2026) expandió su suite de benchmarks médicos de 20 a 30, pero los modelos ya mostraban scores superiores al 90% en evaluaciones tradicionales.

– Soohak, un benchmark de matemática de investigación con 439 problemas creados por 64 matemáticos (incluyendo 38 profesores), apuntaba a capacidades más allá de los tests estilo olímpico.

– La comunidad técnica comenzó a cuestionar si el finetuning era realmente necesario cuando modelos como Claude 3.1 (con 200K tokens de contexto) podían resolver tareas complejas con prompt engineering puro.

1. Avances en infraestructura de inferencia:

– Disgregación de inferencia: Empresas como Modal y Perceptron abandonaron Kubernetes estándar para adoptar stacks especializados, argumentando que la inferencia de IA requiere gestión de cómputo, caching nativo, y checkpointing de GPUs para manejar requisitos de cold-start en modelos multimodales.

Impacto para DevOps / Infraestructura / Cloud / Seguridad

Para equipos de DevOps e Infraestructura

1. Reducción de costos operativos:

– Con la descontinuación de APIs como las de OpenAI, los equipos deben migrar hacia:

– Modelos abiertos: Usar modelos como Llama 3.1 o Qwen3, que permiten LoRA (Low-Rank Adaptation) o QLoRA para ajustes ligeros sin requerir full fine-tuning.

– Inferencia desagregada: Separar etapas de pre-procesamiento, prellenado (prefill) y decodificación para optimizar recursos. Por ejemplo:

       # Ejemplo de configuración en Modal para inferencia desagregada
       compute:
         gpu: "A100:4"
       prefill:
         batch_size: 32
         max_tokens: 8192
       decode:
         batch_size: 128
         temperature: 0.7
       

1. Nuevos vectores de ataque en seguridad:

– Inyección de prompts: Técnicas como prompt injection (ej: ataques que modifican el contexto de entrada para desviar respuestas) se vuelven más relevantes.

– Fugas de datos: Si se usan Knowledge Distillation para transferir conocimiento de modelos propietarios a abiertos, el riesgo de exponer datos sensibles aumenta.

– Según Fastly, en 2026 se reportaron un 40% más de incidentes de prompt leaking en sistemas que combinaban RAG con modelos de código abierto.

1. Escalabilidad en nube híbrida:

– Redes de alta velocidad: Para manejar tokens de contexto >100K, se requieren conexiones como RoCEv2 CX-7 (reported por SemiAnalysis como capaces de mejorar el throughput por GPU hasta 7×).

– Almacenamiento distribuido: Sistemas como Qdrant 1.18 (con TurboQuant para compresión de vectores) reducen el uso de memoria en un 50% sin perder precisión en búsquedas semánticas.

Detalles técnicos

1. Alternativas técnicas al finetuning tradicional

La adaptación de bajo rango (LoRA) reduce el número de parámetros entrenables de ~7B a ~1M, permitiendo ajustes en horas (vs. semanas con full finetuning). Ejemplo con peft:

  from peft import LoraConfig, get_peft_model
  lora_config = LoraConfig(
      r=8,          # Rango de descomposición
      lora_alpha=32,
      target_modules=["q_proj", "v_proj"],
      lora_dropout=0.05
  )
  model = get_peft_model(model, lora_config)
  

• Disgregación de inferencia en AWS:

– NVLink para comunicación GPU-GPU a 600GB/s.

– EFA (Elastic Fabric Adapter) para reducir latencia en all-reduce a <350µs.

Configuración típica:

  # Despliegue en EKS con vLLM
  helm install vllm oci://ghcr.io/vllm-project/vllm-helm \
    --version 0.4.2 \
    --set model="Qwen/Qwen3-235B" \
    --set gpu.count=8 \
    --set nvlink.enabled=true
  

2. Métricas de rendimiento clave en 2026

• Throughput por GPU:

– Disaggregación de prefill/decodificación: Separar etapas permite escalar prefill (etapa crítica en MoE) mientras decode se ejecuta en GPUs dedicadas.

– Quantización INT4/INT8: Modelos como Qdrant 1.18 con TurboQuant reducían el uso de VRAM en un 60% sin pérdida de precisión en búsquedas.

• Latencia en sistemas distribuidos:

| Sistema | Prellenado (µs) | Decodificación (tokens/s) | VRAM (GB) |

|——————|——————-|—————————|————-|

| vLLM (A100) | 730.1 | 1,200 | 80 |

| vLLM (GB200)| 438.5 | 2,800 | 128 |

| TensorRT-LLM | 512.3 | 2,100 | 96 |

Qué deberían hacer los administradores y equipos técnicos

1. Migrar desde finetuning tradicional

1. Evaluar alternativas inmediatas:

– Prompt engineering avanzado con contextos largos (ej: usar Claude 3.1 con 200K tokens de contexto).

– RAG con vectores embebidos en Qdrant 1.18 o Weaviate 1.20 (este último añadió soporte para sparse vectors en abril 2026).

– Ejemplo de migración en Python:

     from transformers import AutoModelForCausalLM, AutoTokenizer
     from qdrant_client import QdrantClient

     # 1. Cargar modelo abierto
     model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen3-235B", device_map="auto")
     tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-235B")

     # 2. Usar RAG para recuperar contexto relevante
     client = QdrantClient("localhost", port=6333)
     results = client.search(
         collection_name="docs",
         query_text="código para autenticación en Go",
         limit=5
     )

     # 3. Construir prompt con contexto recuperado
     prompt = f"""Responde en español técnico:
     CONTEXTO:
     {results[0].payload['text']}
     PREGUNTA: {user_input}
     """
     

1. Implementar LoRA/LoRA para ajustes ligeros:

     pip install peft bitsandbytes accelerate
     

     from peft import LoraConfig, prepare_model_for_kbit_training
     from transformers import AutoModelForCausalLM

     model = AutoModelForCausalLM.from_pretrained(
         "meta-llama/Meta-Llama-3.1-8B",
         load_in_4bit=True,
         bnb_4bit_compute_dtype=torch.float16
     )
     model = prepare_model_for_kbit_training(model)

     lora_config = LoraConfig(
         r=16,
         lora_alpha=64,
         target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
         lora_dropout=0.1,
         bias="none",
         task_type="CAUSAL_LM"
     )
     model = get_peft_model(model, lora_config)
     

2. Optimizar infraestructura para inferencia

1. Desplegar con vLLM o TensorRT-LLM:

     helm repo add vllm https://vllm-helm.github.io/vllm-helm
     helm install vllm vllm/vllm \
       --set model="Qwen/Qwen3-235B-MoE" \
       --set gpu.count=8 \
       --set nvlink.enabled=true \
       --set quantize="int8"
     

– Para modelos pequeños (ej: Phi-3-mini), usa TensorRT-LLM con FlashAttention-2:

     docker run --gpus all -it \
       -v /models:/models \
       nvcr.io/nvidia/pytorch:23.10-py3 \
       bash -c "trtllm-build --model_name phi3 --model_dir /models/phi-3-mini-4k-instruct \
       --output_dir /models/phi3-engine --gemm_plugin float16"
     

1. Configurar caching y checkpointing:

     # Ejemplo en Kubernetes con CRIU
     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: vllm-phi3
     spec:
       template:
         spec:
           containers:
           - name: vllm
             image: vllm/vllm-openai:v0.4.2
             command: ["vllm", "serve", "Phi-3-mini-4k-instruct"]
             volumeMounts:
             - name: criu-sock
               mountPath: /var/run/criu
           volumes:
           - name: criu-sock
             emptyDir: {}
     

3. Seguridad y gobernanza

1. Auditar prompts y datos:

     from guardrails import Guard
     guard = Guard().use("prompt_injection_detector")
     response = guard(
         model="claude-3.1",
         prompt="Responde a la pregunta: {user_input}",
         metadata={"user_id": "12345"}
     )
     

– Loguea todos los prompts en OpenTelemetry para análisis forense.

1. Proteger datos en RAG:

     from sentence_transformers import SentenceTransformer
     from opacus import PrivacyEngine

     model = SentenceTransformer("all-MiniLM-L6-v2")
     privacy_engine = PrivacyEngine()
     model, optimizer, train_loader = privacy_engine.make_private(
         module=model,
         optimizer=optimizer,
         data_loader=train_loader,
         max_grad_norm=1.0,
         noise_multiplier=0.5
     )
     

Conclusión

El finetuning no desapareció, pero su rol en la pila de IA se transformó. Los equipos técnicos deben adoptar un enfoque multimodal, combinando:

1. Modelos abiertos con LoRA/QLoRA para ajustes ligeros.
2. RAG + Long Context Prompting para reducir la necesidad de reentrenamiento.
3. Inferencia desagregada con stacks especializados (vLLM, Modal, Perceptron).
4. Optimización de recursos con cuantización, caching y GPU checkpointing.

La clave está en medir el ROI de cada técnica: si un ajuste fino requiere 4 semanas de entrenamiento y 100K USD en GPUs, pero un prompt de 50K tokens resuelve el 90% del problema, la elección es clara. En 2026, la eficiencia operativa en IA no se mide en FLOPs, sino en tokens por dólar.

Fuentes

• AINews: The End of Finetuning
• Fastly: AI Security Trends 2026
• Latent Space: Research Benchmarks May 2026
• Perplexity: Serving Qwen3-235B on GB200
• SemiAnalysis: GPU Cluster Optimization 2026
• Qdrant: TurboQuant Announcement