Zoek naar “hoe krijg ik mijn geld terug”, en een goed systeem zou een pagina met de titel “Terugbetalingsbeleid” moeten vinden, ook al delen de twee geen belangrijke woorden. Dat vermogen komt voort uit inbedding, een van de nuttigste ideeën in de moderne AI.

In deze handleiding worden insluitingen uitgelegd zonder zware wiskunde. We hebben een klein voorbeeld uitgevoerd in Python 3.13, en de uitvoer ervan wordt hieronder weergegeven. De vectoren daarin zijn de vectoren die we met de hand hebben gemaakt, met elk slechts drie getallen, zodat het idee gemakkelijk te begrijpen is. Echte inbedding is afkomstig van een getraind model en bestaat vaak uit honderden of duizenden cijfers.

Wat is een inbedding?

Een inbedding is een weergave van iets als een lijst met getallen, een zogenaamde vector. Een model wordt zo getraind dat items met gerelateerde betekenissen vectoren krijgen die dicht bij elkaar liggen.

"kitten"  -> [0.9, 0.8, 0.1]
"cat"     -> [0.9, 0.7, 0.2]
"invoice" -> [0.0, 0.1, 0.9]

Zodra de tekst deze vorm heeft, kan een computer berekenen hoe vergelijkbaar twee stukken tekst zijn, wat hij niet rechtstreeks met woorden kan doen. Inbedding beperkt zich ook niet tot woorden. Zinnen, hele documenten, afbeeldingen, audio en producten kunnen allemaal worden ingesloten.

Waarom niet gewoon zoekwoorden matchen?

Onze gids voor RAG laat dit in de praktijk zien. Een eenvoudige zoekopdracht op basis van het aantal woorden scoorde nul voor “Wanneer kan ik mijn geld terugkrijgen?” tegen een restitutiedocument, omdat ze geen woorden deelden. Let ook op de derde rij: exacte ID’s zijn een zwakte van insluitingen, dus zoeken op trefwoorden heeft nog steeds een plaats.

Denk aan een kaart

Stel je voor dat je elk woord op een enorme kaart plaatst, waar de locatie de betekenis weerspiegelt. ‘Kat’ en ‘kitten’ zitten bijna naast elkaar, ‘hond’ bevindt zich in dezelfde buurt en ‘factuur’ bevindt zich in een andere stad. Om verwante woorden te vinden, hoeft u alleen maar in de buurt te kijken.

Een echte inbedding werkt op dezelfde manier, behalve dat de kaart honderden dimensies heeft in plaats van twee. Mensen kunnen zich dat niet voorstellen, maar de wiskunde werkt precies hetzelfde. Individuele cijfers hebben over het algemeen geen nette betekenis, zoals “vacht”. Waar het om gaat is de algemene positie.

Een klein werkend voorbeeld

Zo kunt u onze handgemaakte vectoren vergelijken:

import math

def cosine(a, b):
    dot = sum(x * y for x, y in zip(a, b))
    return dot / (math.sqrt(sum(x * x for x in a)) *
                  math.sqrt(sum(y * y for y in b)))

vectors = {
    "kitten":  [0.9, 0.8, 0.1],
    "cat":     [0.9, 0.7, 0.2],
    "dog":     [0.8, 0.3, 0.2],
    "invoice": [0.0, 0.1, 0.9],
}

for word in ("kitten", "dog", "invoice"):
    print(word, round(cosine(vectors["cat"], vectors[word]), 3))

# kitten 0.994
# dog 0.955
# invoice 0.238

Tegen ‘kat’ scoort ‘kitten’ het hoogst, vervolgens ‘hond’ en ‘factuur’ veel lager. We hebben deze vectoren gekozen om dat patroon te produceren, dus de rangschikking bewijst niets over echte taal. Het laat alleen zien hoe de berekening zich gedraagt. Een semantische zoekopdracht doet hetzelfde in drie stappen: de zoekopdracht insluiten, een score toekennen aan elk opgeslagen item en sorteren.

query = [0.85, 0.75, 0.15]
sorted(vectors, key=lambda w: cosine(query, vectors[w]), reverse=True)

# ['kitten', 'cat', 'dog', 'invoice']

Cosinus gelijkenis uitgelegd

Elke vector kan worden gezien als een pijl die vanuit de oorsprong wijst. Cosinusgelijkenis meet de hoek tussen twee pijlen, waarbij wordt genegeerd hoe lang ze zijn. We hebben de belangrijkste waarden bevestigd:

cosine([1, 2, 3], [2, 4, 6])   # 1.0   same direction
cosine([1, 0], [0, 1])         # 0.0   unrelated (at right angles)
cosine([1, 0], [-1, 0])        # -1.0  opposite directions

Kijk naar de eerste regel. [2, 4, 6] is twee keer zo lang als [1, 2, 3], maar de score is een perfecte 1,0, omdat richting het enige is dat telt. Dat is handig voor tekst, waarbij de lengte zaken als de documentgrootte kan weerspiegelen in plaats van de betekenis. Wees ook voorzichtig met drempels. Er is geen universele score die ‘soortgelijk’ betekent, aangezien bruikbare bereiken van model tot model verschillen. Test dus op uw eigen gegevens.

