AI Engineering Academy · Lektion

Vad är vector embeddings?

Förstå hur neurala nätverk mappar text till täta vektorer i ett högdimensionellt rum, varför semantiskt liknande texter ger närliggande vektorer och vad cosinuslikhet mäter.

Lektion 1 av 413 steg

Vad är vector embeddings? är en gratis lektion i AI Engineering Academy på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för AI Engineering Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i AI Engineering Academy innehåller totalt 4 lektioner.

Meningen bakom siffrorna

En vektorinbäddning är en lista med tal (en vektor) som representerar betydelsen hos en text. I stället för att lagra ord som råa strängar lär sig neurala nätverk att koda semantisk betydelse i täta numeriska arrayer. Två texter med liknande betydelse ger vektorer som ligger nära varandra i detta högdimensionella rum.

Högdimensionellt vektorrum

Moderna inbäddningar har vanligtvis 768 till 3072 dimensioner. Varje dimension fångar någon latent egenskap hos betydelsen — ämnen, sentiment, stil och relationer — utan att detta har programmerats uttryckligen. Resultatet är ett rikt geometriskt rum där semantiska relationer kan mätas som avstånd.

Exempelvis producerar text-embedding-3-small vektorer med 1536 dimensioner, medan text-embedding-3-large producerar vektorer med 3072 dimensioner.

Så lär sig neurala nätverk inbäddningar

Inbäddningsmodeller tränas på enorma textkorpusar för att förutsäga saknade ord (maskerad språkmodellering) eller skilja semantiskt lika par från olika par. Under träningen justerar nätverket miljontals vikter tills liknande texter naturligt grupperas i det inlärda vektorrummet.

Det är därför inbäddningar kallas täta representationer — varje dimension innehåller information, till skillnad från glesa one-hot-kodningar där de flesta värden är noll.

Cosinuslikhet: mäta närhet

Cosinuslikhet mäter vinkeln mellan två vektorer och returnerar ett värde mellan -1 och 1. Ett värde på 1 innebär att vektorerna pekar exakt i samma riktning (identisk betydelse), 0 innebär att de är ortogonala (obesläktade) och -1 innebär att de pekar i motsatta riktningar.

Det föredras framför euklidiskt avstånd för text eftersom vektorns storlek ignoreras och fokus enbart ligger på riktningen, vilket gör måttet robust mot skillnader i textlängd.

import numpy as np

def cosine_similarity(vec_a, vec_b):
    dot_product = np.dot(vec_a, vec_b)
    norm_a = np.linalg.norm(vec_a)
    norm_b = np.linalg.norm(vec_b)
    return dot_product / (norm_a * norm_b)

# Example with tiny 3D vectors
v1 = np.array([0.8, 0.2, 0.5])
v2 = np.array([0.9, 0.1, 0.4])
print(cosine_similarity(v1, v2))  # Close to 1.0

Varför semantisk likhet är viktig

Traditionell nyckelordssökning fungerar sämre när användare uttrycker sig med omskrivningar: en sökning efter automobile missar dokument om cars. Vektorinbäddningar löser detta eftersom texter med samma semantiska betydelse mappas till närliggande vektorer oavsett vilka exakta ord som används.

Det möjliggör semantisk sökning, där ni hittar det mest relevanta resultatet baserat på betydelse i stället för överlappande ord — en grundläggande funktion som behövs i RAG-system.

Vektorinbäddningen visualiserad

Föreställ er att meningar plottas på en 2D-karta (en förenklad analogi). Meningar om maskininlärning grupperas i en region, meningar om matlagning i en annan och meningar om sport bildar en tredje grupp. Vektorinbäddningar skapar denna karta i tusentals dimensioner.

Kända relationer som king - man + woman ≈ queen är verklig aritmetik i detta rum — vektoroperationer kodar semantiska analogier.

Generera en enkel inbäddning

OpenAI embeddings API tar emot text och returnerar en lista med flyttal. Ett enda API-anrop kan bädda in en mening eller ett helt stycke. Den returnerade vektorn har en fast dimension oavsett indatans längd.

Viktigt: längre indata ger inte större vektorer — de ger fortfarande en vektor av samma fasta storlek, men mycket långa texter kan förlora detaljer eftersom modellen komprimerar allt till detta fasta utrymme.

from openai import OpenAI

client = OpenAI()  # uses OPENAI_API_KEY from environment

response = client.embeddings.create(
    model='text-embedding-3-small',
    input='Vector embeddings capture semantic meaning.'
)

