Transformer, GPT & LLM

Efter genombrotten inom datorseende flyttades frontlinjen för AI-forskningen till det kanske mest mänskliga av alla områden: språket. Vi såg i det förra kapitlet hur RNNs och LSTMs var ett stort steg framåt för språkförståelse, men de hade en fundamental begränsning inbyggd i sin design. För att förstå nästa revolution måste vi först förstå flaskhalsen.

Flaskhalsen: Den Sekventiella Processorn

En LSTM-cell var genial på att hantera minne, men den tvingades fortfarande arbeta på ett mycket mänskligt, men väldigt ineffektivt sätt: ett ord i taget. För att förstå en mening var den tvungen att läsa ord 1, uppdatera sitt minne, läsa ord 2, uppdatera sitt minne igen, och så vidare.

Detta skapade två stora problem:

1. Det var Långsamt. Processen var i grunden sekventiell. Det gick inte att dela upp arbetet. En GPU, med sina tusentals kärnor som är designade för att arbeta parallellt, stod mest och väntade på att nätverket skulle processa nästa ord i kön. Det var som att försöka lasta en lastbil med en enda person som bär ett paket i taget.
2. Kontexten Försvagades. Även med LSTMs smarta "minnesmotorväg", hade informationen från början av ett långt dokument en mycket lång och krokig väg att färdas för att påverka förståelsen av ett ord i slutet. Kontexten riskerade fortfarande att "vattnas ur".

För att verkligen knäcka språkkoden behövdes en helt ny arkitektur. En arkitektur som kunde överge den sekventiella processen och titta på alla ord i en mening samtidigt, för att omedelbart förstå de komplexa relationerna mellan dem.

Vägen till förståelse: Från ord till vektorer

Innan vi kan bygga huset behöver vi tegelstenarna. För att en maskin ska kunna "förstå" text, måste orden först översättas till siffror. Ett tidigt genombrott var tekniken Word2Vec (2013), som lärde sig att representera varje ord som en vektor (en lång rad med tal) i ett flerdimensionellt rum. Det magiska var att orden placerades så att deras relationer till varandra bevarades. Vektorn för "kung" minus "man" plus "kvinna" hamnade till exempel väldigt nära vektorn för "drottning". För första gången kunde en AI fånga den semantiska innebörden av ord på ett matematiskt sätt. Denna idé – att varje ord är en punkt i ett "meningsrum" – är grunden för allt som skulle följa.

Revolutionen: "Attention Is All You Need"

Det verkliga paradigmskiftet kom 2017 med ett paper från Google med den kaxiga titeln "Attention Is All You Need". Det introducerade en helt ny arkitektur: The Transformer. Den löste både hastighets- och kontextproblemet med några få, eleganta mekanismer.

Byggsten 1: Uppmärksamhet (Attention) - Cocktailparty-principen

Kärnan i Transformern är Attention (Uppmärksamhet). Föreställ dig att du är på ett stökigt cocktailparty och försöker förstå en mening som någon säger:

"Roboten plockade upp bollen från golvet eftersom den var röd."

För att förstå vad ordet "den" syftar på, gör din hjärna omedvetet en snabb sökning. Den ignorerar oviktiga ord som "från" och "var", och fokuserar på substantiven. Den inser snabbt att "bollen" är en mycket mer sannolik kandidat att vara "röd" än vad "roboten" är. Din hjärna "riktar sin uppmärksamhet" till ordet "bollen" för att ge ordet "den" sin rätta innebörd.

Attention-mekanismen gör exakt detta, men matematiskt. Man kan bäst förstå det som en sofistikerad databasuppslagning som varje ord utför för att berika sin egen förståelse med hjälp av de andra orden i meningen.

För att denna uppslagning ska fungera, måste varje ords vektor först omvandlas för att kunna spela tre olika roller. Detta görs genom att multiplicera varje ords inbäddningsvektor med tre separata viktmatriser (Wq, Wk, Wv) som nätverket lär sig under träning. Resultatet är tre nya, specialiserade vektorer för varje ord:

1. En Fråga (Query - Q): Detta är ordets aktiva sökning efter kontext. Vektorn representerar frågan: "För att jag ska förstå min roll i den här meningen, vilken information behöver jag från mina grannar?" För ordet 'den' är frågan ungefär: "Jag är ett pronomen som syftar på något, vem i den här meningen är mest sannolik att beskrivas som 'röd'?"
2. En Nyckel (Key - K): Detta är varje ords "etikett" eller "annons" som det håller upp för alla andra ord. Den beskriver vad ordet är och vilka egenskaper det har. För ordet 'bollen' säger nyckeln ungefär: "Jag är ett konkret, fysiskt objekt. Jag kan ha en färg. Jag kan plockas upp." Nyckeln är designad för att kunna "matcha" en relevant fråga.
3. Ett Värde (Value - V): Detta är ordets fulla, rika innehåll. Medan Nyckeln är en kort annons, är Värdet hela "informationspaketet". För 'bollen' innehåller denna vektor all den djupa semantiska information som nätverket har lärt sig om konceptet 'boll'. Det är detta värdefulla innehåll som ett annat ord vill "importera" när det riktar sin uppmärksamhet.

TODO Illustration: Query, Key, Value

En enkel illustration med tre ikoner. Query: Ett förstoringsglas (symboliserar en sökning). Key: En nyckel eller en prislapp (symboliserar en etikett att matcha mot). Value: En skattkista eller en filmapp (symboliserar det faktiska innehållet som ska hämtas). Detta skapar en stark visuell metafor för de tre rollerna.

Med dessa tre komponenter på plats kan varje ord nu genomföra en trestegsprocess för att hitta och absorbera den mest relevanta kontexten från sina grannar.

Processen i tre steg: Från fråga till kontext

För varje ord i meningen sker nu följande process parallellt. Låt oss fortsätta följa ordet "den" när det försöker förstå sig självt.

Steg 1: Beräkna Relevanspoäng (Fråga möter Nyckel)

Först måste ordet "den" ta reda på hur relevant varje annat ord i meningen är för just dess fråga. Det gör den genom att ta sin Fråga (Q)-vektor och jämföra den med varje annat ords Nyckel (K)-vektor.

• "den" (Q) <---> "Roboten" (K)
• "den" (Q) <---> "plockade" (K)
• "den" (Q) <---> "upp" (K)
• "den" (Q) <---> "bollen" (K)
• ...och så vidare för alla ord.

Den matematiska operation som används för denna jämförelse är oftast en dot product. Resultatet blir ett enkelt tal, en rå poäng, för varje ordpar. En hög poäng betyder "hög relevans" – frågan och nyckeln matchar väl. I vårt exempel kommer jämförelsen mellan Fråga(den) och Nyckel(bollen) att ge en mycket hög poäng, eftersom nätverket har lärt sig att saker som "plockas upp" och "är röda" ofta är substantiv som 'boll'. Jämförelsen med 'roboten' ger en lägre poäng, och jämförelsen med 'från' en nästan obefintlig poäng.

Efter detta steg har ordet "den" en lista med råa relevanspoäng: [Roboten: 12.5, plockade: 3.1, upp: 1.5, bollen: 98.7, ...]

Steg 2: Från råa poäng till fokuserade vikter (Softmax)

De här råa poängen är ärliga men lite otympliga. 98.7 är uppenbarligen mycket högre än 12.5, men hur mycket mer uppmärksamhet betyder det? 90%? 80%? För att göra dem användbara och jämförbara vill vi omvandla dem till en tydlig, procentuell fördelning där den totala uppmärksamheten summerar till 100%.

För detta används en elegant matematisk funktion som heter Softmax. Man kan se den som en "vinnaren-tar-nästan-allt"-omvandlare. Den tar listan med råa poäng och gör följande i tre delsteg:

1. Exponentiell förstärkning: Först gör den något som kan verka lite konstigt: den upphöjer talet e (Eulers tal, ca 2.718) med varje enskild poäng. Denna operation (e^poäng) har en dramatisk effekt: den förstärker exponentiellt de höga poängen och trycker ner de låga. Skillnaden mellan e^98.7 och e^12.5 är astronomisk, mycket större än den ursprungliga skillnaden mellan poängen. Detta gör kontrasten mellan relevanta och irrelevanta ord extremt tydlig.

