Salt la conținutul principal
Română— Alege o limbă
Meniu

Căutare semantică vs. căutare pe cuvinte cheie

Lecția 6 din 22 Actualizată 29 iulie 2026 Dezvoltator
Pe această pagină
  1. Obiective
  2. Limitele căutării pe cuvinte cheie
  3. Căutarea semantică
  4. Comparație structurată
  5. Când să-l folosiți pe care?
  6. Implementarea unei căutări semantice complete
  7. Puncte cheie

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ă

CriteriuCuvinte 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