Cum generează un LLM text: următorul token
Un model de limbaj nu „știe” răspunsul dinainte și nu îl caută nicăieri: îl scrie bucată cu bucată, alegând de fiecare dată continuarea cea mai potrivită. Când înțelegi acest mecanism simplu, înțelegi de ce modelele sunt atât de bune la text, de ce greșesc uneori cu încredere și cum să construiești aplicații care țin cont de asta.
De ce te ajută să știi cum funcționează
Nu ai nevoie de matematică avansată ca să construiești aplicații AI, dar ai nevoie de un model mental corect. Aproape toate deciziile din acest curs (ce pui în prompt, de ce dai modelului documentele firmei, de ce verifici răspunsul în cod, de ce plătești pe token) decurg dintr-un singur fapt: modelul prezice următorul token.
Un token este o bucată de text: un cuvânt scurt, o parte dintr-un cuvânt lung sau un semn de punctuație. Lecția următoare e dedicată lor; deocamdată gândește-te la un token ca la „aproape un cuvânt”.
Un token, apoi încă unul, apoi încă unul
Când trimiți o cerere, modelul primește tot textul (instrucțiunile și mesajul tău) și calculează, pentru fiecare token pe care îl cunoaște, cât de probabil este să urmeze. Alege unul, îl lipește la text și repetă calculul cu textul mai lung. Procesul se numește autoregresiv: fiecare token nou depinde de toți cei de dinainte.
Modelul se oprește când alege un token special de final (de aici stop_reason == "end_turn" din lecția 1) sau când atinge limita max_tokens pe care i-ai dat-o (atunci stop_reason == "max_tokens" și răspunsul e tăiat).
Fiecare token de ieșire este un pas separat de calcul. De aceea un răspuns de 1.000 de tokeni durează vizibil mai mult decât unul de 50 și de aceea tokenii de ieșire costă mai mult decât cei de intrare.
Probabilități, în Python
Poți imita un singur pas cu un dicționar: cheile sunt variantele, valorile sunt probabilitățile (suma lor este 1). Varianta „cea mai probabilă” o găsești cu max(dictionar, key=dictionar.get). Strategia care ia mereu varianta cea mai probabilă se numește greedy (lacomă).
# probabilitățile pentru cuvântul care urmează după „Livrarea durează”
urmatorul = {"2": 0.46, "o": 0.21, "între": 0.18, "doar": 0.15}
ales = max(urmatorul, key=urmatorul.get)
print("Cel mai probabil:", ales, urmatorul[ales])
print("Suma probabilităților:", round(sum(urmatorul.values()), 2))
Cel mai probabil: 2 0.46 Suma probabilităților: 1.0
Modelele reale de obicei nu iau mereu prima variantă: eșantionează, adică aleg la întâmplare, dar ponderat după probabilități. Varianta cu 46% iese cel mai des, dar uneori iese și una mai puțin probabilă. De aceea același prompt poate da răspunsuri ușor diferite.
import random
urmatorul = {"2": 0.46, "o": 0.21, "între": 0.18, "doar": 0.15}
cuvinte = list(urmatorul)
probabilitati = list(urmatorul.values())
random.seed(14) # fixat, ca rezultatul să fie același la fiecare rulare
for i in range(5):
ales = random.choices(cuvinte, weights=probabilitati)[0]
print("Generarea", i + 1, "→ Livrarea durează", ales, "...")
Generarea 1 → Livrarea durează 2 ... Generarea 2 → Livrarea durează între ... Generarea 3 → Livrarea durează o ... Generarea 4 → Livrarea durează doar ... Generarea 5 → Livrarea durează 2 ...
Mută cursorul de mai sus și apasă „Generează”: vezi cum se schimbă distribuția și ce variante ies. Despre temperatură și despre cum controlezi variația în API-urile actuale vorbim în lecția 5.
Bucla completă: o propoziție întreagă
Pune pasul într-o buclă și ai un generator de text în miniatură. Modelul real face exact asta, doar că alege dintre zeci de mii de tokeni posibili, iar probabilitățile le calculează o rețea neuronală uriașă, nu un dicționar scris de mână.
PREDICTII = {
"Vă": {"mulțumim": 0.82, "rugăm": 0.12, "așteptăm": 0.06},
"mulțumim": {"pentru": 0.77, "mult": 0.23},
"pentru": {"comandă": 0.61, "răbdare": 0.39},
}
text = ["Vă"]
for pas in range(3):
ultimul = text[-1]
variante = PREDICTII[ultimul]
ales = max(variante, key=variante.get)
text.append(ales)
print(f"Pasul {pas + 1}: {' '.join(text)}")
Pasul 1: Vă mulțumim Pasul 2: Vă mulțumim pentru Pasul 3: Vă mulțumim pentru comandă
De unde știe modelul probabilitățile
- Pre-antrenarea: modelul citește o cantitate uriașă de text (cărți, site-uri, cod) și învață să prezică următorul token. Așa capătă gramatică, fapte, stiluri și raționamente.
- Ajustarea cu instrucțiuni: e antrenat pe exemple de tipul „cerere → răspuns bun”, ca să răspundă la întrebări în loc să continue la nesfârșit textul.
- Feedback-ul uman (și reguli scrise de firmă): oamenii compară variante de răspuns, iar modelul învață să le prefere pe cele utile, corecte și sigure.
Cunoștințele modelului se opresc la data la care s-a terminat antrenarea și nu se actualizează singure. Modelul nu are acces la internet sau la baza ta de date decât dacă aplicația ta i le dă: în prompt (modulul 5, RAG) sau prin tool-uri (modulul 4).
Ce înseamnă asta pentru aplicația ta
| Faptul | Consecința practică |
|---|---|
| Prezice text plauzibil, nu caută într-o bază de date | Poate inventa cu încredere un preț, o lege sau un link (lecția 6). Îi dai datele reale în prompt. |
| Nu știe ce s-a întâmplat după antrenare | Stocul, comenzile, prețurile de azi vin din aplicația ta, nu din model. |
| Eșantionează dintre variante | Același prompt poate da răspunsuri diferite: nu compari textul exact, verifici conținutul. |
| Fiecare token de ieșire e un pas | Răspunsurile lungi sunt mai lente și mai scumpe: ceri explicit răspunsuri scurte. |
| Tot ce vede e textul primit | Calitatea răspunsului depinde de cât de clar și complet e promptul tău (modulul 2). |
Asistentul nu răspunde „din memorie” la „cât costă?”, ci primește prețul curent de la aplicație.
Codul verifică dacă răspunsul conține numărul tichetului înainte să-l trimită clientului.
Programul de lucru e pus în prompt, iar modelul are voie să spună „nu știu”.
Construiește un generator de text în miniatură. Pornind de la cuvântul Comanda, alege de 3 ori cuvântul cel mai probabil din PREDICTII (strategia greedy), afișând la fiecare pas Pasul N: cuvânt (probabilitate), apoi afișează Propoziția: urmat de toate cuvintele, separate prin spațiu.
- Scrie o buclă for care rulează de 3 ori.
- La fiecare pas ia variantele pentru ultimul cuvânt: PREDICTII[text[-1]].
- Alege varianta cu probabilitatea maximă cu max(variante, key=variante.get) și adaug-o în text.
- Afișează Pasul N: cuvânt (probabilitate), de exemplu Pasul 1: ta (0.71).
- După buclă afișează Propoziția: + " ".join(text).
Soluția exercițiului
# Pentru fiecare cuvânt: probabilitățile cuvântului care urmează (un „model” foarte mic)
PREDICTII = {
"Comanda": {"ta": 0.71, "noastră": 0.18, "mea": 0.11},
"ta": {"a": 0.64, "este": 0.27, "va": 0.09},
"a": {"plecat": 0.58, "ajuns": 0.30, "fost": 0.12},
"este": {"gata": 0.66, "pe": 0.34},
}
text = ["Comanda"]
for pas in range(3):
variante = PREDICTII[text[-1]]
ales = max(variante, key=variante.get)
text.append(ales)
print(f"Pasul {pas + 1}: {ales} ({variante[ales]})")
print("Propoziția:", " ".join(text)) 