2. Summering: Sedan summerar den alla dessa nya, enorma tal för att få en totalsumma.

3. Normalisering: Till sist dividerar den varje enskilt exponentiellt värde med den stora totalsumman. Resultatet av denna division är att alla värden nu hamnar mellan 0 och 1, och deras totala summa blir exakt 1.

Genom denna process har de råa poängen omvandlats till en uppsättning vackra uppmärksamhetsvikter. Dessa vikter är den exakta, kvantifierade representationen av vad "den" bör fokusera på:

[Roboten: 0.04, plockade: 0.01, upp: 0.00, bollen: 0.91, ...] (Siffrorna summerar till 1, eller 100%)

Nätverket har nu matematiskt kommit fram till: "För att förstå ordet 'den', ska jag rikta 91% av min uppmärksamhet mot 'bollen', 4% mot 'roboten', och i princip ignorera resten."

En justerbar termostat: Temperatur

Softmax-funktionen har en inbyggd "termostat" som kallas Temperatur (T), som låter oss finjustera hur självsäker eller kreativ modellen ska vara i sina val. Konceptet är enkelt: innan exponenten beräknas, delas varje rå poäng med detta temperaturvärde: e^(poäng / T).

Detta får tre olika effekter:

• Låg temperatur (t.ex. T = 0.2): Poängen delas med ett litet tal, vilket gör de redan stora skillnaderna ännu större. Detta gör modellen extremt konservativ och fokuserad. Den kommer nästan garanterat att välja det alternativ med högst poäng. Användbart för faktabaserade svar.
• Normal temperatur (T = 1.0): Värdet är oförändrat (poäng / 1 = poäng). Detta är standardfallet vi beskrev ovan, en balanserad fördelning.
• Hög temperatur (t.ex. T = 1.5): Poängen delas med ett stort tal, vilket jämnar ut skillnaderna mellan alla alternativ. Detta gör fördelningen mer slumpmässig och modellen blir mer kreativ och oförutsägbar. Den är mer benägen att välja överraskande eller mindre uppenbara ord. Användbart för poesi eller brainstorming.

Temperaturen är en parameter man ofta kan justera själv när man interagerar med stora språkmodeller, för att styra balansen mellan exakthet och kreativitet.

Steg 3: Skapa den nya, kontextuella vektorn (Vikta Värdena)

Nu är det dags för finalen. Ordet "den" har sin "receptlista" (uppmärksamhetsvikterna) och vet exakt hur mycket information det ska hämta från varje annat ord. Den gör detta genom att multiplicera varje ords Värde (V)-vektor – dess fulla informationspaket – med motsvarande uppmärksamhetsvikt.

ny_vektor = (0.91 * Värde(bollen)) + (0.04 * Värde(roboten)) + (0.01 * Värde(plockade)) + ...

Resultatet är en helt ny vektor som representerar ordet "den". Men den är inte längre bara den generiska vektorn för "den". Den har nu absorberat den relevanta kontexten från hela meningen. Den nya vektorn kan bäst beskrivas som: "den-som-med-91%-säkerhet-är-bollen".

En viktig uppgradering: Multi-Head Attention

Förklaringen ovan är kraftfull, men den har en dold begränsning. Den beskriver en enda Attention-mekanism som måste lära sig att förstå alla sorters relationer i en mening på en och samma gång. I meningen om roboten måste den både förstå pronomen-syftningen ("den" -> "bollen") och den grammatiska strukturen (vem som gjorde vad). Det är som att be en enda person att samtidigt vara grammatikexpert, faktagranskare och stilanalytiker.

Lösningen är lika elegant som den är kraftfull: Multi-Head Attention.

Istället för att göra en Attention-beräkning (med ett set av Q, K, V-vektorer), gör man flera stycken (ofta 8 eller 12) helt parallellt. Man kan se det som att man tillsätter en expertkommitté för att analysera meningen. Varje "huvud" i kommittén får sin egen, oberoende uppsättning av Q, K, V-vektorer och kan därför lära sig att specialisera sig på olika sorters relationer.

När meningen "Roboten plockade upp bollen eftersom den var röd" analyseras, kan de olika huvudena fokusera på helt olika saker samtidigt:

• Huvud 1 (Pronomen-experten): Fokuserar, precis som i vårt exempel, nästan uteslutande på kopplingen mellan "den" och "bollen".
• Huvud 2 (Verb-experten): Fokuserar på handlings-relationer, som kopplingen mellan "plockade upp" och "bollen" (vad som blev upplockat).
• Huvud 3 (Grammatik-experten): Fokuserar på meningsstrukturen, kanske kopplingen mellan subjektet "Roboten" och verbet "plockade".
• ... och så vidare.

Efter att varje "experthuvud" har producerat sin egen, specialiserade version av de kontextualiserade vektorerna, finns det en sista mekanism som samlar in alla dessa insikter och väger samman dem till en enda, rik och mångfacetterad slutrepresentation för varje ord.

Resultatet är att modellen inte längre behöver välja en sak att fokusera på. Den kan samtidigt förstå att 'den' syftar på 'bollen' OCH att 'plockade upp' är något 'roboten' gjorde med 'bollen'. Detta ger en exponentiellt djupare och mer robust förståelse av språket, och är en av de absolut främsta anledningarna till att Transformer-arkitekturen är så framgångsrik.

Från Teori till Praktik: Attention i Python

Attention-mekanismen kan verka abstrakt, men kärnan är ren matris-matematik. För att avmystifiera processen ska vi implementera ett enkelt Attention-huvud från grunden med NumPy och visualisera resultatet.

Steg 1: Implementera Attention-matematiken

Koden nedan är en direkt översättning av de tre stegen vi diskuterade:

1. Beräkna råa poäng (Q • K^T).
2. Omvandla till vikter med softmax.
3. Beräkna den viktade summan av V.

Vi använder en enkel exempelmening och låtsas att vi redan har ord-vektorer (embeddings) för varje ord. För enkelhetens skull använder vi dessa embeddings direkt som våra Q, K och V-vektorer.

# attention_numpy.py
import numpy as np
import matplotlib.pyplot as plt

def softmax(x):
    e_x = np.exp(x - np.max(x)) # Subtrahera max för numerisk stabilitet
    return e_x / e_x.sum(axis=-1, keepdims=True)

def calculate_attention(queries, keys, values):
    # Steg 1: Beräkna råa poäng (dot product)
    scores = np.matmul(queries, keys.T)
    
    # Skalningsfaktor (vanligt i Transformers)
    d_k = keys.shape[-1]
    scaled_scores = scores / np.sqrt(d_k)
    
    # Steg 2: Beräkna vikter med softmax
    weights = softmax(scaled_scores)
    
    # Steg 3: Beräkna viktad summa av Värden
    output = np.matmul(weights, values)
    
    return output, weights

# Exempelmening och låtsas-embeddings (ord-vektorer)
# Varje ord är en vektor med 4 dimensioner
sentence = ["Roboten", "jagar", "katten"]
embeddings = np.array([
    [1, 0, 1, 0], # Roboten
    [0, 1, 0, 1], # jagar
    [1, 1, 1, 1]  # katten
])

# I en riktig Transformer skulle Q, K, V vara projektioner av embeddings.
# Här använder vi embeddings direkt för enkelhetens skull.
queries = embeddings
keys = embeddings
values = embeddings

# Beräkna den slutgiltiga, kontextuella representationen och vikterna
final_representation, attention_weights = calculate_attention(queries, keys, values)

print("Uppmärksamhetsvikter (hur varje ord tittar på de andra):")
print(attention_weights)

#### Steg 2: Visualisera Uppmärksamheten

Siffrorna i `attention_weights`-matrisen kan vara svåra att tolka. En heatmap är ett perfekt verktyg för att visualisera dem. Varje rad i matrisen visar vilket ord som ett visst ord "tittar" på.

# Visualisera med matplotlib
fig, ax = plt.subplots()
im = ax.imshow(attention_weights, cmap='viridis')

