Kurti įterpinius (Embeddings)
Šiame puslapyje
Koduok fragmentus į vektorius
Tavo dokumentai dabar suskaidyti į švarius fragmentus. Kitas žingsnis – paversti juos įterpiniais (embeddings) naudojant mistral-embed API, o tada saugoti šiuos vektorius vektorių duomenų bazėje, kuri veiks kaip tavo paieškos variklis. Būtent šiuo metu tavo tekstynas nustoja būti paprastu tekstu ir tampa užklausoms pritaikyta geometrija. Keletas inžinerinių atsargumo priemonių – grupavimas, pakartotiniai bandymai ir išsaugojimas – lemia skirtumą tarp trapaus prototipo ir patikimo indekso.
Nedideliam tekstynui, tarkime, mažiau nei šimtui fragmentų, pakanka vieno tiesioginio kvietimo. Ištrauk tekstą iš savo fragmentų žodynų, perduok jį API tokį, koks yra, ir gauk visą matricą. Vykdymo pabaigoje rodoma forma (87, 1024) yra tavo pirmoji sveikatos patikra: eilučių skaičius turi sutapti su fragmentų skaičiumi, o stulpelių – 1024, nes tokia yra mistral-embed dimensija. Jei eilučių skaičius nesutampa, į grupę pateko tuščias fragmentas.
import numpy as np
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
# Assume chunks is the list of our prepared chunks
chunk_texts = [c["text"] for c in chunks]
# Encode in a single call
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) for example
Grupinis kodavimas
Viršijus kelias dešimtis fragmentų, vienas kvietimas pasiekia API ribas. Sprendimas – padalinti sąrašą į grupes ir sujungti rezultatus. Toliau pateikta funkcija apdoroja 25 elementų dalis ir rodo eigą. Tai ne kosmetinis pakeitimas: apdorojant kelių tūkstančių fragmentų tekstyną, kodavimas trunka kelias minutes, ir norėsi žinoti, kurioje vietoje procesas yra, užuot žiūrėjęs į tylų terminalą. Tvarka išsaugoma, todėl kiekvienas vektorius lieka suderintas su atitinkamu fragmentu pradiniame sąraše.
def encode_chunks(chunks, batch_size=25, model="mistral-embed"):
"""Encode a list of chunks in batches."""
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" Encoding batch {i // batch_size + 1}/{(len(texts) - 1) // batch_size + 1} "
f"({len(batch)} chunks)...")
response = client.embeddings.create(
model=model,
inputs=batch,
)
all_embeddings.extend([d.embedding for d in response.data])
return np.array(all_embeddings)
# Encode all chunks
embeddings = encode_chunks(chunks, batch_size=25)
print(f"Total: {embeddings.shape[0]} vectors of {embeddings.shape[1]} dimensions")
Atsparumas tinklo klaidoms
Gamybinėje aplinkoje API kvietimas anksčiau ar vėliau nepavyks: nutrūks ryšys, bus pasiekta užklausų riba arba įvyks laikinas sutrikimas. Be apsaugos, tavo indeksavimas sustos ties 180 grupe iš 400, ir vėl grįši prie pradžių. Patikima versija kiekvieną grupę apgaubia pakartotinių bandymų ciklu su eksponentiniu delsos didinimu – viena sekundė, tada dvi, tada keturios. Šis didėjantis intervalas yra svarbus: bandymas iškart po kvotos atmetimo tik pablogins situaciją. Po trijų nesėkmingų bandymų iš eilės funkcija išmeta aiškią išimtį, nurodančią klaidingą grupę, užuot grąžinusi sutrumpintą matricą, kurios trūkumą pastebėtum tik paieškos metu.
import time
def encode_chunks_robust(chunks, batch_size=25, max_retries=3):
"""Robust encoding with error handling."""
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 # Success, exit retry loop
except Exception as e:
wait_time = 2 ** attempt # Exponential backoff: 1s, 2s, 4s
print(f" Error in batch {i // batch_size + 1}, "
f"attempt {attempt + 1}/{max_retries}: {e}")
if attempt < max_retries - 1:
print(f" Waiting {wait_time}s before retry...")
time.sleep(wait_time)
else:
raise RuntimeError(
f"Failed after {max_retries} attempts for batch {i // batch_size + 1}"
)
return np.array(all_embeddings)
Išsaugok indeksą diske
Kiekvienas kodavimo vykdymas kainuoja laiką ir apmokamus API kvietimus. Vektorių perskaičiavimas kiekvieną kartą paleidus programą yra grynas švaistymas, ypač kai pats tekstynas nepakito. Išsaugojimas vyksta dviem papildomais failais: vektoriai saugomi „NumPy“ formatu – kompaktiškame dvejetainiame formate, kuris įkeliamas akimirksniu, o metaduomenys – tekstas, šaltinis, pozicija – saugomi skaitomame JSON faile, kurį gali atidaryti ir patikrinti įtartiną fragmentą. Šie du failai yra tarpusavyje priklausomi, susieti eilučių tvarka: niekada nepergeneruok vieno be kito, kitaip paieškos rezultatai nukreips į neteisingus tekstus.
import json
def save_index(chunks, embeddings, filepath="rag_index"):
"""Save chunks and embeddings."""
# Save embeddings (NumPy)
np.save(f"{filepath}_embeddings.npy", embeddings)
# Save metadata (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"Index saved: {len(chunks)} chunks, {embeddings.shape}")
def load_index(filepath="rag_index"):
"""Load chunks and embeddings from disk."""
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"Index loaded: {len(metadata)} chunks, {embeddings.shape}")
return metadata, embeddings
# Save
save_index(chunks, embeddings)
# Load (on next startup)
chunks_loaded, embeddings_loaded = load_index()
Patikrink prieš tęsdamas
Tyliu būdu sugadintas indeksas paaiškėja vėlai, paprastai tada, kai vartotojas praneša apie absurdišką atsakymą. Keli neprisijungus atliekami patikrinimai trunka trisdešimt sekundžių ir apsaugo nuo tokio atradimo. Tikrinimo funkcija pirmiausia parodo pagrindinius rodiklius – fragmentų skaičių, dimensiją, vidutinę normą – tada išmatuoja gretimų fragmentų panašumą: kadangi jie kilę iš to paties dokumento, jų reikšmės turėtų būti žymiai didesnės nei dviejų atsitiktinių ištraukų. Paskutinis testas yra paprasčiausias ir labiausiai atskleidžiantis: fragmentas, lyginamas su savimi, privalo duoti tiksliai 1,0. Bet kokia kita reikšmė signalizuoja apie suderinimo problemą arba skaitinio konvertavimo klaidą.
from sklearn.metrics.pairwise import cosine_similarity
def verify_embeddings(chunks, embeddings, n_tests=5):
"""Verify embedding quality with simple tests."""
print("=== Verifying embeddings ===")
print(f"Number of chunks: {len(chunks)}")
print(f"Dimensions: {embeddings.shape[1]}")
print(f"Average norm: {np.linalg.norm(embeddings, axis=1).mean():.4f}")
# Test: chunks from the same document should be closer
for i in range(min(n_tests, len(chunks) - 1)):
sim = cosine_similarity([embeddings[i]], [embeddings[i + 1]])[0][0]
print(f" Similarity chunk {i} <-> {i+1}: {sim:.4f}")
# Test: a chunk compared to itself = 1.0
self_sim = cosine_similarity([embeddings[0]], [embeddings[0]])[0][0]
print(f" Self-similarity (must be 1.0): {self_sim:.6f}")
verify_embeddings(chunks, embeddings)
Sujungus viską, darbo eiga sutrumpėja iki keturių naudingų eilučių. Paruoši fragmentus naudodamas ankstesnės pamokos metodiką, koduoji patikimu režimu, patikrini ir išsaugai. Tai scenarijus, kurį paleisi iš naujo kiekvieną kartą, kai tekstynas bus atnaujintas.
# 1. Prepare chunks (previous lesson)
chunks = prepare_documents(raw_docs)
# 2. Encode
embeddings = encode_chunks_robust(chunks, batch_size=25)
# 3. Verify
verify_embeddings(chunks, embeddings)
# 4. Save
save_index(chunks, embeddings)
print("Index ready for search!")
Svarbiausi punktai
- Naudok grupavimą dideliems tekstynams koduoti (25–50 fragmentų grupės)
- pridėk pakartotinių bandymų logiką su eksponentiniu delsos didinimu patikimumui užtikrinti
- Išsaugok įterpinius diske („NumPy“), kad išvengtum perskaičiavimo
- Metaduomenis (tekstą, šaltinį, poziciją) laikyk atskirame JSON faile
- Prieš naudodamas gamyboje, patikrink įterpinių kokybę