Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Hakusemantikka vs. avainsanahaku

Oppitunti 6 / 22 Päivitetty 29. heinäkuuta 2026 Kehittäjä
Tällä sivulla
  1. Tavoitteet
  2. Avainsanahaun rajat
  3. Hakusemantikka
  4. Rakennevertailu
  5. Milloin käyttää mitäkin?
  6. Täydellisen semanttisen haun toteuttaminen
  7. Keskeiset asiat

Tavoitteet

  • Ymmärrä avainsanahaun rajoitukset
  • Tutustu siihen, miten hakusemantikka ratkaisee nämä ongelmat
  • Toteuta yksinkertainen semanttinen haku

Avainsanahaun rajat

Klassinen haku – TF-IDF, BM25, Elasticsearch – perustuu leksikaaliseen täsmäytykseen: se etsii kyselystä tarkat sanat dokumenteista. Tämä mekanismi on nopea, ennustettava ja täysin luotettava niin kauan kuin käyttäjä käyttää samaa sanastoa kuin dokumentit. Ongelma on siinä, että näin käy lähes koskaan.

Alla oleva pieni kommentoitu aineisto esittää neljä tyypillistä tilannetta, kun kyselynä on “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"

Vain ensimmäinen dokumentti löytyy, vaikka toinen ja kolmas vastaavat kysymykseen yhtä hyvin. Pahempaa on, että neljäs nousee korkealle pelkästään siksi, että se jakaa sanoja kyselyn kanssa, vaikka se käsittelee liikkeenjohtoa. Synonyymit, uudelleenmuotoilu ja monimerkityksisyys: leksikaalinen haku epäonnistuu kaikissa kolmessa.

Hakusemantikka

Hakusemantikka vertaa tekstien merkitystä, ei niiden sanoja. Koodaat aineiston kerran ja lopullisesti, koodaat kyselyn sen saapuessa ja järjestät dokumentit samankaltaisuuden perusteella.

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

Odotettu tulos:

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

Kolme asiaankuuluvaa dokumenttia miehittävät kolme kärkipaikkaa täysin erilaisesta muotoilusta huolimatta, ja väärä positiivinen tulos putoaa arvoon 0,45 – hyvin sen kynnyksen alapuolelle, joka nostaisi sen kärkeen. Malli ymmärsi, että “puppy” toimii tässä vertauksena, ei aiheena.

Rakennevertailu

ArviointiperusteAvainsanat (BM25)Semanttinen (upotukset)
Synonyymit❌ Epäonnistuu✅ Toimii
Uudelleenmuotoilu❌ Epäonnistuu✅ Toimii
Monikielisyys❌ Mahdotonta✅ Mahdollista
Oikeinkirjoitusvirheet❌ Epäonnistuu✅ Sietää
Tarkka osuma✅ Erinomainen⚠️ Joskus epätarkka
Erisnimet, koodit✅ Erinomainen⚠️ Saattaa sekoittaa
Nopeus (suuri aineisto)✅ Erittäin nopea⚠️ Vaatii indeksin
Kustannus✅ Ilmainen⚠️ API-kutsut

Milloin käyttää mitäkin?

Taulukon lukeminen antaa yksinkertaisen säännön: mitä lähempänä kysely on tunnisteena toimivaa arvoa, sitä sopivammaksi leksikaalinen haku muodostuu. Tuotteen viite kuten XR-4471-B, päivämäärä, tarkka kategoria tai harvinainen erisnimi tulisi hakea sanasta sanaan; upotusmalli pyrkii sekoittamaan tämän viitteen sen naapureihin. Tämä on myös oletusvalinta, kun aineisto on valtava ja upotusbudjetti on nolla.

Hakusemantikka ottaa ohjat käsiinsä heti, kun käyttäjä ilmaisee itseään luonnollisella kielellä. Usein kysytyt kysymykset (FAQ), asiakastuki, ei-asiantuntijoiden lukema tekninen dokumentaatio, monikielinen aineisto, jossa kysymys esitetään ranskaksi ja vastaus on kirjoitettu englanniksi, tai jopa epämääräinen, tutkiva kysely: kaikissa näissä tapauksissa käyttäjän sanaston ja dokumenttien sanaston välinen kuilu on juuri se, minkä upotukset osaavat silloittaa.

Koska nämä kaksi profiilia täydentävät toisiaan eivätkä kilpaile keskenään, paras vastaus koostuu usein molempien lähestymistapojen yhdistämisestä kaikkien tapausten kattamiseksi. Tämä on oppitunnin 9 aihe.

Täydellisen semanttisen haun toteuttaminen

Käytännössä kapseloit indeksoinnin ja kyselyn pieneen luokkaan. Tämä välttää aineiston vektorien uudelleenlaskennan jokaista kyselyä kohden – yleisin ja kallein virhe, jonka aloittelijat tekevät.

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

Testaa tätä moottoria kyselyllä “set up Python on my PC”: yksikään näistä viidestä sanasta ei esiinny dokumentissa 1, joka puhuu “Pythonin asentamisesta Windowsiin”. Sen pitäisi kuitenkin nousta ensimmäiseksi. Muuta sitten kyselyä puhumaan “ympäristön konfiguroinnista” ja tarkkaile, kuinka sijoitus siirtyy dokumenttiin 2 – sinulla on nyt minimaalinen testipenkki varmistaaksesi indeksisi toiminnan ennen sen vakavaa täyttämistä.

Keskeiset asiat

  • Avainsanahaku epäonnistuu synonyymien ja uudelleenmuotoilun kanssa
  • Hakusemantikka vertaa merkitystä upotusten avulla
  • Kummallakin lähestymistavalla on vahvuutensa: hybridi-haku yhdistää molemmat
  • Yksinkertainen semanttinen moottori voidaan rakentaa muutamassa kymmenessä rivissä