Izveidot iegulšanas (embeddings)
Šajā lapā
Kodēt fragmentus vektoros
Tavi dokumenti tagad ir sadalīti tīros fragmentos. Nākamais solis ir pārveidot tos par iegulšanām (embeddings), izmantojot mistral-embed API, un saglabāt šos vektorus vektoru krātuvē, kas kalpos kā tava meklētājprogramma. Šajā brīdī tavs korpuss pārstāj būt vienkāršs teksts un kļūst par vaicājamu ģeometriju. Daži inženiertehniski piesardzības pasākumi — partiju apstrāde, atkārtoti mēģinājumi un noturība — nosaka atšķirību starp trauslu prototipu un uzticamu indeksu.
Nelielam korpusam, piemēram, mazāk nekā simts fragmenti, pietiek ar vienu tiešu izsaukumu. Izvelc tekstu no savu fragmentu vārdnīcām, nodod tos API tādu, kāds tas ir, un saņem pilnu matricu. Forma (87, 1024), kas parādās izpildes beigās, ir tava pirmā veselības pārbaude: tikpat daudz rindu, cik fragmentu, un 1024 kolonnas, jo tāda ir mistral-embed dimensija. Ja rindu skaits nesakrīt, partijā ir iekļuvusi tukša fragmenta ieraksts.
import numpy as np
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
# Pieņemam, ka chunks ir mūsu sagatavoto fragmentu saraksts
chunk_texts = [c["text"] for c in chunks]
# Kodējam vienā izsaukumā
response = client.embeddings.create(
model="mistral-embed",
inputs=chunk_texts,
)
embeddings = np.array([d.embedding for d in response.data])
print(f"Embeddings: {embeddings.shape}")
# Embeddings: (87, 1024) piemēram
Kodēšana pa partijām
Pārsniedzot dažus desmitus fragmentu, viens izsaukums sasniedz API limitus. Risinājums ir sadalīt sarakstu partijās un apvienot rezultātus. Tālāk redzamā funkcija apstrādā 25 elementu griezumus un parāda progresu. Tas nav tikai kosmetisks uzlabojums: korpusam ar vairākiem tūkstošiem fragmentu kodēšana ilgst vairākas minūtes, un tu vēlēsies zināt, kurā brīdī process atrodas, nevis skatīties uz klusu termināli. Secība tiek saglabāta, tāpēc katrs vektors paliek sinhronizēts ar atbilstošo fragmentu sākotnējā sarakstā.
def encode_chunks(chunks, batch_size=25, model="mistral-embed"):
"""Kodē fragmentu sarakstu pa partijām."""
texts = [c["text"] for c in chunks]
all_embeddings = []
for i in range(0, len(texts), batch_size):
batch = texts[i:i + batch_size]
print(f" Kodē partiju {i // batch_size + 1}/{(len(texts) - 1) // batch_size + 1} "
f"({len(batch)} fragmenti)...")
response = client.embeddings.create(
model=model,
inputs=batch,
)
all_embeddings.extend([d.embedding for d in response.data])
return np.array(all_embeddings)
# Kodē visus fragmentus
embeddings = encode_chunks(chunks, batch_size=25)
print(f"Kopā: {embeddings.shape[0]} vektori ar {embeddings.shape[1]} dimensijām")
Pārdzīvo tīkla kļūdas
Produkcijas vidē API izsaukums agrāk vai vēlāk neizdosies: tīkla pārtraukums, sasniegts ātruma limits vai īslaicīgs pārtraukums. Bez aizsardzības tava indeksēšana apstāsies pie 180. partijas no 400, un tu būsi atgriezies sākumpunktā. Noturīgā versija ietver katru partiju atkārtotu mēģinājumu ciklā ar eksponenciālu atkāpšanos (exponential backoff) — viena sekunde, tad divas, tad četras. Šis pieaugošais intervāls ir svarīgs: atkārtots mēģinājums tūlīt pēc kvotas noraidījuma situāciju tikai pasliktina. Pēc trim secīgām neveiksmēm funkcija izraisa skaidru izņēmumu, norādot kļūdaino partiju, nevis atgriež saīsinātu matricu, kurā plaisu pamanītu tikai meklēšanas laikā.
import time
def encode_chunks_robust(chunks, batch_size=25, max_retries=3):
"""Noturīga kodēšana ar kļūdu apstrādi."""
texts = [c["text"] for c in chunks]
all_embeddings = []
for i in range(0, len(texts), batch_size):
batch = texts[i:i + batch_size]
for attempt in range(max_retries):
try:
response = client.embeddings.create(
model="mistral-embed",
inputs=batch,
)
all_embeddings.extend([d.embedding for d in response.data])
break # Veiksmīgi, iziet no atkārtotu mēģinājumu cikla
except Exception as e:
wait_time = 2 ** attempt # Eksponenciāla atkāpšanās: 1s, 2s, 4s
print(f" Kļūda partijā {i // batch_size + 1}, "
f"mēģinājums {attempt + 1}/{max_retries}: {e}")
if attempt < max_retries - 1:
print(f" Gaidu {wait_time}s pirms atkārtota mēģinājuma...")
time.sleep(wait_time)
else:
raise RuntimeError(
f"Neizdevās pēc {max_retries} mēģinājumiem partijai {i // batch_size + 1}"
)
return np.array(all_embeddings)
Saglabā indeksu diskā
Katra kodēšanas reize prasa laiku un maksā par API izsaukumiem. Vektoru pārrēķināšana katrā lietotnes startēšanas reizē ir tīrs izšķērdējums, it īpaši tāpēc, ka pats korpuss nav mainījies. Saglabāšana notiek divos papildinošos failos: vektori nonāk NumPy formātā — kompaktā binārā formātā, kas ielādējas acumirklī, bet metadati — teksts, avots, pozīcija — nonāk lasāmā JSON failā, ko vari atvērt, lai pārbaudītu aizdomīgu fragmentu. Abi faili ir savstarpēji atkarīgi un saistīti pēc rindu secības: nekad ģenerē vienu no tiem bez otra, citādi tavi meklēšanas rezultāti norādīs uz nepareiziem tekstiem.
import json
def save_index(chunks, embeddings, filepath="rag_index"):
"""Saglabā fragmentus un iegulšanas."""
# Saglabā iegulšanas (NumPy)
np.save(f"{filepath}_embeddings.npy", embeddings)
# Saglabā metadatus (JSON)
metadata = []
for c in chunks:
metadata.append({
"text": c["text"],
"source": c.get("source", ""),
"chunk_index": c.get("chunk_index", 0),
})
with open(f"{filepath}_metadata.json", "w", encoding="utf-8") as f:
json.dump(metadata, f, ensure_ascii=False, indent=2)
print(f"Indekss saglabāts: {len(chunks)} fragmenti, {embeddings.shape}")
def load_index(filepath="rag_index"):
"""Ielādē fragmentus un iegulšanas no diska."""
embeddings = np.load(f"{filepath}_embeddings.npy")
with open(f"{filepath}_metadata.json", "r", encoding="utf-8") as f:
metadata = json.load(f)
print(f"Indekss ielādēts: {len(metadata)} fragmenti, {embeddings.shape}")
return metadata, embeddings
# Saglabā
save_index(chunks, embeddings)
# Ielādē (nākamajā startēšanas reizē)
chunks_loaded, embeddings_loaded = load_index()
Pārbaudi pirms turpināšanas
Klusībā bojāts indekss atklājas vēlu, parasti tad, kad lietotājs ziņo par absurdu atbildi. Dažas bezsaistes pārbaudes aizņem trīsdesmit sekundes un pasargā tevi no šāda atklājuma. Pārbaudes funkcija vispirms parāda pamatrādītājus — fragmentu skaitu, dimensiju, vidējo normu — tad mēra līdzību starp blakus esošajiem fragmentiem: tā kā tie nāk no viena un tā paša dokumenta, tiem jāuzrāda ievērojami augstākas vērtības nekā diviem nejaušiem tekstiem. Pēdējais tests ir vienkāršākais un visatklāsmīgākais: fragments, salīdzināts pats ar sevi, ir jāsniedz precīzi 1,0. Jebkura cita vērtība liecina par sinhronizācijas problēmu vai skaitlisku konvertēšanas kļūdu.
from sklearn.metrics.pairwise import cosine_similarity
def verify_embeddings(chunks, embeddings, n_tests=5):
"""Pārbauda iegulšanu kvalitāti ar vienkāršiem testiem."""
print("=== Pārbauda iegulšanas ===")
print(f"Fragmentu skaits: {len(chunks)}")
print(f"Dimensijas: {embeddings.shape[1]}")
print(f"Vidējā norma: {np.linalg.norm(embeddings, axis=1).mean():.4f}")
# Tests: viena dokumenta fragmentiem jābūt tuvākiem
for i in range(min(n_tests, len(chunks) - 1)):
sim = cosine_similarity([embeddings[i]], [embeddings[i + 1]])[0][0]
print(f" Līdzība fragments {i} <-> {i+1}: {sim:.4f}")
# Tests: fragments salīdzināts pats ar sevi = 1.0
self_sim = cosine_similarity([embeddings[0]], [embeddings[0]])[0][0]
print(f" Pašlīdzībai jābūt 1.0: {self_sim:.6f}")
verify_embeddings(chunks, embeddings)
Apvienojot visu kopā, darbplūsma reducējas līdz četrām noderīgām rindām. Tu sagatavo fragmentus ar iepriekšējās nodarbības cauruļvadu, kodē noturīgā režīmā, pārbaudi un saglabā. Šis ir skripts, ko palaidīsi atkārtoti ikreiz, kad korpuss tiek atjaunināts.
# 1. Sagatavo fragmentus (iepriekšējā nodarbība)
chunks = prepare_documents(raw_docs)
# 2. Kodē
embeddings = encode_chunks_robust(chunks, batch_size=25)
# 3. Pārbaudi
verify_embeddings(chunks, embeddings)
# 4. Saglabā
save_index(chunks, embeddings)
print("Indekss gatavs meklēšanai!")
Galvenās atziņas
- Izmanto partiju apstrādi, lai kodētu lielus korpusus (partijas pa 25–50 fragmentiem)
- Pievieno atkārtotu mēģinājumu loģiku ar eksponenciālu atkāpšanos noturībai
- Saglabā iegulšanas diskā (NumPy), lai izvairītos no pārrēķināšanas
- Uzglabā metadatus (teksts, avots, pozīcija) atsevišķā JSON failā
- Pārbaudi iegulšanu kvalitāti pirms to izmantošanas produkcijā