# Sätt upp axlarna med orden från meningen
ax.set_xticks(np.arange(len(sentence)))
ax.set_yticks(np.arange(len(sentence)))
ax.set_xticklabels(sentence)
ax.set_yticklabels(sentence)

# Rotera x-axelns etiketter för läsbarhet
plt.setp(ax.get_xticklabels(), rotation=45, ha="right", rotation_mode="anchor")

# Loopa över datan och skapa en text-annotering för varje cell
for i in range(len(sentence)):
    for j in range(len(sentence)):
        text = ax.text(j, i, f"{attention_weights[i, j]:.2f}",
                       ha="center", va="center", color="w")

ax.set_title("Self-Attention Visualiserad")
ax.set_xlabel("Ord som 'annonserar' sin nyckel (Key)")
ax.set_ylabel("Ord som 'frågar' efter kontext (Query)")
fig.tight_layout()
plt.show()

När du kör koden ser du en matris med siffror och en heatmap. Heatmapen visar en visuell representation av uppmärksamheten. Diagonalen är ofta ljusast, eftersom ett ord tenderar att vara mest relevant för sig själv. Men du kan också se hur andra ord, beroende på deras vektor-likhet, ger och tar uppmärksamhet från varandra. Detta är den grundläggande mekanismen som, när den skalas upp över många lager och huvuden, ger Transformers sin djupa kontextuella förståelse.

TODO Attention-mekanismen

En visuell representation av Attention-mekanismen. Visa en mening, t.ex. "Roboten plockade upp bollen eftersom den var röd". Ordet "den" är markerat. Pilar med olika tjocklek går från "den" till de andra orden i meningen. Pilen till "bollen" ska vara mycket tjockare än pilen till "roboten", för att visuellt visa att modellen har "förstått" att "den" syftar på bollen.

Byggsten 2: Bearbeta Insikterna (Feed-Forward Network)

Efter att Multi-Head Attention-mekanismen har vägt samman alla sina insikter till en enda, rik vektor för varje ord, är halva jobbet i ett Transformer-block gjort. Denna nya, kontextuella vektor skickas sedan vidare till nästa steg: ett enkelt, lokalt Feed-Forward Network (FFN).

Varje ords vektor processas här helt oberoende av de andra. Man kan se det som att varje ord, efter att ha samlat in all nödvändig kontext från sina grannar, nu får en stunds individuell "betänketid" för att bearbeta denna nya information. FFN-lagret ger nätverket ytterligare beräkningsdjup och förmågan att utföra mer komplexa transformationer på den information som Attention-steget har samlat in.

Tillsammans utgör dessa två sub-lager – Multi-Head Attention följt av ett Feed-Forward Network – ett komplett Transformer-block. En fullständig modell som GPT-3 består av nästan hundra sådana block staplade på varandra, där outputen från ett block blir input till nästa, vilket skapar en allt djupare och mer abstrakt förståelse av texten för varje lager.

Byggsten 3: Positionskodning - Ordens Postnummer

Den parallella naturen hos Attention-mekanismen är dess största styrka, men den skapar också ett omedelbart och uppenbart problem. Om nätverket bara ser alla ord i en "säck" samtidigt, hur kan det då förstå den avgörande skillnaden mellan meningarna:

• "Kungen gav drottningen en ros."
• "Drottningen gav kungen en ros."

Utan information om ordens position skulle dessa två meningar se nästan identiska ut för modellen. Ordningen är allt. För att lösa detta introducerade Transformer-arkitekturen Positionskodning (Positional Encoding).

Idén är att "injicera" information om varje ords plats direkt in i dess vektorrepresentation. Innan ord-vektorerna skickas in i det första Transformer-blocket, adderas en unik "matematisk signatur" till varje vektor. Det geniala ligger i hur denna signatur skapas: med en kombination av sinus- och cosinusvågor med olika frekvenser.

Varför just sinus och cosinus? För att deras periodiska, vågliknande natur ger modellen ett extremt smart sätt att förstå relativa positioner. Eftersom avståndet mellan, säg, position 3 och 4 är detsamma som mellan position 8 och 9, kan relationen mellan deras positions-signaturer representeras som en enkel, konsekvent transformation. Modellen behöver inte lära sig varje position utantill; den kan lära sig det generella konceptet "ordet efter". Genom att använda vågor med olika frekvenser för varje dimension i vektorn, får varje position i meningen en helt unik, men ändå relationell, signatur.

Resultatet är en hybridvektor som bär på dubbel information: [Vektor för "Kungen"] + [Vektor för "Position 1"] = [En Kungen-som-är-på-första-plats]. Även om Attention-mekanismen sedan blandar ihop alla ord, bär varje ord med sig en outplånlig signal om sin ursprungliga plats.

Byggsten 4: Encoder & Decoder - Ett Samtal Mellan En Läsare och En Skribent

Nu när vi har våra tre grundläggande verktyg – Attention, Feed-Forward Networks och Positionskodning – kan vi bygga ihop hela arkitekturen.

Den ursprungliga utmaningen som Transformern designades för att lösa var ett av de svåraste problemen inom språkteknologi: maskinöversättning. Att översätta en mening från ett språk till ett annat kräver inte bara att man förstår orden, utan också den djupa kontexten och relationerna mellan dem.

Tidigare arkitekturer, som LSTMs, hade också försökt lösa detta med en liknande idé om en "läsare" och en "skribent", men de led av sin inbyggda flaskhals. LSTM-läsaren var tvungen att pressa in innebörden av en hel mening i ett enda, komprimerat minne (en vektor). Skribenten fick sedan bara denna enda, stressade sammanfattning att arbeta med. Det var som att be någon översätta en bok efter att bara ha läst en kort baksidestext.

Transformern revolutionerade denna process genom att låta läsaren och skribenten ha ett mycket rikare och mer direkt samtal. Arkitekturen delades elegant upp i två specialiserade delar, en Encoder-stack och en Decoder-stack, som båda är uppbyggda av flera lager.

1. Encodern (Läsaren): Dess enda jobb är att läsa och förstå källtexten (t.ex. en engelsk mening). Men istället för att skapa en sammanfattning, använder den sina lager av Attention-mekanismer för att bygga en djupt kontextuell förståelse av varje ord i relation till alla andra ord. Resultatet är inte en enda vektor, utan en hel uppsättning av rika, kontextualiserade vektorer – en för varje ord. Det är som att läsaren inte bara sammanfattar boken, utan ger skribenten en version med understrykningar, kommentarer och pilar som visar hur alla begrepp hänger ihop.

2. Decodern (Skribenten): Dess jobb är att generera måltexten (t.ex. den svenska översättningen), ett ord i taget. Men för varje nytt ord den ska skriva har den en superkraft. Den kan titta tillbaka på två saker genom två olika Attention-mekanismer:

   • 1. De svenska ord den redan har skrivit: Precis som ett RNN ser den till att den nya meningen är grammatiskt sammanhängande. Denna Attention-mekanism är "maskerad" – den får bara titta på orden till vänster (de som redan skrivits), inte fuska genom att titta in i framtiden.
   • 2. Hela Encoderns kommenterade text: Detta är det geniala. Genom en andra Attention-mekanism kan Decodern ställa en fråga till Encoderns output: "För det svenska ord jag ska skriva nu, vilket av de engelska orden är absolut viktigast att titta på?" När den ska översätta 'it' i meningen 'The robot picked up the ball because it was red', kan den rikta all sin uppmärksamhet mot Encoderns vektor för 'ball', och därmed förstå att det svenska ordet ska vara 'den' och inte 'det'.

Detta samarbete mellan en läsare som skapar en rik, kommenterad förståelse och en skribent som intelligent kan slå upp information i den, var ett enormt genombrott.

Variationer på Transformern

Medan den ursprungliga Transformer-arkitekturen var en elegant duo för översättning, insåg forskare snabbt att dess två delar hade unika superkrafter på egen hand. Detta ledde till att fältet delades i två huvudsakliga filosofier och arkitekturer, som båda använde Transformer-blocket som sin kärna.

1. Decoder-Only: Den Kreativa Skribenten (GPT-familjen)

