Így gondolkodnak a nagy nyelvi modellek (LLM)

A ChatGPT és a hozzá hasonló rendszerek mögött egy speciális architektúra áll. Ezek a modellek, amelyek képesek megérteni a szövegkörnyezetet és választ generálni. De hogyan történik ez a „gondolkodás” a bitek szintjén? A folyamat nem varázslat, hanem színtiszta matematika és statisztika. A modell lépésről lépésre alakítja át a szöveget számokká, majd vissza szöveggé. Ebben a cikkben végigkövetjük az információ útját a bemenettől a kimenetig. Python kódokkal demonstráljuk, mi történik a színfalak mögött.

1. Lépés: Tokenizálás (A szöveg darabolása)

A számítógép nem érti a betűket, csak a számokat. Az első lépés tehát a szöveg átalakítása numerikus adatokká. Ezt végzi a tokenizáló.

A tokenizáló a szöveget kisebb egységekre, úgynevezett tokenekre bontja. Egy token lehet egy szó, egy szórészlet vagy egy írásjel. Minden tokenhez tartozik egy egyedi azonosító szám (ID).

Íme, hogyan néz ez ki Pythonban a transformers könyvtárral:

from transformers import AutoTokenizer

# Modell kiválasztása (pl. GPT-2)
tokenizer = AutoTokenizer.from_pretrained("gpt2")

text = "A transzformátor modellek okosak."
input_ids = tokenizer.encode(text, return_tensors="pt")

print(f"Eredeti szöveg: {text}")
print(f"Token ID-k: {input_ids}")

# Visszafejtve látható a darabolás
tokens = [tokenizer.decode([x]) for x in input_ids[0]]
print(f"Tokenek: {tokens}")

A kimeneten láthatjuk, hogy a mondatból számsorozat lett. Ez a bemenet a modell számára.

2. Lépés: Beágyazás és Pozíció (Embeddings)

A puszta számok önmagukban nem hordoznak jelentést. A modellnek tudnia kell, hogy a „király” és a „királynő” szavak jelentése közel áll egymáshoz.

Erre szolgál a Token Embedding (beágyazás). Minden token ID-t átalakítunk egy sokdimenziós vektorrá (számsorozattá). A hasonló jelentésű szavak vektorai matematikailag közel helyezkednek el egymáshoz a térben.

Ezen felül a modellnek tudnia kell a szavak sorrendjét is. A „Péter szereti Marit” nem ugyanaz, mint a „Mari szereti Pétert”. Ezt a Pozicionális Kódolás (Positional Encoding) oldja meg, amely hozzáadja a sorrendi információt a vektorokhoz.

import torch.nn as nn

# Példa egy embedding rétegre
# 50257 lehetséges token, 768 dimenziós vektorok
embedding_layer = nn.Embedding(50257, 768)

# A token ID-k átalakítása vektorrá
vector_representation = embedding_layer(input_ids)

print(f"Bemenet mérete: {vector_representation.shape}")
# Kimenet: [1, 6, 768] (1 mondat, 6 token, 768 dimenzió/token)

Most már van egy gazdag, szám alapú leírásunk a szövegről és a szavak sorrendjéről.

3. Lépés: A Figyelem Mechanizmusa (Attention)

Ez a Transzformátor legfontosabb része. A Multi-Headed Attention (többfejű figyelem) lehetővé teszi, hogy a modell minden szót az összes többi szóhoz viszonyítson.

Például a „bank” szó jelentése más folyópartként és más pénzintézetként. A mechanizmus megnézi a környező szavakat („folyó” vagy „pénz”), és eldönti, melyik értelmezés a helyes.

A modell súlyozza a kapcsolatokat: a fontosabb szavakra nagyobb „figyelmet” fordít.

# Pszeudokód a figyelem működésének elvéről
def attention_mechanism(query, key, value):
    # Mennyire hasonlít a keresett szó a többihez?
    scores = torch.matmul(query, key.transpose(-2, -1))
    
    # Valószínűségek számítása (súlyozás)
    weights = torch.nn.functional.softmax(scores, dim=-1)
    
    # Az információk összefésülése a súlyok alapján
    context = torch.matmul(weights, value)
    return context

Ez a folyamat többször ismétlődik a modell mélyebb rétegeiben. Így a rendszer megtanulja a bonyolult nyelvtani és szemantikai összefüggéseket.

4. Lépés: Előrecsatolás (Feed-Forward)

A figyelem réteg után az adatok egy hagyományos neurális hálózaton haladnak át. Ez a Feed-Forward Network.

Ez a lépés „tisztázza” és elmélyíti a tanult mintázatokat. Segít a modellnek absztraktabb fogalmakat is megérteni az egyszerű szókapcsolatokon túl. A folyamat (Figyelem -> Előrecsatolás) blokkonként ismétlődik, akár 96-szor is (pl. a GPT-3 esetében).

5. Lépés: A következő szó jóslása

A feldolgozás végén a modellnek egyetlen feladata van, megtippelni a következő szót.

Az utolsó réteg egy valószínűségi eloszlást állít elő a szótár összes szavára. Például a „Ma szép…” bemenetre a modell kiszámolja:

„idő”: 80%
„nap”: 15%
„autó”: 0.001%

A modell kiválasztja a legvalószínűbb szót (vagy véletlenszerűen választ a legjobbak közül), és hozzáadja a kimenethez.

from transformers import GPT2LMHeadModel

model = GPT2LMHeadModel.from_pretrained("gpt2")

# A következő szó valószínűségeinek kiszámítása
outputs = model(input_ids)
predictions = outputs.logits

# A legmagasabb pontszámú szó kiválasztása
next_token_id = torch.argmax(predictions[0, -1, :]).item()
next_word = tokenizer.decode([next_token_id])

print(f"A modell tippje a következő szóra: '{next_word}'")

A szógenerálás körforgása

Ez a ciklus, tokenizálás, beágyazás, figyelem, predikció, ismétlődik minden egyes generált szónál. A modell visszacsatolja a saját kimenetét a bemenetre, és újra elkezdi a folyamatot.

Bár a háttérben bonyolult mátrixműveletek zajlanak, az alapelv egyszerű. A múltbeli adatok alapján megérteni a jelentést és megjósolni a jövőt. Ezzel a tudással már nem fekete dobozként, hanem logikus rendszerként tekinthetünk a nyelvi modellekre.