Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Distanza e similarità del coseno

Lezione 4 di 22 Aggiornata il 29 luglio 2026 Sviluppatore
In questa pagina
  1. Obiettivi
  2. Misurare la prossimità tra vettori
  3. Confronto pratico
  4. Interpretare i punteggi
  5. Ricerca del vicino più prossimo
  6. Con scikit-learn
  7. Punti chiave

Obiettivi

  • Comprendere la similarità del coseno e perché è preferibile
  • Implementare il confronto tra vettori in Python
  • Interpretare i punteggi di similarità

Misurare la prossimità tra vettori

Una volta convertiti i tuoi testi in vettori, tutto dipende da una domanda: come decidi se due vettori sono “vicini”? Coesistono tre risposte e la scelta conta.

La distanza euclidea è la distanza geometrica classica, quella che misureresti con un righello tra due punti. È intuitiva, ma dipende dalla magnitudo del vettore: due testi con lo stesso significato, dove uno è codificato con un’ampiezza maggiore, apparirebbero artificialmente distanti.

import numpy as np

def euclidean_distance(a: list[float], b: list[float]) -> float:
    return np.linalg.norm(np.array(a) - np.array(b))

Il prodotto scalare somma i prodotti elemento per elemento. È l’operazione più veloce della famiglia, quella che il processore esegue in modo più efficiente su grandi matrici.

def dot_product(a: list[float], b: list[float]) -> float:
    return np.dot(a, b)

La similarità del coseno, infine, misura l’angolo tra due vettori indipendentemente dalla loro lunghezza, rendendola la metrica standard per gli embedding: conta solo la direzione del significato, non la sua intensità.

def cosine_similarity(a: list[float], b: list[float]) -> float:
    a, b = np.array(a), np.array(b)
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

Il valore varia da -1 per direzioni opposte a +1 per direzioni identiche. Un dettaglio pratico è fondamentale: gli embedding di OpenAI sono già normalizzati, il che significa che hanno una lunghezza pari a 1. Il denominatore è quindi uguale a 1 e il prodotto scalare fornisce esattamente lo stesso risultato della similarità del coseno, ma con un costo computazionale inferiore. Questa è la scorciatoia che useremo per tutto questo corso.

Confronto pratico

Nulla batte la misurazione su frasi reali. Confrontiamo una frase, la sua parafrasi completa e una frase fuori tema:

from openai import OpenAI

client = OpenAI()

def get_embedding(text: str) -> list[float]:
    response = client.embeddings.create(
        input=text,
        model="text-embedding-3-large"
    )
    return response.data[0].embedding

# Frasi da confrontare
sentences = {
    "a": "The cat sleeps on the couch",
    "b": "The feline dozes on the sofa",
    "c": "Python is a programming language",
}

embeddings = {k: get_embedding(v) for k, v in sentences.items()}

# Confronta tutte le coppie
from itertools import combinations

for (k1, v1), (k2, v2) in combinations(sentences.items(), 2):
    sim = cosine_similarity(embeddings[k1], embeddings[k2])
    print(f"sim({k1}, {k2}) = {sim:.4f}")
    print(f"  {v1}")
    print(f"  {v2}")
    print()

Risultato tipico:

sim(a, b) = 0.8923   ← significato molto vicino
sim(a, c) = 0.1247   ← argomenti diversi
sim(b, c) = 0.1189   ← argomenti diversi

Le frasi a e b non condividono parole (cat/feline, sleeps/dozes, couch/sofa), eppure ottengono un punteggio di 0,89. Questo è esattamente ciò che nessun metodo lessicale può ottenere.

Interpretare i punteggi

Le soglie dipendono dal tuo caso d’uso, ma la tabella seguente fornisce punti di riferimento per leggere un punteggio senza sbagliare di un ordine di grandezza.

PunteggioInterpretazione
> 0,85Molto simili (parafrasi, sinonimi)
0,70 – 0,85Tematicamente correlati
0,40 – 0,70Debolmente correlati
< 0,40Argomenti diversi

Questi valori variano in base al modello e al dominio: un corpus legale, dove tutti i testi condividono lo stesso vocabolario formale, produce generalmente punteggi più alti rispetto a un corpus generico, al punto che una soglia di 0,70 diventa troppo permissiva. Calibra sempre sui tuoi dati osservando una trentina di coppie di cui conosci la risposta attesa.

Ricerca del vicino più prossimo

Trovare un documento significa calcolare la similarità tra il vettore della query e tutti i vettori del corpus, per poi mantenere i migliori k. Il trucco è evitare il loop in Python: una moltiplicazione di matrici NumPy calcola tutte le similarità in una volta, in una frazione di tempo.

def search_similar(
    query_embedding: list[float],
    corpus_embeddings: np.ndarray,
    k: int = 5
) -> list[tuple[int, float]]:
    """Restituisce i k documenti più simili."""
    query = np.array(query_embedding)

    # Calcolo vettoriale di tutte le similarità
    similarities = corpus_embeddings @ query
    # (funziona perché gli embedding OpenAI sono normalizzati)

    # Indici dei migliori k punteggi
    top_k_indices = np.argsort(similarities)[-k:][::-1]

    return [(int(i), float(similarities[i])) for i in top_k_indices]

# Utilizzo
corpus = np.load("embeddings.npy")  # matrice (n, 3072)
query_emb = get_embedding("How do I install Python?")

results = search_similar(query_emb, corpus, k=5)
for idx, score in results:
    print(f"Document {idx}: score = {score:.4f}")

La porzione [-k:][::-1] merita un secondo sguardo: argsort ordina in modo crescente, quindi prendiamo la fine dell’array per ottenere i punteggi migliori, poi invertiamo per classificarli dal più rilevante al meno rilevante.

Con scikit-learn

Quando non cerchi un documento specifico ma vuoi confrontare l’intero corpus con se stesso, ad esempio per rilevare duplicati o prepararti al clustering, scikit-learn fornisce una funzione ottimizzata che restituisce l’intera matrice.

from sklearn.metrics.pairwise import cosine_similarity
import numpy as np

# Matrice di similarità tra tutti i documenti
corpus = np.array(embeddings_list)
sim_matrix = cosine_similarity(corpus)

print(f"Shape: {sim_matrix.shape}")  # (n, n)
print(f"Similarity doc 0 ↔ doc 1: {sim_matrix[0][1]:.4f}")

Tieni presente che questa matrice ha dimensioni n × n: diecimila documenti producono cento milioni di valori, circa 400 MB in float32. Oltre qualche migliaio di elementi, elabora a blocchi invece di fare una singola chiamata.

Punti chiave

  • La similarità del coseno misura l’angolo tra i vettori, indipendentemente dalla loro magnitudo
  • Gli embedding OpenAI sono normalizzati: prodotto scalare = coseno
  • Un punteggio > 0,85 indica testi molto simili
  • La ricerca del vicino più prossimo viene eseguita in modo efficiente con NumPy o scikit-learn