Sličnost pomenskih vsebin
Na tej strani
Merjenje bližine besedila
Ko besedila pretvoriš v vektorje z uporabo modela mistral-embed, lahko količinsko opredeliš, kako pomensko blizu si sta dve besedili. To je bistvo pomenskega iskanja: primerjava pomenov, ne le besed. Medtem ko poizvedba SQL LIKE '%račun%' vrne preprost odgovor da ali ne, metrika podobnosti poda številko, ki omogoča razvrščanje. Prav to razvrščanje naredi celoten sistem vrednega.
V tej lekciji boš implementiral glavne metrike podobnosti in videl, kako delujejo v praksi s konkretnimi primeri v Pythonu.
Evklidska razdalja
Evklidska razdalja meri dolžino daljice med dvema točkama v vektorskem prostoru. Manjša kot je razdalja, bolj podobni sta besedili. Spodnji primer primerja tri stavke: prva dva pravita isto stvar z uporabo drugačnega besedišča, tretji pa govori o jabolčni piti. Stavka A in B nimata skupnih besed, vendar bo njuna razdalja znatno manjša od razdalje med A in C.
import numpy as np
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
def get_embedding(text):
"""Get the embedding for a text via mistral-embed."""
response = client.embeddings.create(
model="mistral-embed",
inputs=[text],
)
return np.array(response.data[0].embedding)
# Three sentences to compare
phrase_a = "Machine learning transforms data into predictions."
phrase_b = "Automatic learning converts data into results."
phrase_c = "The recipe for apple pie is simple."
emb_a = get_embedding(phrase_a)
emb_b = get_embedding(phrase_b)
emb_c = get_embedding(phrase_c)
# Euclidean distances
dist_ab = np.linalg.norm(emb_a - emb_b)
dist_ac = np.linalg.norm(emb_a - emb_c)
print(f"Distance A-B (semantically close): {dist_ab:.4f}")
print(f"Distance A-C (semantically distant): {dist_ac:.4f}")
# A-B will be significantly lower than A-C
Kosinusna podobnost
Kosinusna podobnost je najpogosteje uporabljena metrika za vdelave. Meri kot med dvema vektorjema, neodvisno od njune velikosti. Rezultat se giblje med -1 in 1, kar zagotavlja takoj razumljivo lestvico: lahko določiš prag in ga sporočiš poslovni ekipi, ne da bi moral razlagati norme vektorjev.
from sklearn.metrics.pairwise import cosine_similarity
# With scikit-learn
sim_ab = cosine_similarity([emb_a], [emb_b])[0][0]
sim_ac = cosine_similarity([emb_a], [emb_c])[0][0]
print(f"Cosine similarity A-B: {sim_ab:.4f}") # ~0.92 (very close)
print(f"Cosine similarity A-C: {sim_ac:.4f}") # ~0.35 (distant)
Razlika med 0,92 in 0,35 je koristna informacija: ni pomembna absolutna vrednost, temveč razmik, ki ločuje ustrezne rezultate od tistih, ki niso relevantni za tvojo specifično zbirko podatkov. Metriko lahko implementiraš tudi ročno, če že samo zato, da preveriš, kaj počne scikit-learn, ali da se izogneš odvisnostim v omejenem okolju:
def cosine_sim(vec_a, vec_b):
"""Manual cosine similarity."""
dot = np.dot(vec_a, vec_b)
norm_a = np.linalg.norm(vec_a)
norm_b = np.linalg.norm(vec_b)
return dot / (norm_a * norm_b)
print(f"Manual verification A-B: {cosine_sim(emb_a, emb_b):.4f}")
Matrika podobnosti
Za medsebojno primerjavo več dokumentov lahko sestaviš matriko podobnosti. Spodnji korpus namerno meša dve temi – umetno inteligenco in gastronomijo –, tako da ti struktura takoj skoči v oči: dokumenti 0, 1 in 3 so med seboj povezani, medtem ko dokumenta 2 in 4 tvorita ločen grozd. To je točno tisti signal, ki ga izkoriščajo algoritmi za gručenje.
from sklearn.metrics.pairwise import cosine_similarity
documents = [
"Mistral AI develops language models.",
"LLMs generate text from prompts.",
"French cuisine is renowned worldwide.",
"NLP is a branch of artificial intelligence.",
"Croissants taste best in the morning.",
]
# Encode all documents
response = client.embeddings.create(
model="mistral-embed",
inputs=documents,
)
embeddings = np.array([d.embedding for d in response.data])
# Similarity matrix (5x5)
sim_matrix = cosine_similarity(embeddings)
print("Similarity Matrix:")
for i, doc in enumerate(documents):
for j, doc2 in enumerate(documents):
if j > i:
print(f" [{i}]-[{j}]: {sim_matrix[i][j]:.3f}")
Preprosto pomensko iskanje
Vse zgoraj navedeno se združi v mini iskalnik. Poizvedba se kodira z istim modelom kot korpus – to je nepogrešljiv pogoj, saj dva različna modela proizvajata neprimerljiva prostora –, nato pa argsort obrne razvrščanje, da najvišje rezultate postavi na vrh.
def recherche_semantique(query, documents, embeddings, top_k=3):
"""Finds the most relevant documents for a query."""
# Encode the query
query_response = client.embeddings.create(
model="mistral-embed",
inputs=[query],
)
query_embedding = np.array(query_response.data[0].embedding)
# Calculate similarities
similarities = cosine_similarity(
[query_embedding], embeddings
)[0]
# Sort by descending similarity
ranked_indices = np.argsort(similarities)[::-1][:top_k]
results = []
for idx in ranked_indices:
results.append({
"document": documents[idx],
"score": similarities[idx],
"index": int(idx),
})
return results
# Usage example
query = "How does Mistral's AI work?"
results = recherche_semantique(query, documents, embeddings)
for r in results:
print(f" Score: {r['score']:.3f} -- {r['document']}")
Prag relevantnosti
Ta iskalnik ima napako, ki jo boš v proizvodnem okolju hitro odkril: vedno vrne tri rezultate, tudi če vprašanje nima nobene zveze s korpusom. Vprašaj ga o vremenu in vrnil bo tri najmanj oddaljene dokumente z smešno nizkimi rezultati, a navidezno normalnim razvrščanjem. V praksi moraš zato določiti prag podobnosti, pod katerim se dokument šteje za nerelevantnega:
SEUIL_PERTINENCE = 0.7
def recherche_avec_seuil(query, documents, embeddings, seuil=SEUIL_PERTINENCE):
"""Search with filtering by relevance threshold."""
results = recherche_semantique(query, documents, embeddings, top_k=len(documents))
return [r for r in results if r["score"] >= seuil]
# A threshold of 0.7 is a good starting point
# Adjust based on your use case:
# - 0.8+: very strict (few results, high relevance)
# - 0.6-0.7: balanced
# - 0.5: permissive (many results, variable relevance)
Vzemi si čas za umerjanje tega praga na približno tridesetih realnih poizvedbah, preden storitev odpreš uporabnikom. Če ga nastaviš previsoko, bo tvoj iskalnik na legitimna vprašanja odgovarjal z „ne vem”. Če ga nastaviš prenizko, boš LLM hranil z nerelevantnim kontekstom in s tem ustvarjal prav tiste halucinacije, ki naj bi jih RAG preprečil.
Ključne ugotovitve
- Kosinusna podobnost je standardna metrika za primerjavo vdelav
- Za hitre izračune uporabi
sklearn.metrics.pairwise.cosine_similarity - Matrika podobnosti omogoča medsebojno primerjavo vseh dokumentov
- Določi prag relevantnosti, prilagojen tvoji uporabi (0,7 je dobra privzeta vrednost)
- Pomensko iskanje najde rezultate po pomenu, ne po natančnem ujemanju besed