Andere afstandsmaatregelen

Het verschil is gemakkelijk te zien. Diezelfde twee vectoren met een cosinusscore van 1,0 hebben een Euclidische afstand van 3,742, aangezien de ene langer is dan de andere. Veel systemen normaliseren vectoren, waarbij ze elk naar een lengte van 1 schalen. Daarna geven het puntproduct en de cosinus hetzelfde antwoord, en we hebben dit bevestigd: beide gaven 0,955 voor “kat” en “hond”. Controleer de documentatie van uw model om te zien welke maatregel wordt aanbevolen.

Hoe inbeddingen worden geleerd

Niemand wijst deze nummers in echte systemen met de hand toe. Een neuraal netwerk leert ze tijdens de training. Een vroeg en invloedrijk idee is dat woorden die in vergelijkbare contexten voorkomen, vaak dezelfde betekenis hebben, zoals bij “Ik heb mijn kat te eten gegeven” en “Ik heb mijn hond te eten gegeven”. Modellen zoals Word2Vec en GloVe leerden woordvectoren uit die patronen.

Later maakten op transformatoren gebaseerde modellen zoals BERT de inbedding contextbewust, zodat ‘bank’ een andere vector kon krijgen in ‘rivieroever’ en ‘banklening’. Veel moderne modellen integreren hele zinnen of passages in één keer. In onze gids voor grote taalmodellen wordt uitgelegd hoe transformatoren omgaan met context.

Waar inbedding wordt gebruikt

Zoeken op schaal

Ons voorbeeld vergeleek een zoekopdracht met elk item, wat bekend staat als een exacte zoekopdracht. Dat werkt prima voor duizenden items, maar bij vele miljoenen wordt het traag. Geschatte dichtstbijzijnde buur (ANN)-indexen zoals HNSW lossen dit op. Ze vinden snel zeer goede overeenkomsten, door een kleine kans op te geven om de absoluut beste te missen.

Vectordatabases en extensies, zoals pgvector voor PostgreSQL, bieden deze indexen samen met filtering en opslag. Onze vectordatabasegids behandelt de opties. Voor een klein project heb je er misschien helemaal geen nodig, en zoeken in het geheugen is een prima manier om te beginnen.

Een inbeddingsmodel kiezen

• Taal. Als uw inhoud bijvoorbeeld in het Hindi of Tamil is, controleer dan of het model hier goed mee omgaat.
• Domein. Algemene modellen kunnen moeite hebben met specialistische juridische of medische termen.
• Afmetingen. Met meer dimensies kunnen meer details worden vastgelegd, maar dit kost meer opslagruimte en geheugen.
• Kosten en hosting. Vergelijk een gehoste API met een open model dat u zelf kunt uitvoeren, vooral voor privégegevens.
• Invoerlengte. Modellen hebben een limiet, dus lange documenten moeten eerst in delen worden opgesplitst.

De beste test zijn uw eigen gegevens. Verzamel ongeveer twintig echte zoekopdrachten, samen met de documenten die ze moeten vinden, en vergelijk hoe elk model ze rangschikt. Gepubliceerde benchmarks geven mogelijk niet uw inhoud weer.

Beperkingen

• Model lock-in. Vectoren van verschillende modellen kunnen niet met elkaar worden vergeleken. Als je van model verandert, moet je alles opnieuw embedden.
• Exacte termen. ID’s, codes en zeldzame namen komen mogelijk niet betrouwbaar overeen.
• Ontkenning. ‘Terugbetalingen toegestaan’ en ‘Terugbetalingen niet toegestaan’ kunnen dicht bij elkaar liggen, ook al betekenen ze tegengestelde dingen.
• Gelijkaardig betekent niet dat het correct is. Een goede match kan achterhaald of gewoonweg verkeerd zijn.
• Vooroordelen. Inbedding kan stereotypen uit de trainingsgegevens halen.
• Cosinus is geen magie. Onderzoekers hebben zich afgevraagd hoe betekenisvol het is bij sommige aangeleerde inbeddingsvormen. Beschouw scores dus als een nuttig signaal en niet als maatstaf voor de waarheid.

Veel voorkomende fouten

• Modellen combineren. Query’s en documenten insluiten met hetzelfde model en dezelfde versie.
• Gebruik overal één gelijkheidsdrempel. Stem deze af voor elk model en elke taak.
• Grote documenten in hun geheel insluiten. De betekenis wordt verwaterd, dus deel ze eerst op.
• Evaluatie overgeslagen. Zonder testquery’s kun je niet zeggen of een wijziging heeft geholpen.
• Voor alles gebruik maken van insluitingen. Als gebruikers naar exacte ID’s zoeken, is een normale database-index beter.

Tot slot

Een inbedding verandert betekenis in cijfers, zodat software ideeën kan vergelijken in plaats van strings. Het concept is eenvoudig, terwijl het praktische werk bestaat uit het kiezen van een model, het opsplitsen van gegevens en het testen op echte vragen. Om het zelf te proberen, sluit u enkele tientallen van uw eigen documenten in met een willekeurig inbeddingsmodel, doorzoekt u ze met echte vragen en ziet u waar de resultaten u verrassen.

Veelgestelde vragen

Blijf leren