En gren av forskningen, ledd av OpenAI, ställde frågan: "Vad händer om vi bara använder Decodern (Skribenten) och tränar den på en extremt enkel uppgift: att förutsäga nästa ord i en text?"

Denna arkitektur är i grunden autoregressiv – den tittar bara bakåt på de ord den redan har skrivit för att generera nästa. Den är en fantastisk textkompletterare. Genom att träna den på nästan hela det öppna internet lärde den sig inte bara språk, utan även mönster av resonemang, fakta och kod. Detta är vägen som ledde till Generative Pre-trained Transformers (GPT) och de stora språkmodeller vi känner till idag.

2. Encoder-Only: Den Allvetande Kritikern (BERT-familjen)

Samtidigt ställde en annan forskargrupp på Google en annan fråga: "Vad händer om vi bara använder Encodern (Läsaren) för att skapa den djupaste möjliga förståelsen av en befintlig text?"

Resultatet blev BERT (Bidirectional Encoder Representations from Transformers). Till skillnad från GPT, som bara läser från vänster till höger, kan en Encoder-arkitektur se hela meningen på en gång. BERT utnyttjar detta fullt ut genom att vara bidirektionell – den kan använda både orden före och efter ett ord för att förstå dess sanna innebörd.

BERT tränades inte på att förutsäga nästa ord. Istället gavs den en genial uppgift kallad Masked Language Modeling (MLM). Man tog en mening, dolde 15% av orden ([MASK]), och bad modellen att gissa vilka ord som saknades, baserat på den omgivande kontexten.

• Exempel: "Jag gick till ___ för att köpa en liter ___."

För att lösa detta måste modellen utveckla en otroligt djup förståelse för språk och sammanhang. Denna förmåga gjorde BERT till kungen av Natural Language Understanding (NLU). Den var inte designad för att skriva poesi, utan för att analysera text. Den blev grunden för system som kan utföra sentimentanalys, svara på frågor om en text, och den drev den största uppdateringen av Google Sök på flera år, eftersom den var så bra på att förstå den verkliga avsikten bakom en sökfråga.

Medan GPT-familjen blev experter på generering, blev BERT-familjen experter på förståelse.

Byggsten 5: Skalningens Magiska Effekt - Från Transformer till LLM

Medan den ursprungliga arkitekturen var designad för översättning, upptäckte forskare snabbt att man kunde använda bara en del av den – oftast Decodern – för en mycket enklare men kraftfullare uppgift: att förutsäga nästa ord.

De upptäckte också en nästan magisk egenskap. Genom att följa "Scaling Laws" (Skalningslagar), en uppsättning empiriska observationer från bl.a. OpenAI, fann man ett förutsägbart, närmast lagbundet förhållande: om man exponentiellt ökade tre saker – 1) antalet parametrar (nätverkets storlek), 2) storleken på träningsdatasetet, och 3) mängden beräkningskraft – så blev modellen inte bara lite bättre på sin uppgift. Den började utveckla helt nya, emergenta förmågor som inte explicit hade programmerats in.

Detta är steget från en Transformer till en Stor Språkmodell (Large Language Model, LLM). En LLM som tränats på i princip hela det öppna internet lär sig inte bara grammatik. Genom att se miljarder exempel lär den sig att:

• Sammanfatta långa texter.
• Svara på frågor om fakta den "läst".
• Skriva kod i olika programmeringsspråk.
• Resonera i enkla steg.

Dessa emergenta förmågor är inte längre helt mystiska. Skalningslagarna visar att de är en förutsägbar, om än extraordinär, konsekvens av att massivt skala upp arkitekturen. Ingenjörerna designade ett system för att förutsäga nästa ord, men genom ren och skär skala började det uppvisa drag av mer generell intelligens.

Röst från förr: Utdrag ur "Attention Is All You Need" (2017)

"The dominant sequence transduction models are based on complex recurrent or convolutional neural networks that include an encoder and a decoder. The best performing models also connect the encoder and decoder through an attention mechanism. We propose a new simple network architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence and convolutions entirely."

...tasks show these models to be superior in quality while being more parallelizable and requiring significantly less time to train [...] We are excited about the future of attention-based models and plan to apply them to other tasks."

Guidad analys

Nyckelorden är "simple network architecture" och "dispensing with recurrence and convolutions entirely". Forskarna hade hittat ett sätt att uppnå bättre resultat genom att ta bort komplexitet, inte lägga till den. De insåg att uppmärksamhetsmekanismen i sig var så kraftfull att de gamla, långsamma sekventiella metoderna (RNNs) inte längre behövdes. De var också optimistiska över möjligheten att de hade skapat en generell arkitektur som skulle kunna användas för en mängd andra uppgifter. De hade rätt.

Transformers blev snabbt grunden för alla moderna LLMs, som GPT-serien från OpenAI, Gemini från Google och Llama från Meta.

Svensk kontext: GPT-SW3

Att träna dessa modeller är extremt resurskrävande. För att säkerställa att det finns kraftfulla språkmodeller som är anpassade för det svenska språket och kulturen, startade forskningskonsortiet AI Sweden projektet GPT-SW3. Målet är att skapa en grundmodell för svenska som kan användas av företag, myndigheter och forskare i Sverige, vilket minskar beroendet av de stora amerikanska modellerna.

Case in Point: Hur BERT Förändrade Google Sök

Innan Transformer-arkitekturen förlitade sig sökmotorer som Google mest på att matcha nyckelord. De var bra på att förstå vilka ord du skrev, men inte alltid vad du menade. Små ord som "för" eller "till" ignorerades ofta.

BERT, med sin förmåga att läsa en hel mening i båda riktningarna samtidigt (bidirektionell), ändrade allt detta. Plötsligt kunde Google förstå den avgörande rollen som prepositioner och sammanhang spelar.

• Gammal sökning: "brazilian traveler to usa visa"
  • Resultat: En blandning av resultat för amerikanska medborgare som reser till Brasilien.
• Sökning med BERT: "brazilian traveler to usa visa"
  • Resultat: BERT förstår att "to" är kritiskt. Sökningen handlar om en brasilianare som reser till USA. Resultaten blir omedelbart mycket mer relevanta.

Google kallade detta den största enskilda förbättringen av sin sökmotor på fem år. Det är ett perfekt exempel på hur Encoder-arkitekturens djupa språkförståelse (NLU) fick en omedelbar och enorm praktisk betydelse.

Etiskt vägskäl: "Garbage In, Garbage Out" - Bias i LLMs

En språkmodell är en spegel av den data den tränas på. Eftersom LLMs tränas på enorma mängder text från internet, lär de sig oundvikligen att reflektera och förstärka de fördomar, stereotyper och den toxicitet som finns i vårt samhälle. Detta är inte ett teoretiskt problem; det är ett bevisat faktum.

• Exempel: Om träningsdatan historiskt har associerat yrket "läkare" med pronomenet "han" och "sjuksköterska" med "hon", kommer modellen att lära sig och reproducera denna könsstereotyp. Om den ombeds att "skriva en berättelse om en VD", är det statistiskt sannolikt att den skapar en manlig karaktär.

Detta leder till ett av de svåraste etiska problemen inom AI: Frågan: Vem är ansvarig för att hantera denna bias?

• Är det utvecklarna, som borde "tvätta" datan eller bygga in algoritmiska skyddsräcken?
• Är det företagen som använder modellerna, som borde ha riktlinjer för hur de får användas?
• Är det användarna, som borde vara medvetna om och kritiska till modellernas output?

Att "fixa" bias är extremt svårt. Att försöka ta bort den helt riskerar att införa nya, subtila fördomar eller en specifik, påtvingad världsbild. Detta är en pågående teknisk och filosofisk kamp utan enkla svar.

Perspektiv på den nya språkåldern

Det filosofiska perspektivet: Det Kinesiska Rummet

Precis när det verkade som att AI var på väg att knäcka koden till sann språkförståelse, återvände en gammal filosofisk invändning med full kraft. Filosofen John Searles tankeexperiment från 1980, "Det Kinesiska Rummet", blev mer relevant än någonsin.

