Файн-тюнинг на ембъдинги
На тази страница
Цели
- Да разберете кога е необходим файн-тюнинг на ембъдинги
- Да подготвите двойки данни за обучение
- Да реализирате файн-тюнинг с леки адаптери
Кога да правите файн-тюнинг?
Нека започнем с лошите новини, които всъщност са добри: в повечето случаи предварително обучените модели за ембъдинги работят перфектно, а файн-тюнингът е загуба на усилия. Само три ситуации наистина го оправдават. Първата е специализирана област с високо специфичен речник – медицина, право, индустрия – където общият модел не знае, че “МИ” и “миокарден инфаркт” означават едно и също нещо. Втората е достигане на плато: оптимизирали сте разделянето на чънкове, добавили сте хибридно търсене и преподреждане (reranking), но метриките не мърдат. Третата е просто наличието на анотирани текстови двойки, подобни или различни, които стоят неизползвани във вашите логове за търсене.
Обратно, пропуснете файн-тюнинга, ако имате по-малко от хиляда анотирани двойки: обучението ще запомни примерите ви, без да обобщи знанията. Пропуснете го и ако производителността вече е задоволителна – повишение с две точки в recall не си струва поддръжката на допълнителен модел. И най-вече, проверете дали по-добро разделяне на чънкове или по-добър промпт няма да решат проблема: почти винаги е по-евтино и по-бързо.
Подход 1: Линеен адаптер (Matryoshka)
Най-икономичният подход оставя модела за ембъдинги непроменен. Позволявате му да генерира своите вектори, след което обучавате малък проекционен слой върху тях, който изкривява пространството, за да сближи онова, което трябва да бъде близо във вашата област. Моделът на OpenAI остава черна кутия, достъпна чрез API; обучават се само няколкостотин хиляди параметъра, на CPU, за минути.
Обучението разчита на триплети: заявка, документ, който ѝ отговаря, и документ, който засяга същата тема, но не отговаря. Разгледайте медицинските примери по-долу – негативният пример за “странични ефекти на парацетамол” не е текст за футбол, а текст за парацетамол, продавани в аптеките. Това се нарича “труден негатив” (hard negative) и именно то учи модела: очевиден негатив не коригира нищо, тъй като общият модел вече го е класифицирал правилно.
import numpy as np
from openai import OpenAI
from sklearn.model_selection import train_test_split
client = OpenAI()
# Dataset of pairs (query, positive_document, negative_document)
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..."
},
# ... more triplets
]
def prepare_embeddings(triplets: list[dict]) -> dict:
"""Generate embeddings for the triplets."""
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],
}
Самият адаптер е двуслойна мрежа, която проектира 3072-те измерения на модела надолу до 256, с финална нормализация, така че изходните вектори да останат сравними чрез косинусова близост. Функцията на загубата е triplet margin loss: тя става нула веднага щом заявката е по-близо до позитивния, отколкото до негативния, с поне марж от 0.2, и наказва пропорционално в противен случай. С други думи, вие учите модела само на онова, което все още не е разбрало, и обучението естествено се стабилизира, след като триплетите са добре разделени.
import torch
import torch.nn as nn
import torch.optim as optim
class EmbeddingAdapter(nn.Module):
"""Projection layer to adapt 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):
"""Triplet margin loss."""
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):
"""Train the adapter on triplets."""
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
# Train
data = prepare_embeddings(triplets)
adapter = train_adapter(data)
# Save
torch.save(adapter.state_dict(), "medical_adapter.pt")
Един оперативен момент, който не бива да пропускате: в деня, в който внедрите този адаптер, всеки вектор, вече съхранен във вашата база данни, трябва да премине отново през проекцията, в противен случай бихте сравнявали вектори от две различни пространства. Планирайте пълно преиндексиране на корпуса при внедряването си в продукция.
Подход 2: Файн-тюнинг със Sentence Transformers
Когато адаптерът не е достатъчен, трябва да модифицирате самия модел за ембъдинги, което изисква отворен модел, който хоствате – тук BAAI/bge-large-en-v1.5. Sentence Transformers прави това достъпно: описвате примерите като текстови двойки с непрекъснат етикет, където 1.0 означава “тези два текста трябва да са близки”, а 0.2 означава “те изглеждат повърхностно сходни, раздалечете ги”. CosineSimilarityLoss след това бута изчислената косинусова близост към предоставения етикет.
Три епохи и сто стъпки за загряване (warmup) са консервативни стойности и с добра причина: при скромен набор от данни, твърде дългото обучение унищожава общите знания на модела, правейки го отличен за вашите примери и посредствен навсякъде другаде.
from sentence_transformers import (
SentenceTransformer, InputExample, losses
)
from torch.utils.data import DataLoader
# Load a base model
model = SentenceTransformer("BAAI/bge-large-en-v1.5")
# Prepare training examples
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)
# Train
model.fit(
train_objectives=[(train_dataloader, train_loss)],
epochs=3,
warmup_steps=100,
output_path="./finetuned_medical_model"
)
# Use the fine-tuned model
embeddings = model.encode([
"abdominal pain after taking medication",
"adverse drug effects"
])
Подготовка на качествен набор от данни
Тук се крие истинското препятствие: никой няма хиляда анотирани двойки, лежащи наоколо. Заобиколният път е да ги построите от онова, което вече имате, а именно вашите документи. Подавате всеки документ на LLM, искайки въпросите, на които той отговаря точно, и получавате двойки въпрос-документ без никакво ръчно анотиране. Температура от 0.7 гарантира, че трите въпроса, генерирани за един и същи документ, не са три варианта на едно и също изречение, а lstrip почиства номерацията, която моделът добавя спонтанно.
def generate_training_pairs(
documents: list[str],
n_per_doc: int = 3
) -> list[dict]:
"""Generate query-document pairs for training."""
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
Оценяване на файн-тюнинга
Обучението с намаляваща загуба не доказва нищо: единственият въпрос, който има значение, е дали търсенето се е подобрило. Функцията по-долу измерва recall@5 върху един и същи набор от заявки, с и без адаптера, просто като предадете adapter=None, за да получите базовата линия. Както корпусът, така и заявките преминават през проекцията, когато тя е предоставена, което е условието и двата вектора да живеят в едно и също пространство.
Винаги изпълнявайте това сравнение преди внедряване. Редовно се случва адаптер, обучен на твърде малко триплети, да влоши recall, и без измерване бихте пуснали регресия, мислейки, че пускате подобрение.
def evaluate_before_after(
queries: list[str],
relevant_docs: list[list[str]],
corpus: list[str],
adapter=None
):
"""Compare performance before and after fine-tuning."""
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)
Ключови изводи
- Файн-тюнингът на ембъдинги подобрява производителността в специализирани области
- Линейният адаптер е най-простият метод и често е достатъчен
- Sentence Transformers позволява по-дълбок файн-тюнинг на целия модел
- Препоръчителен е минимум от 1000 анотирани двойки
- Винаги оценявайте преди и след, за да валидирате ползата