Salt la conținutul principal
Română— Alege o limbă
Meniu

Similaritate Semantică

Lecția 3 din 18 Actualizată 2 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Măsurarea Proximității Textului
  2. Distanța Euclidiană
  3. Similaritatea Cosinus
  4. Matricea de Similaritate
  5. Căutare Semantică Simplă
  6. Prag de Relevanță
  7. Puncte cheie

Măsurarea Proximității Textului

Odată ce ați transformat textele în vectori folosind mistral-embed, puteți cuantifica cât de apropiate semantic sunt două texte. Acesta este nucleul căutării semantice: compararea sensurilor, nu doar a cuvintelor. În timp ce o interogare SQL LIKE '%invoice%' returnează un simplu da sau nu, o metrică de similaritate vă oferă un număr, permițând clasarea. Această clasare este ceea ce face întregul sistem valoros.

În această lecție, veți implementa principalele metrici de similaritate și veți vedea cum funcționează ele în practică prin exemple concrete în Python.

Distanța Euclidiană

Distanța euclidiană măsoară lungimea segmentului dintre două puncte în spațiul vectorial. Cu cât distanța este mai mică, cu atât textele sunt mai similare. Exemplul de mai jos compară trei propoziții: primele două spun același lucru folosind un vocabular diferit, în timp ce a treia discută despre plăcinta cu mere. Propozițiile A și B nu au niciun cuvânt comun, totuși distanța lor va fi semnificativ mai mică decât distanța dintre A și 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

Similaritatea Cosinus

Similaritatea cosinus este metrica cea mai utilizată pentru embeddings. Aceasta măsoară unghiul dintre doi vectori, independent de magnitudinea lor. Rezultatul variază de la -1 la 1, oferind o scară imediat lizibilă: puteți stabili un prag și îl puteți comunica unei echipe de business fără a fi nevoie să explicați normele vectoriale.

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)

Diferența dintre 0,92 și 0,35 reprezintă informația utilă: nu valoarea absolută contează, ci marja care separă rezultatele relevante de cele fără legătură cu subiectul în setul dumneavoastră specific de date. Puteți, de asemenea, să implementați metrica manual, dacă doar pentru a verifica ce face scikit-learn sau pentru a evita dependențele într-un mediu constrâns:

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

Matricea de Similaritate

Pentru a compara mai multe documente între ele, puteți construi o matrice de similaritate. Corpusul de mai jos amestecă intenționat două teme – IA și gastronomia – astfel încât structura să vă sară în ochi: documentele 0, 1 și 3 sunt legate între ele, în timp ce documentele 2 și 4 formează un cluster separat. Acesta este exact semnalul pe care algoritmii de clustering îl exploatează.

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

Căutare Semantică Simplă

Toate cele de mai sus se combină pentru a forma un mini motor de căutare. Interogarea este codificată cu același model ca și corpusul – o condiție non-negociabilă, deoarece două modele diferite produc spații incomparabile – apoi argsort inversează clasarea pentru a aduce cele mai mari scoruri în vârf.

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 de Relevanță

Acest motor are un defect pe care îl veți descoperi rapid în producție: returnează întotdeauna trei rezultate, chiar și atunci când întrebarea nu are nicio legătură cu corpusul. Întrebați-l despre vreme și vă va returna cele trei documente cel mai puțin îndepărtate, cu scoruri derizorii, dar cu o clasare aparent normală. În practică, trebuie deci să definiți un prag de similaritate sub care un document este considerat irelevant:

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)

Luați-vă timp pentru a calibra acest prag pe aproximativ treizeci de interogări reale înainte de a deschide serviciul utilizatorilor. Dacă îl setați prea sus, motorul dumneavoastră va spune „Nu știu“ la întrebări legitime. Dacă îl setați prea jos, veți alimenta LLM-ul cu context irelevant, creând exact halucinațiile pe care RAG trebuia să le prevină.

Puncte cheie

  • Similaritatea cosinus este metrica standard pentru compararea embeddings
  • Utilizați sklearn.metrics.pairwise.cosine_similarity pentru calcule rapide
  • O matrice de similaritate vă permite să comparați toate documentele între ele
  • Definiți un prag de relevanță adaptat cazului dumneavoastră de utilizare (0,7 este un bun implicit)
  • Căutarea semantică găsește rezultate prin sens, nu prin potrivirea exactă a cuvintelor