Tankeexperimentet går så här: Föreställ dig en person som inte kan ett enda ord kinesiska, instängd i ett rum. Genom en lucka får personen in papperslappar med kinesiska tecken (frågor). I rummet finns en enorm regelbok som på engelska exakt beskriver vilka kinesiska tecken personen ska skicka ut som svar på de tecken som kom in. Personen följer reglerna, hittar rätt symboler och skickar ut dem. För en person utanför rummet ser det ut som att rummet perfekt förstår kinesiska.

TODO Det Kinesiska Rummet

En illustration av det Kinesiska Rummet. Man ser en person inuti en låda. Personen tittar förvirrat på en kinesisk symbol och slår frenetiskt i en gigantisk regelbok. Personen skickar sedan ut en annan kinesisk symbol genom en lucka, till en person utanför som ser nöjd ut och tror att den pratar med någon som kan kinesiska.

Searles poäng är: Även om rummet kan ge perfekta svar, finns det någon eller något i rummet som förstår kinesiska? Svaret är nej. Personen manipulerar bara symboler enligt regler, utan någon som helst förståelse för deras innebörd.

Searle menar att en LLM är precis som det kinesiska rummet. Den har lärt sig de statistiska sambanden mellan ord och kan manipulera dessa symboler för att ge övertygande svar, men den "förstår" inte vad den säger. Den har syntax (reglerna för hur symboler kombineras), men ingen semantik (förståelse för symbolernas innebörd). Detta är den mest centrala och seglivade kritiken mot moderna språkmodeller.

Det ekonomiska perspektivet: Plattformskriget 2.0

LLMs är inte bara en teknisk innovation; de har lagt grunden för en storskalig ekonomisk strid. Insikten är att den som kontrollerar den ledande AI-plattformen kommer att ha en enorm makt över framtidens digitala ekonomi, precis som Microsoft hade med Windows och Google med sin sökmotor.

Detta förklarar varför Microsoft satsade allt på OpenAI och investerade miljarder dollar. Genom att integrera OpenAIs modeller i sina produkter (Bing, Office, etc.) hoppades de kunna utmana Googles dominans. Detta startade ett nytt plattformskrig, där techjättarna nu tävlar om att skapa det mest kraftfulla och mest använda AI-ekosystemet.

För kunskapsyrken (jurister, programmerare, journalister, etc.) innebär detta en förändring. Frågan är inte längre om AI kommer att påverka dessa jobb, utan hur. Debatten handlar om Automation vs. Augmentation: kommer AI att helt ersätta dessa yrken, eller kommer den att bli ett kraftfullt verktyg som förstärker de mänskliga experterna? Eller är det möjligt att kvalitén på det som genereras är sådant att nya yrkesroller kommer skapas för att hantera/göra om det som potentiellt inte möter en viss standard? Det är inte omöjligt att den som tidigare skapade finner sig i en situation där den spenderar samma tid på att styra och rätta ett skapande artificiellt system. Tiden och nya versioner av LLMs kommer visa i vilken riktning dessa yrken blir påverkade.

En ny industriell revolution?

Vissa ekonomer jämför införandet av LLMs med tidigare General Purpose Technologies (GPTs), som ångmaskinen eller elektriciteten. Dessa var teknologier som inte bara förbättrade en enskild industri, utan fundamentalt förändrade hela ekonomin och samhället. Frågan är om denna nuvarande våg av AI kommer att ha en lika stor effekt.

Det kognitiva & psykologiska perspektivet: Intellektuellt Hantverk vs. Kognitiv Avlastning

Vad händer med vårt eget tänkande när vi ständigt har tillgång till en maskin som kan ge oss omedelbara svar? Författaren Nicholas Carr har varnat i flera böcker om hur användandet av internet och datorer omformar våra hjärnor.

Citat

“If we’re not careful, the automation of mental labor, by changing the nature and focus of intellectual endeavor, may end up eroding one of the foundations of culture itself: our desire to understand the world. Predictive algorithms may be supernaturally skilled at discovering correlations, but they’re indifferent to the underlying causes of traits and phenomena. Yet it’s the deciphering of causation—the meticulous untangling of how and why things work the way they do—that extends the reach of human understanding and ultimately gives meaning to our search for knowledge. If we come to see automated calculations of probability as sufficient for our professional and social purposes, we risk losing or at least weakening our desire and motivation to seek explanations, to venture down the circuitous paths that lead toward wisdom and wonder. Why bother, if a computer can spit out “the answer” in a millisecond or two?”

Nicholas Carr, The Glass Cage: How Our Computers Are Changing Us

Med LLMs blir denna fråga ännu mer akut. Att skriva en argumenterande text, att brottas med en svår fråga eller att strukturera sina tankar är ett intellektuellt hantverk som kräver övning. När vi lägger ut detta arbete på en AI riskerar vi det som kallas kognitiv avlastning. Vi tappar vår egen förmåga, precis som en person som alltid använder GPS tappar sin lokalkännedom. Risken är inte att AI:n blir smartare än oss, utan att vi blir latare och mindre benägna att utföra det ansträngande mentala arbete som leder till äkta lärande och insikt.

Det sociologiska perspektivet: Ensam tillsammans?

Forskaren Sherry Turkle har i sin bok Alone Together beskrivit en paradox i vår digitala tidsålder: teknologin lovar oss ständig uppkoppling och sällskap, men kan i själva verket leda till ökad isolering. Vi ersätter djupa, men stökiga och krävande, mänskliga relationer med ytliga, men enkla och kontrollerbara, digitala interaktioner.

AI-kompanjoner och alltmer sofistikerade chatbots är den ultimata versionen av denna paradox. De erbjuder en perfekt simulerad relation – en vän som alltid finns där, alltid är på gott humör och aldrig ställer några krav. Detta kan vara ett värdefullt stöd för ensamma människor, men det väcker också svåra frågor. Vad händer med vår förmåga att hantera verkliga, komplicerade mänskliga relationer om vi vänjer oss vid den friktionsfria AI-versionen? Detta är ELIZA-effekten på steroider, där gränsen mellan verktyg och vän blir allt suddigare.

Populärkulturens Spegel: Den Relationella Partnern och Verklighetens Upplösning

Artefakt 1: Samantha i Her (2013). Denna film är en perfekt illustration av Sherry Turkles "Alone Together"-paradox. Den förutsåg på ett kusligt sätt de sociala och psykologiska konsekvenserna av att ha en relation med en avancerad LLM och utforskar teman som ensamhet, kärlek och medvetande utan kropp. Filmen ställer den avgörande frågan: Kan en relation med en AI vara "äkta", och vad betyder ens det ordet när den ena parten kan ha tusentals likadana "äkta" relationer samtidigt?

Artefakt 2: The Matrix (1999). Även om filmen är äldre, har dess centrala koncept aldrig varit mer relevant. Den blir den ultimata illustrationen för "Det Kinesiska Rummet"-argumentet i praktiken. Neo är fången i ett system som perfekt kan simulera varje input och output av verkligheten, men utan att ha någon "äkta" förståelse eller koppling till den. I en tid av deepfakes och AI-genererat innehåll ställer The Matrix den avgörande frågan: Om en AI kan generera en verklighet som är helt övertygande, hur kan vi då någonsin veta vad som är sant? Är du blue eller red pilled?

Verklighetens upplösning

Kombinationen av kraftfulla språkmodeller och bildgenereringsmodeller skapar en ny, fundamental utmaning: epistemisk säkerhet. Det vill säga, hur kan vi veta vad som är sant? När det blir trivialt att skapa övertygande falska texter, bilder och videor, eroderas vår gemensamma grund av fakta. Detta är inte bara ett tekniskt problem, utan ett hot mot grunden för journalistik, vetenskap och till och med demokrati.

Övningar

Transformer, GPT & LLM

I detta kapitel går vi från den teoretiska förståelsen av Transformers till att praktiskt interagera med dem. Övningarna är designade för att du, steg för steg, ska få en känsla för de olika "personligheterna" hos dessa modeller, de matematiska vektorerna de bygger på, och den magiska mekanismen som driver dem (Attention).

Verktyg: Visual Studio Code med en Python-installation. Vi kommer att använda det populära biblioteket transformers från Hugging Face.

