Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Hasonlóság szemantikai értelemben

3. lecke 18 közül Frissítve 2026. november 2. Fejlesztő
Ezen az oldalon
  1. Szövegek közelségének mérése
  2. Euklideszi távolság
  3. Koszinusz-hasonlóság
  4. Hasonlósági mátrix
  5. Egyszerű szemantikai keresés
  6. Relevancia-küszöb
  7. Főbb megállapítások

Szövegek közelségének mérése

Miután a mistral-embed modell segítségével vektorokká alakítottad a szövegeidet, számszerűsítheted, mennyire állnak szemantikai értelemben közel egymáshoz. Ez a szemantikai keresés lényege: a jelentéseket hasonlítjuk össze, nem csupán a szavakat. Míg egy SQL LIKE '%invoice%' lekérdezés egyszerű igen/nem választ ad, egy hasonlósági metrika egy számot szolgáltat, ami lehetővé teszi a rangsorolást. Éppen ez a rangsorolás teszi értékessé az egész rendszert.

Ebben a leckében megvalósítod a főbb hasonlósági metrikákat, és konkrét Python-példákon keresztül megnézed, hogyan működnek a gyakorlatban.

Euklideszi távolság

Az euklideszi távolság a vektortérben lévő két pont közötti szakasz hosszát méri. Minél kisebb a távolság, annál hasonlóbbak a szövegek. Az alábbi példa három mondatot hasonlít össze: az első kettő ugyanazt mondja eltérő szókészlettel, míg a harmadik az almáspitéről szól. Az A és B mondatoknak nincs közös szavuk, mégis a közöttük lévő távolság jelentősen kisebb lesz, mint az A és C közötti.

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

Koszinusz-hasonlóság

A koszinusz-hasonlóság a beágyazások (embeddings) leggyakrabban használt metrikája. Két vektor szögét méri, függetlenül azok nagyságától. Az eredmény -1 és 1 között mozog, ami azonnal értelmezhető skálát biztosít: meghatározhatsz egy küszöbértéket, és közölheted azt az üzleti csapattal anélkül, hogy el kellene magyaráznod a vektornormákat.

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)

A 0,92 és 0,35 közötti különbség a hasznos információ: nem az abszolút érték számít, hanem az a távolság, amely elválasztja a releváns találatokat a témától idegenektől a te saját adathalmazodban. A metrikát manuálisan is megvalósíthatod, akár csak annak ellenőrzésére, mit csinál a scikit-learn, vagy függőségek elkerülésére egy korlátozott környezetben:

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}")

Hasonlósági mátrix

Több dokumentum egymással való összehasonlításához felépíthetsz egy hasonlósági mátrixot. Az alábbi korpusz szándékosan kever két témát – a mesterséges intelligenciát és a gasztronómiát –, így a szerkezet szembetűnő: a 0., 1. és 3. dokumentumok összefüggenek egymással, míg a 2. és 4. dokumentumok egy különálló klasztert alkotnak. Pontosan ezt a jelet használják ki a klaszterező algoritmusok.

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}")

Egyszerű szemantikai keresés

A fentiek mindegye összeáll egy mini keresőmotorrá. A lekérdezést ugyanazzal a modellel kódolod, mint a korpuszt – ez nem tárgyalható feltétel, mivel két különböző modell összehasonlíthatatlan tereket hoz létre –, majd az argsort megfordítja a rangsorolást, hogy a legmagasabb pontszámok kerüljenek felülre.

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']}")

Relevancia-küszöb

Ennek a motornak van egy hibája, amit éles környezetben gyorsan felfedezel: mindig visszaad három találatot, még akkor is, ha a kérdésnek semmi köze a korpuszhoz. Kérdezz rá az időjárásra, és visszaadja a három legkevésbé távoli dokumentumot, nevetségesen alacsony pontszámokkal, de látszólag normális rangsorolással. A gyakorlatban ezért meg kell határoznod egy hasonlósági küszöbértéket, amely alatt egy dokumentumot irrelevánsnak tekintesz:

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)

Szánj időt ennek a küszöbértéknek a kalibrálására körülbelül harminc valós lekérdezésen, mielőtt megnyitnád a szolgáltatást a felhasználók előtt. Ha túl magasra állítod, a motorod azt mondja: „nem tudom“ a jogos kérdésekre is. Ha túl alacsonyra, akkor témától idegen kontextust táplálsz az LLM-be, létrehozva éppen azokat a hallucinációkat, amelyeket a RAG hivatott volt megelőzni.

Főbb megállapítások

  • A koszinusz-hasonlóság a szabványos metrika a beágyazások összehasonlítására
  • Használd a sklearn.metrics.pairwise.cosine_similarity függvényt a gyors számításokhoz
  • A hasonlósági mátrix lehetővé teszi az összes dokumentum egymással való összehasonlítását
  • Határozz meg a használati esetedhez igazított relevancia-küszöböt (a 0,7 jó alapértelmezett érték)
  • A szemantikai keresés jelentés alapján talál találatokat, nem pedig pontos szövegegyezés alapján