Cruthaigh Leabaithe
Ar an leathanach seo
Cuir Píosaí in Ionchódú mar Veicteoirí
Tá do chuid doiciméad roinnte anois ina bpíosaí glana. Is é an chéad chéim eile ná iad a thiontú ina leabaithe (embeddings) trí úsáid a bhaint as an API mistral-embed, agus ansin na veicteoirí sin a stóráil i siopa veicteoireachta a fheidhmeoidh mar d’innill chuardaigh. Seo an nóiméad a stopann do chorpas bheith ina ghnáth-théacs agus a éiríonn sé ina gheoiméadracht inchuardaithe. Déanann cúpla réamhchúram innealtóireachta—baisceáil, iarratais athfhillteacha, agus marthanacht—an difríocht idir fréamhshamhail bhog agus innéacs iontaofa.
I gcás corpais bheag, abair faoi chéad píosa, is leor glao amháin díreach. Bain an téacs as do fhoclóirí píosaí, cuir chuig an API iad mar atá siad, agus faigh an maitrís iomlán. Is é an chruth (87, 1024) a thaispeántar ag deireadh an fhorghníomhaithe do chéad seiceáil sláinte: oiread róanna agus atá píosaí ann, agus 1024 colún toisc gurb é sin toise mistral-embed. Mura n-oireann líon na rónna, shleamhnaigh píosa folamh isteach sa bhaisc.
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
Ionchódú i mBaisceanna
Thar roinnt dosaen píosa, buaileann glao amháin teorainneacha an API. Is é an réiteach ná an liosta a roinnt ina bhaisceanna agus na torthaí a chumasc. Déanann an fheidhm thíos slisní de 25 a phróiseáil agus taispeánann sí an dul chun cinn. Ní cosmaideach é seo: ar chorpas de roinnt mílte píosa, tógann an t-ionchódú roinnt nóiméad, agus ba mhaith leat a bheith ar an eolas faoin áit a bhfuil an próiseas seachas bheith ag breathnú ar theirminéal tostach. Coinnítear an t-ord, mar sin fanann gach veicteoir ailínithe lena phíosa comhfhreagrach sa liosta bunaidh agat.
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")
Teacht Slán ar Earráidí Líonra
Sa táirgeadh, teipfidh ar ghlao API faoi dheireadh: titim líonra, srian ráta buailte, nó briseadh sealadach. Gan cosaint, stopann d’innéacsú ag baisc 180 as 400, agus tá tú ar ais ag an tús. Cuireann an leagan láidir lúb athiarrtha timpeall gach baisce le cúlú easpónantúil—soicind amháin, ansin dhá cheann, ansin ceathair. Tá tábhacht leis an spásáil mhéadaitheach seo: ní dhéanann athiarracht láithreach tar éis diúltú cuóta ach rudaí a dhéanamh níos measa. Tar éis trí theip as a chéile, ardaíonn an fheidhm eisceacht shainráite a ainmníonn an baisc lochtach, seachas maitrís ghiorraithe a thabhairt ar ais nach bhfaighfeá an bhearna inti ach le linn cuardaigh.
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)
Sábháil an tInnéacs ar an Diosca
Costaíonn gach rith ionchódaithe am agus glaochanna API íoctha. Is dramhaíl íomlán é veicteoirí a ríomh arís gach uair a thosaíonn d’iarratas, go háirithe ós rud é nach bhfuil athrú tagtha ar an gcorpas féin. Tarlaíonn an tsábháil i dhá chomhad chomhlántacha: téann veicteoirí isteach i NumPy, formáid dhénártha dlúth a lódálann láithreach, agus téann meiteashonraí—téacs, foinse, suíomh—isteach i JSON inléite is féidir leat a oscailt chun píosa amhrasach a scrúdú. Tá an dá chomhad spleách ar a chéile, nasctha de réir ord na líne: ná gineann ceann ar bith acu arís gan an ceann eile, nó léireoidh do thorthaí cuardaigh ar na téacsanna míchearta.
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()
Fíoraigh Sula Leanfaidh Tú Ar Aghaidh
Nochtar innéacs truaillithe go ciúin go déanach, de ghnáth nuair a thuairiscíonn úsáideoir freagra absurd. Tógann cúpla seiceáil as líne tríocha soicind agus sábhálann siad ón nochtadh sin tú. Taispeánann an fheidhm fíoraithe ar dtús méadrachtaí bunúsacha—líon na bpíosaí, toise, meán-norm—ansin tomhaiseann sí cosúlacht idir píosaí comharsanacha: ós rud é go dtagann siad ón doiciméad céanna, ba chóir luachanna i bhfad níos airde a thaispeáint acu ná mar a bheadh ag dhá phas randamacha. Is é an tástáil dheireanach an ceann is simplí agus is nochtaithe: caithfidh píosa a chuirtear i gcomparáid leis féin toradh 1.0 a thabhairt go beacht. Léiríonn aon luach eile fadhb ailínithe nó fadhb tiontaithe uimhriúil.
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)
Nuair a chuirtear le chéile iad, tagann an sruth oibre síos go ceithre líne úsáideacha. Ullmhaíonn tú píosaí leis an bpíblíne ón gcacht roimhe seo, déanann tú ionchódú sa mhód láidir, fíoraíonn tú, agus sábhálann tú. Seo an script a rithfidh tú arís gach uair a nuashonraítear an corpas.
# 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!")
Príomhphointí
- Úsáid baisceáil chun corpais mhóra a ionchódú (baisceanna de 25–50 píosa)
- Cuir loighic athiarrtha le cúlú easpónantúil leis chun marthanacht a chinntiú
- Sábháil leabaithe ar an diosca (NumPy) chun ríomh arís a sheachaint
- Coinnigh meiteashonraí (téacs, foinse, suíomh) i gcomhad JSON ar leith
- Fíoraigh cáilíocht na leabaithe sula n-úsáideann tú iad sa táirgeadh