Förberedelser: Installation

Innan vi börjar, öppna en terminal i VS Code och installera de bibliotek vi behöver. Vi använder PyTorch som bakgrundsmotor.

pip install transformers torch

---

Övning 1: Under ytan - Från Ord till Kontextuella Vektorer

Syfte: Att praktiskt utforska de två mest grundläggande koncepten: hur ord blir till vektorer i ett "meningsrum" (embeddings) och hur Transformer-modellen magiskt förändrar dessa vektorer baserat på kontext.

1. Skapa en fil: Skapa en ny fil med namnet vectors_deep_dive.py.
2. Importera och förbered: Klistra in denna grundkod som laddar en svensk BERT-modell och dess tokenizer.

   import torch
   from transformers import AutoTokenizer, AutoModel
   
   # Ladda en förtränad svensk BERT-modell och dess tokenizer.
   model_name = "KB/bert-base-swedish-cased"
   tokenizer = AutoTokenizer.from_pretrained(model_name)
   model = AutoModel.from_pretrained(model_name)

Del 1: Ordens Adress i Meningsrummet (Word Embeddings)

Här ska vi se hur ord med liknande betydelse har vektorer som ligger "nära" varandra.

1. Lägg till koden: Klistra in denna kod under den föregående. Den isolerar de råa ordvektorerna och jämför dem.

   # Ord vi vill jämföra
   words = ["kung", "drottning", "man", "kvinna", "äpple"]
   
   # Hämta modellens embedding-lager
   embeddings = model.get_input_embeddings()
   
   # Hämta ID:n för våra ord
   word_ids = tokenizer(words, add_special_tokens=False, padding=True, return_tensors="pt")["input_ids"]
   
   # Hämta de faktiska vektorerna (embeddings) för varje ord
   word_vectors = embeddings(word_ids).detach()
   
   # Jämför "kung" med de andra orden med hjälp av cosinus-likhet
   # (Ett mått på hur lika riktning två vektorer har. 1 = identiska, 0 = olika)
   kung_vec = word_vectors[0]
   drottning_vec = word_vectors[1]
   man_vec = word_vectors[2]
   kvinna_vec = word_vectors[3]
   apple_vec = word_vectors[4]
   
   print("--- Del 1: Råa Ordvektorer ---")
   print(f"Likhet(kung, drottning): {torch.nn.functional.cosine_similarity(kung_vec, drottning_vec, dim=0):.2f}")
   print(f"Likhet(kung, man):       {torch.nn.functional.cosine_similarity(kung_vec, man_vec, dim=0):.2f}")
   print(f"Likhet(kung, kvinna):     {torch.nn.functional.cosine_similarity(kung_vec, kvinna_vec, dim=0):.2f}")
   print(f"Likhet(kung, äpple):      {torch.nn.functional.cosine_similarity(kung_vec, apple_vec, dim=0):.2f}")

2. Kör och Reflektera: Kör skriptet. Notera hur likheten mellan "kung" och "man"/"drottning" är mycket högre än likheten med "äpple". Du har nu matematiskt bevisat att modellen har lärt sig semantiska relationer. Detta är grunden som Attention-mekanismen bygger vidare på.

Del 2: Kontextens Makt (Final Hidden States)

Nu ska vi se hur hela Transformer-modellen förändrar ett ords vektor baserat på meningen det befinner sig i.

1. Lägg till koden: Klistra in denna sista del i din fil.

   # Tre meningar där ordet "bank" har helt olika betydelser
   sentence1 = "Jag satt på en bank vid ån."
   sentence2 = "Jag behöver gå till en bank för att ta ett lån."
   sentence3 = "Jag behöver sätta in pengar på min bank."
   
   # Tokenisera meningarna
   inputs1 = tokenizer(sentence1, return_tensors="pt")
   inputs2 = tokenizer(sentence2, return_tensors="pt")
   inputs3 = tokenizer(sentence3, return_tensors="pt")
   
   # Hitta positionen för ordet "bank" i varje mening
   bank_token_pos1 = torch.where(inputs1['input_ids'][0] == tokenizer.convert_tokens_to_ids("bank"))[0]
   bank_token_pos2 = torch.where(inputs2['input_ids'][0] == tokenizer.convert_tokens_to_ids("bank"))[0]
   bank_token_pos3 = torch.where(inputs3['input_ids'][0] == tokenizer.convert_tokens_to_ids("bank"))[0]
   
   # Kör hela meningen genom modellen
   with torch.no_grad():
       output1 = model(**inputs1)
       output2 = model(**inputs2)
       output3 = model(**inputs3)
   
   # Hämta den *slutgiltiga*, kontextualiserade vektorn för "bank" från varje mening
   bank_final_vec1 = output1.last_hidden_state[0, bank_token_pos1, :].squeeze()
   bank_final_vec2 = output2.last_hidden_state[0, bank_token_pos2, :].squeeze()
   bank_final_vec3 = output3.last_hidden_state[0, bank_token_pos3, :].squeeze()
   
   print("\n--- Del 2: Kontextens Makt ---")
   print(f"Likhet mellan 'bank' (ån) och 'bank' (lån): {torch.nn.functional.cosine_similarity(bank_final_vec1, bank_final_vec2, dim=0):.2f}")
   print(f"Likhet mellan 'bank' (lån) och 'bank' (pengar): {torch.nn.functional.cosine_similarity(bank_final_vec2, bank_final_vec3, dim=0):.2f}")

2. Kör och Reflektera: Kör skriptet igen. Se hur likheten mellan de två "bank"-vektorerna nu är mycket låg. Trots att de började som samma råa ordvektor, har Attention-mekanismen tryckt isär dem i meningsrummet baserat på deras olika kontexter. Detta är Transformer-arkitekturens magi i praktiken: den skapar kontextuella vektorer.

Reflektera

• Varför är likheten hög mellan 'bank' i meningen om lån och pengar, men låg jämfört med 'bank' i meningen om ån? Vad säger detta om hur modellen grupperar koncept?

---

Övning 2: Visualisera Ordens Postnummer (Positional Encoding)

Syfte: Att visuellt förstå hur sinus- och cosinusvågor med olika frekvenser kan ge varje ord i en sekvens en unik positionssignatur.

1. Installera ett extra bibliotek: Vi behöver matplotlib för att rita grafen.

   
   pip install matplotlib numpy
   

2. Skapa en fil: Skapa filen visualize_positional_encoding.py.

3. Skriv koden: Klistra in följande skript. Det skapar och plottar de positionella kodningarna för en kort sekvens.

   
   import numpy as np
   
   import matplotlib.pyplot as plt
   
   
   
   def get_positional_encoding(seq_len, d_model):
   
       """
   
       Genererar positionell kodning.
   
       :param seq_len: Längden på sekvensen (antal ord).
   
       :param d_model: Dimensionen på embedding-vektorn.
   
       """
   
       position = np.arange(seq_len)[:, np.newaxis]
   
       div_term = np.exp(np.arange(0, d_model, 2) * -(np.log(10000.0) / d_model))
   
       
   
       pe = np.zeros((seq_len, d_model))
   
       pe[:, 0::2] = np.sin(position * div_term)
   
       pe[:, 1::2] = np.cos(position * div_term)
   
       
   
       return pe
   
   
   
   # Parametrar
   
   sequence_length = 20  # Antal ord i vår hypotetiska mening
   
   embedding_dim = 128   # Storleken på ordvektorerna
   
   
   
   # Hämta kodningen
   
   pos_encoding = get_positional_encoding(sequence_length, embedding_dim)
   
   
   
   # Visualisera
   
   plt.figure(figsize=(12, 8))
   
   plt.pcolormesh(pos_encoding, cmap='viridis')
   
   plt.xlabel('Embedding Dimension')
   
   plt.xlim((0, embedding_dim))
   
   plt.ylabel('Position in Sequence')
   
   plt.ylim((sequence_length, 0))
   
   plt.colorbar()
   
   plt.title("Positional Encoding")
   
   plt.show()
   

