Ricerca semantica vs. ricerca per parole chiave
In questa pagina
Obiettivi
- Comprendere i limiti della ricerca per parole chiave
- Scoprire come la ricerca semantica risolve questi problemi
- Implementare una semplice ricerca semantica
I limiti della ricerca per parole chiave
La ricerca classica (TF-IDF, BM25, Elasticsearch) si basa sul matching lessicale: cerca le parole esatte della query all’interno dei documenti. Questo meccanismo è veloce, prevedibile e perfettamente affidabile finché l’utente utilizza lo stesso vocabolario dei documenti. Il problema è che quasi non lo fa mai.
Il piccolo corpus commentato qui sotto mostra le quattro situazioni tipiche quando si affronta la query “come nutrire un cucciolo”.
# Keyword search
query = "how to feed a puppy"
# ✅ Found: contains the same words
doc_a = "How to feed a 3-month-old puppy"
# ❌ Not found: different words, same meaning
doc_b = "Feeding the young dog"
# ❌ Not found: rephrasing
doc_c = "Dietary regimen for newborn puppies"
# ⚠️ False positive: same words, different meaning
doc_d = "How to feed a startup project like a puppy"
Viene recuperato solo il primo documento, anche se il secondo e il terzo rispondono alla domanda altrettanto bene. Peggio ancora, il quarto si posiziona in alto esclusivamente perché condivide parole con la query, sebbene parli di gestione aziendale. Sinonimi, riformulazioni e ambiguità: la ricerca lessicale fallisce su tutti e tre i fronti.
Ricerca semantica
La ricerca semantica confronta il significato dei testi, non le loro parole. Codifichi il corpus una volta per tutte, codifichi la query quando arriva e classifichi i documenti per similarità.
from openai import OpenAI
import numpy as np
client = OpenAI()
def embed(text: str) -> np.ndarray:
response = client.embeddings.create(
input=text,
model="text-embedding-3-large"
)
return np.array(response.data[0].embedding)
# Corpus
documents = [
"How to feed a 3-month-old puppy",
"Feeding the young dog",
"Dietary regimen for newborn puppies",
"How to feed a startup project like a puppy",
"The basics of Italian cuisine",
]
# Index the corpus
corpus_embeddings = np.array([embed(doc) for doc in documents])
# Search
query = "how to feed a puppy"
query_embedding = embed(query)
# Calculate similarities
similarities = corpus_embeddings @ query_embedding
# Sort by relevance
results = sorted(
enumerate(similarities), key=lambda x: x[1], reverse=True
)
for idx, score in results:
print(f"{score:.4f} | {documents[idx]}")
Risultato atteso:
0.9123 | How to feed a 3-month-old puppy
0.8756 | Dietary regimen for newborn puppies
0.8421 | Feeding the young dog
0.4532 | How to feed a startup project like a puppy
0.1245 | The basics of Italian cuisine
I tre documenti pertinenti occupano le prime tre posizioni nonostante una formulazione completamente diversa, e il falso positivo scende a 0,45, ben al di sotto della soglia che lo porterebbe in cima. Il modello ha capito che “cucciolo” qui funge da termine di paragone, non da soggetto.
Confronto strutturato
| Criterio | Parole chiave (BM25) | Semantica (embedding) |
|---|---|---|
| Sinonimi | ❌ Fallisce | ✅ Funziona |
| Riformulazione | ❌ Fallisce | ✅ Funziona |
| Multilingua | ❌ Impossibile | ✅ Possibile |
| Errori di ortografia | ❌ Fallisce | ✅ Tollera |
| Corrispondenza esatta | ✅ Eccellente | ⚠️ A volte imprecisa |
| Nomi propri, codici | ✅ Eccellente | ⚠️ Può confondere |
| Velocità (grande corpus) | ✅ Molto veloce | ⚠️ Richiede un indice |
| Costo | ✅ Gratuito | ⚠️ Chiamate API |
Quando usare quale?
Leggendo la tabella emerge una regola semplice: più una query si avvicina a un identificatore, più appropriata diventa la ricerca lessicale. Un riferimento di prodotto come XR-4471-B, una data, una categoria esatta o un nome proprio raro vanno cercati parola per parola; un modello di embedding tenderà a confondere quel riferimento con i suoi vicini. Questa è anche la scelta predefinita quando il corpus è enorme e il budget per gli embedding è zero.
La ricerca semantica prende il sopravvento non appena l’utente si esprime in linguaggio naturale. Una FAQ, un supporto clienti, documentazione tecnica consultata da non esperti, un corpus multilingua dove la domanda è posta in francese e la risposta scritta in inglese, o anche una query vaga ed esplorativa: in tutti questi casi, il divario tra il vocabolario dell’utente e quello dei documenti è esattamente ciò che gli embedding sanno colmare.
Poiché questi due profili sono complementari piuttosto che competitivi, la risposta migliore consiste spesso nel combinare entrambi gli approcci per coprire tutti i casi. Questo è l’argomento della Lezione 9.
Implementazione della ricerca semantica completa
In pratica, incapsuli l’indicizzazione e la ricerca in una piccola classe. Questo evita di ricalcolare i vettori del corpus per ogni query: l’errore più costoso che i principianti commettono.
class SemanticSearch:
def __init__(self, model: str = "text-embedding-3-large"):
self.client = OpenAI()
self.model = model
self.documents: list[dict] = []
self.embeddings: np.ndarray | None = None
def index(self, documents: list[dict]):
"""Indexes a list of documents {id, text, ...}."""
self.documents = documents
texts = [d["text"] for d in documents]
response = self.client.embeddings.create(
input=texts,
model=self.model
)
vectors = sorted(response.data, key=lambda x: x.index)
self.embeddings = np.array(
[v.embedding for v in vectors], dtype=np.float32
)
def search(self, query: str, k: int = 5) -> list[dict]:
"""Searches for the k most relevant documents."""
query_emb = self.client.embeddings.create(
input=query,
model=self.model
).data[0].embedding
similarities = self.embeddings @ np.array(query_emb)
top_k = np.argsort(similarities)[-k:][::-1]
return [
{**self.documents[i], "score": float(similarities[i])}
for i in top_k
]
# Usage
engine = SemanticSearch()
engine.index([
{"id": 1, "text": "How to install Python on Windows"},
{"id": 2, "text": "Guide to configuring the Python environment"},
{"id": 3, "text": "The basics of the Python language"},
])
results = engine.search("set up Python on my PC")
for r in results:
print(f"[{r['score']:.3f}] {r['text']}")
Prova questo motore con la query “set up Python on my PC”: nessuna di queste cinque parole appare nel documento 1, che parla di “installare Python su Windows”. Eppure dovrebbe classificarsi al primo posto. Poi modifica la query per parlare di “configurare l’ambiente” e osserva come la classifica si sposti sul documento 2: ora hai un banco di prova minimale per verificare il comportamento del tuo indice prima di popolarlo seriamente.
Punti chiave
- La ricerca per parole chiave fallisce con sinonimi e riformulazioni
- La ricerca semantica confronta il significato tramite embedding
- Ogni approccio ha i suoi punti di forza: la ricerca ibrida li combina entrambi
- Un semplice motore semantico può essere costruito in poche decine di righe