Премини към основното съдържание
Български— Изберете език
Меню

Семантично търсене срещу търсене по ключови думи

Урок 6 от 22 Обновен 29 юли 2026 г. Програмист
На тази страница
  1. Цели
  2. Ограниченията на търсенето по ключови думи
  3. Семантично търсене
  4. Структурирано сравнение
  5. Кога да използвате кое?
  6. Внедряване на пълно семантично търсене
  7. Ключови изводи

Цели

  • Да разберете ограниченията на търсенето по ключови думи
  • Да откриете как семантичното търсене решава тези проблеми
  • Да внедрите просто семантично търсене

Ограниченията на търсенето по ключови думи

Класическото търсене – TF-IDF, BM25, Elasticsearch – разчита на лексикално съвпадение: то търси точните думи от заявката вътре в документите. Този механизъм е бърз, предвидим и напълно надежден, стига потребителят да използва същия речник като документите. Проблемът е, че те почти никога не го правят.

Малкият коментиран корпус по-долу показва четирите типични ситуации при заявка „как да храним кученце“.

# 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"

Само първият документ се извлича, въпреки че вторият и третият отговарят на въпроса също толкова добре. Още по-лошо, четвъртият се класира високо единствено защото споделя думи със заявката, въпреки че обсъжда управление на бизнес. Синоними, преформулиране и двусмислие: лексикалното търсене се проваля и в трите случая.

Семантично търсене

Семантичното търсене сравнява смисъла на текстовете, а не техните думи. Вие кодирате корпуса веднъж завинаги, кодирате заявката, когато тя пристигне, и класирате документите според сходството им.

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]}")

Очакван резултат:

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

Трите релевантни документа заемат първите три места, въпреки напълно различното формулиране, а фалшиво положителният резултат пада до 0.45 – далеч под прага, който би го издигнал на върха. Моделът е разбрал, че „кученце“ тук служи за сравнение, а не е основният обект.

Структурирано сравнение

КритерийКлючови думи (BM25)Семантично (вграждания)
Синоними❌ Се проваля✅ Работи
Преформулиране❌ Се проваля✅ Работи
Многоезичност❌ Невъзможно✅ Възможно
Правописни грешки❌ Се проваля✅ Толерира
Точно съвпадение✅ Отлично⚠️ Понякога неточно
Собствени имена, кодове✅ Отлично⚠️ Може да обърка
Скорост (голям корпус)✅ Много бързо⚠️ Изисква индекс
Разходи✅ Безплатно⚠️ API повиквания

Кога да използвате кое?

Четенето на таблицата дава просто правило: колкото по-близо е една заявка до идентификатор, толкова по-подходящо става лексикалното търсене. Референтен номер на продукт като XR-4471-B, дата, точна категория или рядко собствено име трябва да се търсят дума по дума; моделът за вграждане ще има тенденцията да обърка тази референция със съседните ѝ. Това е и изборът по подразбиране, когато корпусът е масивен, а бюджетът за вграждания е нулев.

Семантичното търсене поема водещата роля веднага щом потребителят се изразява на естествен език. ЧЗВ, поддръжка на клиенти, техническа документация, консултирана от неспециалисти, многоезичен корпус, където въпросът е зададен на френски, а отговорът е написан на английски, или дори неясна, изследователска заявка: във всички тези случаи пропастта между речника на потребителя и този на документите е точно това, което вгражданията умеят да преодолеят.

Тъй като тези два профила са допълващи се, а не конкурентни, най-добрият отговор често се състои в комбиниране на двата подхода, за да се обхванат всички случаи. Това е темата на Урок 9.

Внедряване на пълно семантично търсене

На практика вие обгръщате индексирането и заявките в малък клас. Това избягва преизчисляването на векторите на корпуса за всяка заявка – най-скъпата грешка, която начинаещите правят.

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']}")

Тествайте този двигател със заявката „set up Python on my PC“: нито една от тези пет думи не се появява в документ 1, който говори за „инсталиране на Python на Windows“. Въпреки това той трябва да се класира първи. След това променете заявката, за да говори за „конфигуриране на средата“, и наблюдавайте как класирането се измества към документ 2 – вече имате минимален тестов стенд, за да проверите поведението на вашия индекс, преди да го попълните сериозно.

Ключови изводи

  • Търсенето по ключови думи се проваля при синоними и преформулиране
  • Семантичното търсене сравнява смисъла чрез вграждания
  • Всеки подход има своите силни страни: хибридното търсене комбинира и двете
  • Прост семантичен двигател може да се изгради с няколко десетки реда код