4. Kör och Analysera: Kör skriptet. Du ser en matris där varje rad är en position i meningen och varje kolumn är en dimension i vektorn.

   • Notera de vågliknande mönstren. De första dimensionerna (vänster) har långa vågor (låg frekvens), medan de sista (höger) har korta, snabba vågor (hög frekvens).

   • Varje rad (position) har en unik kombination av värden från dessa olika vågor.

Reflektera

Notera hur varje position har en unik kombination av värden från de olika vågorna. Hur gör denna unika, men relationella, 'signatur' det möjligt för modellen att förstå ordföljd även när den processar allt parallellt?

---

Övning 3: Visualisera Attention-mekanismen

Syfte: Att avmystifiera "Attention" genom att visuellt se exakt vilka ord en Transformer-modell fokuserar på när den analyserar en mening. Detta är den tekniskt mest avancerade övningen, men ger en djup insikt.

1. Installera ett extra bibliotek: Vi behöver matplotlib för att rita grafen.

   
   pip install matplotlib
   

2. Skapa en fil: Skapa filen visualize_attention.py.

3. Skriv koden: Denna kod är mer komplex. Vi måste manuellt ladda modellen och dess "tokenizer" (som omvandlar ord till siffror) för att komma åt de interna attention-vikterna.

   
   import torch
   
   import matplotlib.pyplot as plt
   
   from transformers import AutoTokenizer, AutoModel
   
   
   
   # 1. Ladda modell och tokenizer. Vi ber specifikt om attention-vikterna.
   
   model_name = "KB/bert-base-swedish-cased"
   
   tokenizer = AutoTokenizer.from_pretrained(model_name)
   
   model = AutoModel.from_pretrained(model_name, output_attentions=True)
   
   
   
   # 2. Välj meningen från läroboken.
   
   sentence = "Roboten plockade upp bollen eftersom den var röd."
   
   
   
   # 3. Tokenisera meningen och skicka den genom modellen.
   
   inputs = tokenizer(sentence, return_tensors="pt")
   
   outputs = model(**inputs)
   
   attention = outputs.attentions # Hämta ut attention-vikterna
   
   
   
   # 4. Hämta tokens och förbered för visualisering.
   
   tokens = tokenizer.convert_ids_to_tokens(inputs["input_ids"][0])
   
   # Vi tar sista lagrets attention och medelvärdesbildar över alla "huvuden".
   
   attention_last_layer = attention[-1][0].mean(dim=0).detach().numpy()
   
   
   
   # 5. Skapa och visa grafen med matplotlib.
   
   fig, ax = plt.subplots(figsize=(8, 8))
   
   im = ax.imshow(attention_last_layer, cmap='viridis')
   
   
   
   ax.set_xticks(range(len(tokens)))
   
   ax.set_yticks(range(len(tokens)))
   
   ax.set_xticklabels(tokens, rotation=90)
   
   ax.set_yticklabels(tokens)
   
   fig.colorbar(im, ax=ax)
   
   plt.title("Attention-mönster (sista lagret)")
   
   plt.tight_layout()
   
   plt.show()
   

4. Kör och Analysera: Kör skriptet (python visualize_attention.py).

   • Ett fönster med en färgglad matris dyker upp. Varje rad och kolumn representerar ett ord i meningen. En ljus (gul) ruta i korsningen mellan rad "X" och kolumn "Y" betyder att ordet "X" riktar stark uppmärksamhet mot ordet "Y".

   • Hitta raden för ordet "den". Vilken kolumn är ljusast på den raden? Är det, som vi hoppades, kolumnen för "bollen"?

   • Experimentera: Ändra sentence-variabeln till: "Kungen gav drottningen en ros eftersom han var generös.". Kör om skriptet. Hitta raden för ordet "han". Vilket ord får högst uppmärksamhet nu?

Reflektera

• Du har nu sett den matematiska kärnan i en Transformer. Denna matris av vikter är exakt det som gör att modellen kan förstå komplexa relationer i en mening parallellt. Hur skiljer sig detta från hur ett RNN tvingas processa en mening, ett ord i taget?

• Jämför de två meningarna du körde. Hur bevisar resultaten att modellen förstår grammatiska och kontextuella skillnader för att korrekt tolka pronomen som "den" och "han"?

---

Övning 4: "Kritikern" i Aktion (BERT & Masked Language Modeling)

Syfte: Att praktiskt uppleva hur en Encoder-Only-modell som BERT använder sin dubbelriktade förståelse för att fylla i saknad information i en text, precis som i träningsuppgiften Masked Language Modeling (MLM).

1. Skapa en fil: Skapa en ny fil med namnet bert_critic.py.

2. Använd en Pipeline: Hugging Face pipeline är det enklaste sättet att använda en förtränad modell. Den hanterar all komplexitet med tokenisering och databearbetning åt oss.

   
   from transformers import pipeline
   
   
   
   # 1. Ladda en pipeline för "fill-mask". 
   
   # Vi använder en svensk version av BERT från Kungliga biblioteket.
   
   fill_mask = pipeline(
   
       "fill-mask",
   
       model="KB/bert-base-swedish-cased"
   
   )
   
   
   
   # 2. Definiera en text med ett maskerat ord.
   
   # [MASK] är den speciella token som modellen är tränad att fylla i.
   
   text = "Jag gick till affären för att köpa en liter [MASK]."
   
   
   
   # 3. Be modellen att ge sina bästa gissningar.
   
   predictions = fill_mask(text)
   
   
   
   # 4. Skriv ut resultaten på ett snyggt sätt.
   
   print(f"Originaltext: {text}\n")
   
   print("Modellens bästa gissningar:")
   
   for prediction in predictions:
   
       # 'token_str' är ordet, 'score' är modellens självförtroende.
   
       print(f"- {prediction['token_str']} (Sannolikhet: {prediction['score']:.2%})")
   

3. Kör och Experimentera: Kör skriptet (python bert_critic.py).

   • Vilka ord föreslog modellen? Verkar de rimliga?

   • Ändra meningen till något mer tvetydigt, t.ex. Stockholm är Sveriges [MASK].. Vad gissar den nu?

   • Prova Kungen gav [MASK] en ros.. Jämför med Drottningen gav [MASK] en ros.. Ser du hur kontexten före och efter masken påverkar resultatet? Detta är BERT:s superkraft.

Reflektera

Du har nu interagerat med en Encoder-Only-modell. Den är inte designad för att skriva långa texter, utan för att ha en djup, kontextuell förståelse av befintlig text. Hur skulle denna förmåga kunna användas i Google Sök för att bättre förstå vad du menar?

---

Övning 5: "Kreatören" i Aktion (GPT & Textgenerering)

Syfte: Att se hur en Decoder-Only-modell som GPT använder sin autoregressiva (vänster-till-höger) förmåga för att fortsätta en text och generera nytt, sammanhängande innehåll.

1. Skapa en fil: Skapa en ny fil med namnet gpt_creator.py.

2. Använd en Textgenererings-pipeline: Vi använder samma pipeline-koncept, men för en annan uppgift.

   
   from transformers import pipeline
   
   
   
   # 1. Ladda en pipeline för "text-generation".
   
   # Vi använder en mindre svensk GPT-modell för att det ska gå snabbt.
   
   generator = pipeline(
   
       "text-generation",
   
       model="birgert/swedish-gpt"
   
   )
   
   
   
   # 2. Skriv en startprompt för modellen att fortsätta.
   
   prompt = "Det var en mörk och stormig natt och"
   
   
   
   # 3. Be modellen att generera en fortsättning.
   
   # max_length sätter en gräns för hur lång den totala texten får bli.
   
   # num_return_sequences ger oss flera olika förslag.
   
   outputs = generator(prompt, max_length=50, num_return_sequences=3)
   
   
   
   # 4. Skriv ut resultaten.
   
   print(f"Startprompt: {prompt}...\n")
   
   print("Modellens genererade texter:")
   
   for i, output in enumerate(outputs):
   
       print(f"{i+1}: {output['generated_text']}")
   

