Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Somiglianza Semantica

Lezione 3 di 18 Aggiornata il 2 novembre 2026 Sviluppatore
In questa pagina
  1. Misurare la Prossimità del Testo
  2. Distanza Euclidea
  3. Similarità del Coseno
  4. Matrice di Similarità
  5. Ricerca Semantica Semplice
  6. Soglia di Rilevanza
  7. Punti chiave

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_similarity per 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