Căutare semantică vs. căutare pe cuvinte cheie
Pe această pagină
Obiective
- Înțelegeți limitările căutării pe cuvinte cheie
- Descoperiți modul în care căutarea semantică rezolvă aceste probleme
- Implementați o căutare semantică simplă
Limitele căutării pe cuvinte cheie
Căutarea clasică—TF-IDF, BM25, Elasticsearch—se bazează pe potrivirea lexicală: aceasta caută cuvintele exacte din interogare în interiorul documentelor. Acest mecanism este rapid, predictibil și perfect fiabil atâta timp cât utilizatorul folosește același vocabular ca și documentele. Problema este că acest lucru se întâmplă aproape niciodată.
Micul corpus comentat de mai jos ilustrează cele patru situații tipice atunci când ne confruntăm cu interogarea „how to feed a puppy“.
# 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"
Doar primul document este recuperat, deși al doilea și al treilea răspund la fel de bine la întrebare. Mai grav, al patrulea se clasează pe o poziție înaltă doar pentru că share-uiește cuvinte cu interogarea, deși discută despre managementul afacerilor. Sinonimele, reformulările și ambiguitatea: căutarea lexicală eșuează la toate cele trei.
Căutarea semantică
Căutarea semantică compară sensul textelor, nu cuvintele lor. Encodați corpusul o singură dată pentru totdeauna, encodați interogarea atunci când aceasta sosește și clasificați documentele în funcție de similaritate.
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]}")
Rezultat așteptat:
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
Cele trei documente relevante ocupă primele trei locuri, în ciuda unei formulări complet diferite, iar falsul pozitiv coboară la 0,45—mult sub pragul care l-ar aduce în vârf. Modelul a înțeles că „puppy“ servește aici drept comparație, nu ca subiect.
Comparație structurată
| Criteriu | Cuvinte cheie (BM25) | Semantic (embeddings) |
|---|---|---|
| Sinonime | ❌ Eșuează | ✅ Funcționează |
| Reformulare | ❌ Eșuează | ✅ Funcționează |
| Multilingv | ❌ Imposibil | ✅ Posibil |
| Erori de ortografie | ❌ Eșuează | ✅ Tolerant |
| Potrivire exactă | ✅ Excelent | ⚠️ Uneori imprecis |
| Nume proprii, coduri | ✅ Excelent | ⚠️ Poate confunda |
| Viteză (corpus mare) | ✅ Foarte rapid | ⚠️ Necesită un index |
| Cost | ✅ Gratuit | ⚠️ Apeluri API |
Când să-l folosiți pe care?
Citirea tabelului oferă o regulă simplă: cu cât o interogare este mai aproape de un identificator, cu atât căutarea lexicală devine mai adecvată. O referință de produs precum XR-4471-B, o dată, o categorie exactă sau un nume propriu rar trebuie căutate cuvânt cu cuvânt; un model de embedding va tinde să confunde acea referință cu vecinii săi. Aceasta este, de asemenea, alegerea implicită atunci când corpusul este masiv, iar bugetul pentru embedding este zero.
Căutarea semantică preia conducerea imediat ce utilizatorul se exprimă în limbaj natural. O FAQ, suportul pentru clienți, documentația tehnică consultată de non-specialiști, un corpus multilingv în care întrebarea este pusă în franceză, iar răspunsul este scris în engleză, sau chiar o interogare vagă, exploratorie: în toate aceste cazuri, decalajul dintre vocabularul utilizatorului și cel al documentelor este exact ceea ce embedding-urile știu să pună în legătură.
Deoarece aceste două profiluri sunt complementare și nu competitive, cel mai bun răspuns constă adesea în combinarea ambelor abordări pentru a acoperi toate cazurile. Acesta este subiectul Lecției 9.
Implementarea unei căutări semantice complete
În practică, încapsulați indexarea și interogarea într-o mică clasă. Acest lucru evită recalcularea vectorilor corpusului pentru fiecare interogare—cea mai costisitoare greșeală pe care o fac începătorii.
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']}")
Testați acest motor cu interogarea „set up Python on my PC“: niciunul dintre aceste cinci cuvinte nu apare în documentul 1, care vorbește despre „installing Python on Windows“. Cu toate acestea, acesta ar trebui să se claseze pe primul loc. Apoi modificați interogarea pentru a vorbi despre „configuring the environment“ și urmăriți cum clasamentul se schimbă către documentul 2—aveți acum un banc de test minim pentru a verifica comportamentul indexului dumneavoastră înainte de a-l popula serios.
Puncte cheie
- Căutarea pe cuvinte cheie eșuează în fața sinonimelor și a reformulărilor
- Căutarea semantică compară sensul prin intermediul embedding-urilor
- Fiecare abordare are punctele sale forte: căutarea hibridă le combină pe ambele
- Un motor semantic simplu poate fi construit în câteva zeci de linii de cod