3. Kör och Experimentera: Kör skriptet (python gpt_creator.py).

   • Jämför de olika förslagen. Är de lika varandra?

   • Kör skriptet igen. Får du exakt samma resultat? Varför/varför inte? (Svar: Det finns en inbyggd slumpmässighet för att öka kreativiteten).

   • Ändra prompt till början på en nyhetstext, en dikt eller en teknisk beskrivning. Ser du hur modellen anpassar sin stil?

Reflektera

Du har nu sett en Decoder-Only-modell i aktion. Den tittar bara på texten som redan skrivits för att förutsäga nästa ord. Jämför detta med BERT-övningen. Vad är den fundamentala skillnaden i deras "personligheter" och uppgifter?

---

Övning 6 (Bonus): Finjustera en språkmodell för en specifik uppgift

Syfte: Att få praktisk erfarenhet av att specialisera en stor, generell språkmodell för en specifik uppgift (sentimentanalys) genom finjustering.

Verktyg: Google Colab (en gratis webbaserad Python-miljö med tillgång till GPU).

Varför Google Colab?

Finjustering av en Transformer-modell är en beräkningsintensiv process som går extremt långsamt på en vanlig datorprocessor (CPU). Google Colab ger oss gratis tillgång till en kraftfull grafikprocessor (GPU), vilket kan förkorta träningstiden från flera timmar till bara några minuter. Denna övning är designad för att köras i den miljön.

Instruktioner:

Följ dessa steg för att finjustera din egen sentimentanalysmodell från grunden.

Del 1: Sätt upp din arbetsmiljö i Google Colab

1. Öppna Google Colab: Gå till https://colab.research.google.com/.

2. Skapa en ny Notebook: Klicka på File i menyn och välj New notebook.

3. Aktivera GPU: Detta är det viktigaste steget!

   • Gå till menyn och välj Runtime -> Change runtime type.

   • I fönstret som dyker upp, välj T4 GPU (eller liknande) från "Hardware accelerator"-menyn.

   • Klicka på Save. Du är nu ansluten till en maskin med en GPU.

Del 2: Skriv och kör koden

Kopiera och klistra in följande kodblock i separata celler i din Colab-notebook. Kör varje cell i ordning genom att klicka på play-knappen till vänster om cellen eller trycka Shift+Enter.

Cell 1: Installera nödvändiga bibliotek

# Denna cell installerar Hugging Face-biblioteken som vi behöver.

# '!' betyder att kommandot körs i terminalen.

# '-U' ser till att vi får de senaste versionerna.

!pip install transformers datasets accelerate -U

Cell 2: Ladda modell och data

from datasets import load_dataset

from transformers import AutoTokenizer, AutoModelForSequenceClassification



# Ladda en förtränad svensk BERT-modell och dess "tokenizer".

# Tokenizern omvandlar text till siffror som modellen förstår.

model_name = "KB/bert-base-swedish-cased"

tokenizer = AutoTokenizer.from_pretrained(model_name)



# Ladda ett dataset med svenska recensioner från Hugging Face Hub.

dataset = load_dataset("swedish_reviews")



# Förbered en funktion som tokeniserar texten i datasetet.

def tokenize_function(examples):

    return tokenizer(examples["text"], padding="max_length", truncation=True)



# Använd .map() för att applicera funktionen på hela datasetet.

tokenized_datasets = dataset.map(tokenize_function, batched=True)

Cell 3: Förbered data för träning

# För att träningen ska gå snabbt använder vi bara en liten del av datan.

# Vi tar 1000 exempel för träning och 300 för validering.

small_train_dataset = tokenized_datasets["train"].shuffle(seed=42).select(range(1000))

small_eval_dataset = tokenized_datasets["test"].shuffle(seed=42).select(range(300))



# Ladda modellen. Viktigt: AutoModelForSequenceClassification har ett 

# extra "huvud" på slutet, anpassat för klassificeringsuppgifter som denna.

model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)

Cell 4: Sätt upp och kör träningsprocessen

from transformers import Trainer, TrainingArguments



# Definiera argumenten för träningen. Detta talar om för tränaren

# hur den ska bete sig, t.ex. vart den ska spara modellen.

training_args = TrainingArguments(

    output_dir="test_trainer",

    evaluation_strategy="epoch",

    num_train_epochs=1 # Vi tränar bara en runda (epoch) för att det ska gå snabbt.

)



# Skapa en Trainer-instans som binder samman modellen, argumenten och datan.

trainer = Trainer(

    model=model,

    args=training_args,

    train_dataset=small_train_dataset,

    eval_dataset=small_eval_dataset,

)



# Starta finjusteringen! Detta är steget där GPU:n gör allt jobb.

# Det kan ta 2-5 minuter.

trainer.train()

Del 3: Testa din finjusterade modell

När träningen är klar har du en ny, specialiserad modell sparad i mappen test_trainer. Nu kan vi använda den för att göra prediktioner.

Cell 5: Använd den finjusterade modellen i en pipeline

from transformers import pipeline



# Ladda en pipeline för sentiment-analysis med vår nyss tränade modell.

# 'test_trainer' är mappen där modellen sparades.

sentiment_pipeline = pipeline("sentiment-analysis", model="test_trainer")



# Testa med en uppenbart positiv recension

result_pos = sentiment_pipeline("Filmen var helt fantastisk och jag älskade skådespelarna!")

print(result_pos)



# Testa med en uppenbart negativ recension

result_neg = sentiment_pipeline("Jag slösade två timmar av mitt liv på den här usla rullen.")

print(result_neg)



# Testa med en mer tvetydig recension

result_meh = sentiment_pipeline("Jag har sett bättre filmer, men den var inte helt dålig.")

print(result_meh)

Reflektera

• Varför är det mer effektivt att finjustera en befintlig modell än att träna en helt ny från grunden för denna uppgift?

• Titta på resultatet för den tvetydiga recensionen. Vad gissade modellen? Vad säger det om de mönster den har lärt sig?

• Vilka andra specifika uppgifter skulle man kunna finjustera en svensk språkmodell för? Ge tre exempel på tillämpningar inom svensk industri eller offentlig sektor.

---

Övning 7: Debatt & Diskussion

Syfte: Att fördjupa förståelsen för de filosofiska och kognitiva konsekvenserna av kraftfulla språkmodeller.

1. Debatt: Det Kinesiska Rummet

   • Organisera en formell debatt i klassen kring påståendet: "En LLM som ChatGPT kan aldrig uppnå verklig förståelse, oavsett hur övertygande dess svar är."

   • Ena sidan argumenterar för påståendet, med John Searles "Kinesiska Rummet" som sitt huvudargument.

   • Andra sidan argumenterar emot påståendet. De kan hävda att "förståelse" är ett emergent fenomen och att det inte finns någon fundamental skillnad mellan hur en hjärna och ett komplext neuralt nätverk processar information.

2. Diskussion: Kognitiv Avlastning

   • Läs citatet från Nicholas Carr i läroboken igen.

   • Diskutera i mindre grupper: Har ni själva märkt av den "kognitiva avlastning" Carr beskriver? Ge konkreta exempel från er vardag (t.ex. GPS vs. lokalsinne, stavningskontroll vs. rättstavningsförmåga).

   • Hur kan vi använda LLMs som kraftfulla verktyg (augmentation) utan att låta dem erodera vårt eget intellektuella hantverk (automation)? Brainstorma fram tre konkreta strategier eller "regler" ni skulle kunna använda i era studier eller framtida yrken.

3. Diskussion: "Garbage In, Garbage Out" - Bias i LLMs

   • Läs textrutan "Etiskt vägskäl" om bias i läroboken.
   • Diskutera i gruppen: Vem bär ansvaret för att hantera bias i AI-modeller?
     • Är det utvecklarna, som borde "tvätta" datan eller bygga in algoritmiska skyddsräcken?
     • Är det företagen som använder modellerna, som borde ha riktlinjer för hur de får användas?
     • Är det användarna, som borde vara medvetna om och kritiska till modellernas output?
   • Brainstorma fram ett konkret exempel på en stereotyp (utöver de som nämns i boken) som en LLM tränad på internet-data troligen skulle reproducera. Hur skulle denna stereotyp kunna orsaka skada i en verklig applikation (t.ex. en anställnings-bot eller en medicinsk chatbot)?