Ajuste fino de embeddings
En esta página
Objetivos
- Comprender cuándo es necesario el ajuste fino de embeddings.
- Preparar un conjunto de datos de pares para el entrenamiento.
- Implementar el ajuste fino con adaptadores ligeros.
¿Cuándo hacer un ajuste fino?
Empecemos por la mala noticia, que en realidad es buena: en la mayoría de los casos, los modelos de embeddings preentrenados funcionan perfectamente y hacer un ajuste fino es una pérdida de esfuerzo. Solo tres situaciones lo justifican realmente. La primera es un dominio con un vocabulario muy especializado —medicina, derecho, industria— donde el modelo genérico no sabe que «MI» e «infarto de miocardio» se refieren a lo mismo. La segunda es alcanzar una meseta: has optimizado la fragmentación, añadido búsqueda híbrida y reordenación, y las métricas no avanzan. La tercera es simplemente tener a mano pares de texto anotados, similares o disímiles, acumulando polvo en tus registros de búsqueda.
Por el contrario, omite el ajuste fino si tienes menos de mil pares anotados: el entrenamiento memorizará tus ejemplos sin generalizar. Omítelo también si el rendimiento ya es satisfactorio; una ganancia de dos puntos en la exhaustividad no compensa mantener un modelo extra. Y, sobre todo, verifica que una mejor fragmentación o un mejor prompt no resuelvan el problema: casi siempre es más barato y rápido.
Enfoque 1: Adaptador lineal (Matryoshka)
El enfoque más económico deja intacto el modelo de embeddings. Dejas que produzca sus vectores y luego entrenas una pequeña capa de proyección encima que deforma el espacio para acercar lo que debe estar cerca en tu dominio. El modelo de OpenAI sigue siendo una caja negra a la que se llama mediante API; solo se entrenan unos pocos cientos de miles de parámetros, en CPU, en minutos.
El entrenamiento se basa en tripletas: una consulta, un documento que la responde y un documento que trata el mismo tema pero no la responde. Observa los ejemplos médicos siguientes: el negativo para «efectos secundarios del paracetamol» no es un texto sobre fútbol, sino un texto sobre paracetamol vendido en farmacias. Esto se llama negativo difícil, y es lo que enseña algo al modelo: un negativo obvio no corrige nada, ya que el modelo genérico ya lo clasificó correctamente.
import numpy as np
from openai import OpenAI
from sklearn.model_selection import train_test_split
client = OpenAI()
# Conjunto de datos de tripletas (consulta, documento_positivo, documento_negativo)
triplets = [
{
"query": "paracetamol side effects",
"positive": "Paracetamol can cause liver disorders...",
"negative": "Paracetamol is available in pharmacies..."
},
{
"query": "children's aspirin dosage",
"positive": "For children aged 6 to 12, the recommended dose...",
"negative": "Aspirin was discovered in the 19th century..."
},
# ... más tripletas
]
def prepare_embeddings(triplets: list[dict]) -> dict:
"""Genera embeddings para las tripletas."""
all_texts = []
for t in triplets:
all_texts.extend([t["query"], t["positive"], t["negative"]])
response = client.embeddings.create(
input=all_texts,
model="text-embedding-3-large"
)
embs = np.array(
[d.embedding for d in sorted(response.data, key=lambda x: x.index)]
)
n = len(triplets)
return {
"queries": embs[0::3],
"positives": embs[1::3],
"negatives": embs[2::3],
}
El adaptador en sí es una red de dos capas que proyecta las 3.072 dimensiones del modelo hasta 256, con una normalización final para que los vectores de salida sigan siendo comparables mediante similitud del coseno. La función de pérdida es una pérdida de margen de triplete: es cero tan pronto como la consulta está más cerca del positivo que del negativo por al menos un margen de 0,2, y penaliza proporcionalmente en caso contrario. En otras palabras, solo enseñas al modelo lo que aún no ha entendido, y el entrenamiento se estabiliza naturalmente una vez que las tripletas están bien separadas.
import torch
import torch.nn as nn
import torch.optim as optim
class EmbeddingAdapter(nn.Module):
"""Capa de proyección para adaptar embeddings."""
def __init__(self, input_dim: int = 3072, output_dim: int = 256):
super().__init__()
self.projection = nn.Sequential(
nn.Linear(input_dim, output_dim),
nn.ReLU(),
nn.Linear(output_dim, output_dim),
)
def forward(self, x):
projected = self.projection(x)
return projected / projected.norm(dim=-1, keepdim=True)
def triplet_loss(anchor, positive, negative, margin=0.2):
"""Pérdida de margen de triplete."""
dist_pos = 1 - torch.cosine_similarity(anchor, positive)
dist_neg = 1 - torch.cosine_similarity(anchor, negative)
return torch.relu(dist_pos - dist_neg + margin).mean()
def train_adapter(data: dict, epochs: int = 50):
"""Entrena el adaptador con tripletas."""
model = EmbeddingAdapter()
optimizer = optim.Adam(model.parameters(), lr=1e-3)
queries = torch.tensor(data["queries"], dtype=torch.float32)
positives = torch.tensor(data["positives"], dtype=torch.float32)
negatives = torch.tensor(data["negatives"], dtype=torch.float32)
for epoch in range(epochs):
optimizer.zero_grad()
q_proj = model(queries)
p_proj = model(positives)
n_proj = model(negatives)
loss = triplet_loss(q_proj, p_proj, n_proj)
loss.backward()
optimizer.step()
if (epoch + 1) % 10 == 0:
print(f"Epoch {epoch + 1}/{epochs}, Loss: {loss.item():.4f}")
return model
# Entrenar
data = prepare_embeddings(triplets)
adapter = train_adapter(data)
# Guardar
torch.save(adapter.state_dict(), "medical_adapter.pt")
Un punto operativo que no puedes pasar por alto: el día que despliegues este adaptador, cada vector ya almacenado en tu base de datos debe pasar de nuevo por la proyección; de lo contrario, estarías comparando vectores de dos espacios diferentes. Planifica una reindexación completa del corpus en tu despliegue en producción.
Enfoque 2: Ajuste fino con Sentence Transformers
Cuando el adaptador no es suficiente, necesitas modificar el propio modelo de embeddings, lo que requiere un modelo abierto que alojes tú mismo —aquí BAAI/bge-large-en-v1.5. Sentence Transformers hace esto accesible: describes los ejemplos como pares de texto con una etiqueta continua, donde 1,0 significa «estos dos textos deben estar cerca» y 0,2 significa «parecen superficialmente similares, sepáralos». La CosineSimilarityLoss empuja entonces la similitud del coseno calculada hacia la etiqueta proporcionada.
Tres épocas y cien pasos de calentamiento son valores conservadores, y por buena razón: en un conjunto de datos modesto, entrenar demasiado tiempo destruye el conocimiento general del modelo, haciéndolo excelente en tus ejemplos y mediocre en cualquier otro sitio.
from sentence_transformers import (
SentenceTransformer, InputExample, losses
)
from torch.utils.data import DataLoader
# Cargar un modelo base
model = SentenceTransformer("BAAI/bge-large-en-v1.5")
# Preparar ejemplos de entrenamiento
train_examples = [
InputExample(
texts=["paracetamol side effects",
"Paracetamol can cause liver disorders"],
label=1.0
),
InputExample(
texts=["paracetamol side effects",
"Paracetamol is sold in pharmacies"],
label=0.2
),
]
train_dataloader = DataLoader(train_examples, shuffle=True, batch_size=16)
train_loss = losses.CosineSimilarityLoss(model)
# Entrenar
model.fit(
train_objectives=[(train_dataloader, train_loss)],
epochs=3,
warmup_steps=100,
output_path="./finetuned_medical_model"
)
# Usar el modelo ajustado fino
embeddings = model.encode([
"abdominal pain after taking medication",
"adverse drug effects"
])
Preparación de un conjunto de datos de calidad
Aquí reside el verdadero obstáculo: nadie tiene mil pares anotados a mano. El truco es construirlos a partir de lo que ya tienes, es decir, tus documentos. Envías cada documento al LLM pidiéndole las preguntas que responde con precisión, y obtienes pares pregunta-documento sin ninguna anotación manual. Una temperatura de 0,7 garantiza que las tres preguntas generadas para el mismo documento no sean tres variantes de la misma frase, y lstrip limpia la numeración que el modelo añade espontáneamente.
def generate_training_pairs(
documents: list[str],
n_per_doc: int = 3
) -> list[dict]:
"""Genera pares consulta-documento para el entrenamiento."""
pairs = []
for doc in documents:
response = client.chat.completions.create(
model="gpt-5.6-terra",
messages=[{
"role": "user",
"content": (
f"Here is a document:\n\n{doc[:500]}\n\n"
f"Generate {n_per_doc} questions that this document "
f"answers precisely. One question per line."
)
}],
temperature=0.7
)
questions = response.choices[0].message.content.strip().split("\n")
for q in questions[:n_per_doc]:
q = q.strip().lstrip("0123456789.-) ")
if q:
pairs.append({"query": q, "document": doc})
return pairs
Evaluación del ajuste fino
Entrenar con una pérdida decreciente no demuestra nada: la única pregunta que importa es si la búsqueda ha mejorado. La función siguiente mide la exhaustividad@5 en el mismo conjunto de consultas, con y sin el adaptador, simplemente pasando adapter=None para obtener la línea base. Tanto el corpus como las consultas pasan por la proyección cuando se proporciona, que es la condición para que ambos vectores vivan en el mismo espacio.
Ejecuta siempre esta comparación antes de desplegar. Ocurre con regularidad que un adaptador entrenado con demasiadas pocas tripletas degrada la exhaustividad, y sin medición lanzarías una regresión pensando que lanzabas una mejora.
def evaluate_before_after(
queries: list[str],
relevant_docs: list[list[str]],
corpus: list[str],
adapter=None
):
"""Compara el rendimiento antes y después del ajuste fino."""
resp = client.embeddings.create(
input=corpus, model="text-embedding-3-large"
)
corpus_embs = np.array(
[d.embedding for d in sorted(resp.data, key=lambda x: x.index)]
)
if adapter:
corpus_embs_adapted = adapter(
torch.tensor(corpus_embs, dtype=torch.float32)
).detach().numpy()
else:
corpus_embs_adapted = corpus_embs
recall_scores = []
for query, relevants in zip(queries, relevant_docs):
q_resp = client.embeddings.create(
input=query, model="text-embedding-3-large"
)
q_emb = np.array(q_resp.data[0].embedding)
if adapter:
q_emb = adapter(
torch.tensor(q_emb, dtype=torch.float32).unsqueeze(0)
).detach().numpy()[0]
scores = corpus_embs_adapted @ q_emb
top_5 = set(np.argsort(scores)[-5:])
relevant_ids = set(
i for i, d in enumerate(corpus) if d in relevants
)
recall = len(top_5 & relevant_ids) / len(relevant_ids)
recall_scores.append(recall)
return np.mean(recall_scores)
Resumen
- El ajuste fino de embeddings mejora el rendimiento en dominios especializados.
- Un adaptador lineal es el método más sencillo y a menudo suficiente.
- Sentence Transformers permite un ajuste fino más profundo del modelo completo.
- Se recomienda un mínimo de 1.000 pares anotados.
- Evalúa siempre antes y después para validar la ganancia.