Somiglianza Semantica
In questa pagina
Misurare la Prossimità del Testo
Una volta trasformati i tuoi testi in vettori utilizzando mistral-embed, puoi quantificare quanto due testi siano semanticamente vicini. Questo è il cuore della ricerca semantica: confrontare i significati, non solo le parole. Mentre una query SQL LIKE '%invoice%' restituisce un semplice sì o no, una metrica di similarità ti fornisce un numero, abilitando il ranking. È proprio questo ranking a rendere prezioso l’intero sistema.
In questa lezione, implementerai le principali metriche di similarità e vedrai come funzionano nella pratica con esempi concreti in Python.
Distanza Euclidea
La distanza euclidea misura la lunghezza del segmento tra due punti nello spazio vettoriale. Più piccola è la distanza, più simili sono i testi. L’esempio seguente confronta tre frasi: le prime due dicono la stessa cosa usando un vocabolario diverso, mentre la terza parla di torta di mele. Le frasi A e B non condividono alcuna parola comune, eppure la loro distanza sarà significativamente inferiore alla distanza tra A e 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
Similarità del Coseno
La similarità del coseno è la metrica più utilizzata per gli embedding. Misura l’angolo tra due vettori, indipendentemente dalla loro magnitudine. Il risultato varia da -1 a 1, fornendo una scala immediatamente leggibile: puoi impostare una soglia e comunicarla a un team aziendale senza dover spiegare le norme vettoriali.
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)
Il divario tra 0.92 e 0.35 rappresenta l’informazione utile: non è il valore assoluto che conta, ma il margine che separa i risultati pertinenti da quelli fuori tema nel tuo dataset specifico. Puoi anche implementare la metrica manualmente, se non altro per verificare cosa sta facendo scikit-learn o per evitare dipendenze in un ambiente vincolato:
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}")
Matrice di Similarità
Per confrontare più documenti tra loro, puoi costruire una matrice di similarità. Il corpus sottostante mescola intenzionalmente due temi—IA e gastronomia—così che la struttura salti subito all’occhio: i documenti 0, 1 e 3 sono correlati tra loro, mentre i documenti 2 e 4 formano un cluster separato. Questo è esattamente il segnale che gli algoritmi di clustering sfruttano.
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}")
Ricerca Semantica Semplice
Tutto quanto sopra si combina in un mini motore di ricerca. La query viene codificata con lo stesso modello del corpus—una condizione non negoziabile, poiché due modelli diversi producono spazi incomparabili—poi argsort inverte il ranking per portare i punteggi più alti in cima.
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']}")
Soglia di Rilevanza
Questo motore ha un difetto che scoprirai rapidamente in produzione: restituisce sempre tre risultati, anche quando la domanda non ha nulla a che fare con il corpus. Chiedigli del meteo e ti restituirà i tre documenti meno distanti, con punteggi irrisori ma un ranking apparentemente normale. Nella pratica, devi quindi definire una soglia di similarità al di sotto della quale un documento è considerato irrilevante:
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)
Prenditi il tempo di calibrare questa soglia su una trentina di query reali prima di aprire il servizio agli utenti. Impostala troppo alta e il tuo motore dirà «Non lo so» a domande legittime. Impostala troppo bassa e fornirai all’LLM un contesto fuori tema, creando proprio quelle allucinazioni che il RAG doveva prevenire.
Punti chiave
- La similarità del coseno è la metrica standard per confrontare gli embedding
- Usa
sklearn.metrics.pairwise.cosine_similarityper calcoli veloci - Una matrice di similarità ti permette di confrontare tutti i documenti tra loro
- Definisci una soglia di rilevanza adattata al tuo caso d’uso (0.7 è un buon default)
- La ricerca semantica trova risultati per significato, non per corrispondenza esatta delle parole