Semantisk lighed
På denne side
Måling af tekstnærhed
Når du har transformeret dine tekster til vektorer ved hjælp af mistral-embed, kan du kvantificere, hvor semantisk tæt to tekster er på hinanden. Dette er kernen i semantisk søgning: at sammenligne betydninger, ikke blot ord. Mens en SQL-forespørgsel som LIKE '%faktura%' kun returnerer et simpelt ja eller nej, giver en lighedsmetrik dig et tal, hvilket muliggør rangering. Det er denne rangering, der gør hele systemet værdifuldt.
I denne lektion implementerer du de vigtigste lighedsmetriker og ser, hvordan de fungerer i praksis med konkrete Python-eksempler.
Euklidisk afstand
Euklidisk afstand måler længden af linjestykket mellem to punkter i vektorrummet. Jo mindre afstanden er, desto mere ens er teksterne. Eksemplet nedenfor sammenligner tre sætninger: de to første siger det samme med forskelligt ordforråd, mens den tredje handler om æbletærte. Sætning A og B har ingen fælles ord, alligevel vil afstanden mellem dem være betydeligt mindre end afstanden mellem A og 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
Cosinuslighed
Cosinuslighed er den mest anvendte metrik til indlejringer. Den måler vinklen mellem to vektorer uafhængigt af deres størrelse. Resultatet varierer fra -1 til 1, hvilket giver en umiddelbart læsbar skala: du kan fastsætte en tærskelværdi og kommunikere den til en forretningsteam uden at skulle forklare vektornormer.
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)
Forskellen mellem 0,92 og 0,35 er den nyttige information: det er ikke den absolutte værdi, der betyder noget, men margenen, der adskiller relevante resultater fra emnefremmede i dit specifikke datasæt. Du kan også implementere metrikken manuelt, hvis ikke andet så for at verificere, hvad scikit-learn laver, eller for at undgå afhængigheder i et begrænset miljø:
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}")
Lighedsmatrix
For at sammenligne flere dokumenter indbyrdes kan du opbygge en lighedsmatrix. Korpusset nedenfor blander bevidst to temaer – AI og gastronomi – så strukturen springer i øjnene: dokument 0, 1 og 3 relaterer til hinanden, mens dokument 2 og 4 danner en separat klynge. Dette er præcis det signal, som klyngedannelsesalgoritmer udnytter.
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}")
Simpel semantisk søgning
Alt ovenstående kombineres til en mini-søgemaskine. Forespørgslen kodificeres med samme model som korpusset – en ikke-forhandlingsbar betingelse, da to forskellige modeller producerer u sammenlignelige rum – hvorefter argsort vender rangeringen om for at bringe de højeste scoringer øverst.
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']}")
Relevanstærskel
Denne motor har en fejl, du hurtigt vil opdage i produktion: den returnerer altid tre resultater, selv når spørgsmålet intet har at gøre med korpusset. Spørger du om vejret, vil den returnere de tre mindst fjerne dokumenter med latterlige scoringer, men en tilsyneladende normal rangering. I praksis skal du derfor definere en lighedstærskel, under hvilken et dokument betragtes som irrelevant:
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)
Tag dig tid til at kalibrere denne tærskel på omkring tredive rigtige forespørgsler, før du åbner tjenesten for brugere. Sætter du den for højt, vil din motor sige „jeg ved det ikke” til legitime spørgsmål. Sætter du den for lavt, fodrer du LLM’en med emnefremmed kontekst og skaber netop de hallucinationer, som RAG skulle forhindre.
Vigtige pointer
- Cosinuslighed er standardmetrikken til sammenligning af indlejringer
- Brug
sklearn.metrics.pairwise.cosine_similaritytil hurtige beregninger - En lighedsmatrix giver dig mulighed for at sammenligne alle dokumenter indbyrdes
- Definer en relevanstærskel tilpasset dit brugstilfælde (0,7 er en god standardværdi)
- Semantisk søgning finder resultater baseret på betydning, ikke på eksakt ordmatchning