Przejdź do głównej treści
Polski— Wybierz język
Menu

Wyszukiwanie semantyczne kontra wyszukiwanie słów kluczowych

Lekcja 6 z 22 Zaktualizowano 29 lipca 2026 Programista
Na tej stronie
  1. Cele
  2. Ograniczenia wyszukiwania słów kluczowych
  3. Wyszukiwanie semantyczne
  4. Porównanie strukturalne
  5. Kiedy stosować które rozwiązanie?
  6. Wdrażanie kompletnego wyszukiwania semantycznego
  7. Kluczowe wnioski

Cele

  • Zrozumienie ograniczeń wyszukiwania słów kluczowych
  • Poznanie sposobu, w jaki wyszukiwanie semantyczne rozwiązuje te problemy
  • Wdrożenie prostego wyszukiwania semantycznego

Ograniczenia wyszukiwania słów kluczowych

Klasyczne wyszukiwanie – TF-IDF, BM25, Elasticsearch – opiera się na dopasowaniu leksykalnym: szuka dokładnych słów z zapytania wewnątrz dokumentów. Mechanizm ten jest szybki, przewidywalny i całkowicie niezawodny, pod warunkiem że użytkownik posługuje się tym samym słownictwem co dokumenty. Problem w tym, że prawie nigdy tak nie jest.

Poniższy mały, zakomentowany korpus przedstawia cztery typowe sytuacje występujące przy zapytaniu „jak karmić szczeniaka“.

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

Tylko pierwszy dokument zostaje odnaleziony, mimo że drugi i trzeci odpowiadają na pytanie równie dobrze. Co gorsza, czwarty zajmuje wysokie miejsce wyłącznie dlatego, że dzieli słowa z zapytaniem, chociaż dotyczy zarządzania biznesem. Synonimy, parafraza i wieloznaczność: wyszukiwanie leksykalne zawodzi we wszystkich trzech przypadkach.

Wyszukiwanie semantyczne

Wyszukiwanie semantyczne porównuje znaczenie tekstów, a nie ich słowa. Kodujesz korpus raz na zawsze, kodujesz zapytanie w momencie jego nadejścia i rankujesz dokumenty według podobieństwa.

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

Oczekiwany wynik:

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

Trzy odpowiednie dokumenty zajmują pierwsze trzy miejsca mimo całkowicie innego sformułowania, a fałszywy wynik pozytywny spada do 0,45 – znacznie poniżej progu, który wyniósłby go na szczyt. Model zrozumiał, że słowo „szczeniak“ pełni tu funkcję porównania, a nie jest tematem przewodnim.

Porównanie strukturalne

KryteriumSłowa kluczowe (BM25)Semantyczne (embeddingi)
Synonimy❌ Zawodzi✅ Działa
Parafraza❌ Zawodzi✅ Działa
Wielojęzyczność❌ Niemożliwe✅ Możliwe
Błędy ortograficzne❌ Zawodzi✅ Toleruje
Dokładne dopasowanie✅ Doskonałe⚠️ Czasami niedokładne
Nazwy własne, kody✅ Doskonałe⚠️ Może mylić
Szybkość (duży korpus)✅ Bardzo szybkie⚠️ Wymaga indeksu
Koszt✅ Darmowe⚠️ Wywołania API

Kiedy stosować które rozwiązanie?

Analiza tabeli prowadzi do prostej zasady: im bliżej zapytanie jest identyfikatora, tym bardziej odpowiednie staje się wyszukiwanie leksykalne. Odwołanie do produktu, takie jak XR-4471-B, data, dokładna kategoria czy rzadka nazwa własna powinny być wyszukiwane słowo w słowo; model embeddingów będzie miał tendencję do mylenia tego odwołania z sąsiednimi elementami. Jest to również domyślny wybór, gdy korpus jest ogromny, a budżet na embeddingi wynosi zero.

Wyszukiwanie semantyczne przejmuje inicjatywę, gdy tylko użytkownik wyraża się językiem naturalnym. FAQ, obsługa klienta, dokumentacja techniczna konsultowana przez niespecjalistów, korpus wielojęzyczny, w którym pytanie zadane jest po francusku, a odpowiedź napisana po angielsku, czy nawet niejasne, eksploracyjne zapytanie: we wszystkich tych przypadkach luka między słownictwem użytkownika a słownictwem dokumentów to właśnie to, co embeddingi potrafią mostkować.

Ponieważ te dwa profile są raczej komplementarne niż konkurencyjne, najlepszą odpowiedzią jest często połączenie obu podejść, aby objąć wszystkie przypadki. Temat ten zostanie omówiony w Lekcji 9.

Wdrażanie kompletnego wyszukiwania semantycznego

W praktyce enkapsulujesz indeksowanie i wykonywanie zapytań w małej klasie. Pozwala to uniknąć ponownego obliczania wektorów korpusu dla każdego zapytania – jest to najkosztowniejszy błąd, jaki popełniają początkujący.

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

Przetestuj ten silnik zapytaniem „set up Python on my PC“: żadne z tych pięciu słów nie pojawia się w dokumencie 1, który mówi o „instalowaniu Pythona w systemie Windows“. A jednak powinien on zająć pierwsze miejsce. Następnie zmodyfikuj zapytanie, aby dotyczyło „konfigurowania środowiska“, i obserwuj, jak ranking przesuwa się na dokument 2 – masz teraz minimalne stanowisko testowe do weryfikacji zachowania swojego indeksu przed jego poważnym wypełnieniem danymi.

Kluczowe wnioski

  • Wyszukiwanie słów kluczowych zawodzi przy synonimach i parafrazach
  • Wyszukiwanie semantyczne porównuje znaczenie za pomocą embeddingów
  • Każde podejście ma swoje mocne strony: wyszukiwanie hybrydowe łączy oba
  • Prosty silnik semantyczny można zbudować w kilkunastu liniach kodu