embedding = response.data[0].embedding
print(f'Dimensions: {len(embedding)}')  # 1536
print(f'First 5 values: {embedding[:5]}')

Bädda in flera texter samtidigt

Ni kan bädda in flera strängar i ett enda API-anrop genom att skicka en lista till parametern input. Det är mycket effektivare än att göra en begäran per text, eftersom det minskar antalet nätverksomgångar och låter API:t batcha beräkningen.

Svaret innehåller ett inbäddningsobjekt per indata i samma ordning, så att ni kan para ihop dem med originaltexterna med hjälp av zip.

from openai import OpenAI

client = OpenAI()

texts = [
    'Python is a programming language.',
    'Snakes are reptiles.',
    'Machine learning requires data.'
]

response = client.embeddings.create(
    model='text-embedding-3-small',
    input=texts
)

for text, result in zip(texts, response.data):
    print(f'{text[:30]}... -> {len(result.embedding)}D vector')

Skalärprodukt jämfört med cosinuslikhet

Om era inbäddningar är L2-normaliserade (enhetsvektorer med längden 1) är skalärprodukten lika med cosinuslikheten. OpenAI:s inbäddningsmodeller returnerar normaliserade vektorer, så ni kan använda vilket av måtten som helst — skalärprodukten är något snabbare att beräkna.

När ni däremot kombinerar inbäddningar från olika modeller eller källor som kanske inte är normaliserade ska ni alltid beräkna cosinuslikheten uttryckligen för att undvika missvisande resultat.

import numpy as np

def normalize(vec):
    return vec / np.linalg.norm(vec)

v1 = normalize(np.array([3.0, 4.0, 0.0]))
v2 = normalize(np.array([4.0, 3.0, 0.0]))

# For unit vectors: dot product == cosine similarity
dot = np.dot(v1, v2)
print(f'Dot product: {dot:.4f}')  # same as cosine sim

Inbäddningar jämfört med one-hot-kodning

One-hot-kodning representerar varje ord som en vektor med exakt en etta och nollor i alla övriga positioner. Ett ordförråd med 50 000 ord ger vektorer med 50 000 dimensioner som nästan helt består av nollor — mycket ineffektivt.

Täta inbäddningar använder 768–3072 dimensioner, men varje dimension innehåller verklig information. Utrymmet är 10–20 gånger mindre men fångar samtidigt mycket fler nyanser, däribland synonymer, analogier och kompositionell betydelse som one-hot-kodning helt missar.

Vanliga användningsområden för inbäddningar

Utöver semantisk sökning används inbäddningar i många praktiska tillämpningar:

Semantisk sökning — hitta dokument utifrån betydelse, inte nyckelord
Rekommendationssystem — föreslå objekt som liknar sådant användaren har gillat
Klustring — gruppera dokument efter ämne automatiskt
Klassificering — mata inbäddningar till en linjär klassificerare
Deduplicering — upptäck nästan identiskt innehåll

Alla RAG-system är beroende av inbäddningar för att matcha användarfrågor mot relevanta dokumentsegment.

Snabbtest

Testa er förståelse av AI Engineering-begreppen från den här lektionen.

Besvara frågan i den interaktiva lektionen

Sammanfattning av lektionen

I den här lektionen har ni lärt er att vektorinbäddningar kodar semantisk betydelse som täta numeriska arrayer, att cosinuslikhet mäter semantisk närhet genom att jämföra vektorernas riktningar och att OpenAI:s embedding API omvandlar text till vektorer av fast storlek i ett enda anrop. Härnäst utforskar vi hur ni i praktiken genererar och jämför inbäddningar med OpenAI-modellerna.

Gratis att börja

Lär dig Python med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 30
Lektioner: 120

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Vad är vector embeddings?” gratis?

Ja – hela texten till ”Vad är vector embeddings?” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i AI Engineering Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i AI Engineering Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Vad är vector embeddings?”?

Förstå hur neurala nätverk mappar text till täta vektorer i ett högdimensionellt rum, varför semantiskt liknande texter ger närliggande vektorer och vad cosinuslikhet mäter. Ni övar på AI Engineering Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig AI Engineering Academy?

Du behöver inga förkunskaper. Utbildningen i AI Engineering Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Vad är vector embeddings?”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här AI Engineering Academy-lektionen?

Ja. Varje AI Engineering Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Vad är vector embeddings?
Generera embeddings med OpenAI
Semantisk sökning med NumPy
Klustring och visualisering av embeddings

← Tillbaka till AI Engineering Academy