Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Semantisk sökning kontra nyckelordsökning

Lektion 6 av 22 Uppdaterad 29 juli 2026 Utvecklare
På denna sida
  1. Mål
  2. Begränsningarna med nyckelordsökning
  3. Semantisk sökning
  4. Strukturerad jämförelse
  5. När ska du använda vad?
  6. Implementera komplett semantisk sökning
  7. Viktiga punkter

Mål

  • Förstå begränsningarna med nyckelordsökning
  • Upptäck hur semantisk sökning löser dessa problem
  • Implementera en enkel semantisk sökning

Begränsningarna med nyckelordsökning

Klassisk sökning – TF-IDF, BM25, Elasticsearch – förlitar sig på lexikal matchning: den letar efter exakt samma ord från frågan i dokumenten. Denna mekanism är snabb, förutsägbar och helt tillförlitlig så länge användaren använder samma ordval som dokumenten. Problemet är att de nästan aldrig gör det.

Den lilla kommenterade korpusen nedan visar de fyra typiska situationerna när man ställs inför frågan “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"

Endast det första dokumentet hämtas, även om det andra och tredje besvarar frågan lika bra. Ännu värre är att det fjärde rankas högt enbart för att det delar ord med frågan, trots att det handlar om affärsledning. Synonymer, omformuleringar och tvetydighet: lexikal sökning misslyckas med alla tre.

Semantisk sökning

Semantisk sökning jämför texters betydelse, inte deras ord. Du kodar korpusen en gång för alla, kodar frågan när den kommer in och rankar dokumenten efter likhet.

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

Förväntat resultat:

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

De tre relevanta dokumenten intar de tre första platserna trots helt olika formuleringar, och falskt positivt resultat sjunker till 0,45 – långt under tröskeln som skulle lyfta det till toppen. Modellen förstod att “puppy” här fungerar som en jämförelse, inte som ämnet.

Strukturerad jämförelse

KriteriumNyckelord (BM25)Semantisk (inbäddningar)
Synonymer❌ Misslyckas✅ Fungerar
Omformulering❌ Misslyckas✅ Fungerar
Flerspråkighet❌ Omöjligt✅ Möjligt
Stavfel❌ Misslyckas✅ Tolererar
Exakt matchning✅ Utmärkt⚠️ Ibland oprecist
Egennamn, koder✅ Utmärkt⚠️ Kan förväxla
Hastighet (stor korpus)✅ Mycket snabb⚠️ Kräver index
Kostnad✅ Gratis⚠️ API-anrop

När ska du använda vad?

Att läsa tabellen ger en enkel regel: ju närmare en fråga är en identifierare, desto lämpligare blir lexikal sökning. En produktreferens som XR-4471-B, ett datum, en exakt kategori eller ett sällsynt egennamn bör sökas ord för ord; en inbäddningsmodell tenderar att förväxla den referensen med dess grannar. Detta är också standardvalet när korpusen är massiv och budgeten för inbäddningar är noll.

Semantisk sökning tar ledningen så snart användaren uttrycker sig i naturligt språk. En FAQ, kundsupport, teknisk dokumentation som konsulteras av icke-specialister, en flerspråkig korpus där frågan ställs på franska och svaret är skrivet på engelska, eller till och med en vag, utforskande fråga: i alla dessa fall är gapet mellan användarens ordval och dokumentens precis det som inbäddningar vet hur man överbryggar.

Eftersom dessa två profiler är komplementära snarare än konkurrerande, består det bästa svaret ofta av att kombinera båda metoderna för att täcka alla fall. Det är ämnet för lektion 9.

Implementera komplett semantisk sökning

I praktiken kapslar du indexering och frågor i en liten klass. Detta undviker att beräkna om korpusvektorerna för varje fråga – det dyraste misstaget nybörjare gör.

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 denna motor med frågan “set up Python on my PC”: inget av dessa fem ord förekommer i dokument 1, som handlar om “installing Python on Windows”. Ändå bör det rankas först. Ändra sedan frågan för att handla om “configuring the environment” och se hur rankningen flyttas till dokument 2 – nu har du en minimal testbänk för att verifiera ditt index beteende innan du fyller det på allvar.

Viktiga punkter

  • Nyckelordsökning misslyckas med synonymer och omformuleringar
  • Semantisk sökning jämför betydelse via inbäddningar
  • Varje metod har sina styrkor: hybrid sökning kombinerar båda
  • En enkel semantisk motor kan byggas på några dussin rader