Deep Dive u Transformer Arhitekturu

🧭 Uvod: Gdje smo i kuda idemo?

Prije nego što naučimo kako koristiti ChatGPT ili Claude u poslovnom okruženju, moramo razumjeti kako oni zapravo rade. Ovo nije teorija radi teorije — kada budete podešavali API parametre, dizajnirali prompts ili procjenjivali troškove, ova znanja su od direktne koristi.

Danas ćemo odgovoriti na pitanja:

• Zašto ChatGPT razumije kompleksne rečenice, a stari chatboti nisu mogli?
• Šta je to Transformer i zašto je revolucionisao AI?
• Kako računar pretvara tekst u matematiku i nazad u tekst?
• Šta su to tenzori, vektori i embedding?

📜 Evolucija NLP-a: Od Rule-Based do Transformera

Da bismo razumjeli zašto je Transformer revolucionaran, moramo vidjeti odakle dolazimo. Natural Language Processing (NLP) — automatska obrada ljudskog jezika — razvijao se decenijama.

🔢 Fundamentalni Pojmovi: Skalari, Vektori, Matrice i Tenzori

Prije nego objasnimo Transformer, moramo definisati matematičke "objekte" sa kojima radi. Ovo su pojmovi koje ćete čuti u svakom razgovoru o AI-ju.

📐 Tenzor (Tensor) — Najvažniji pojam u AI!

Generalizacija skalara, vektora i matrica na N dimenzija. Ovo je često najneobičniji koncept početnicima, ali je zapravo vrlo logičan način organizacije podataka.

• Skalar = 0D (jedan broj, npr. jedan račun)
• Vektor = 1D niz (kolona iz tabele, npr. lista računa za danas)
• Matrica = 2D tabela (svi računi za cijeli mjesec posloženi po danima i tipovima)
• Tenzor rang 3 = 3D "kocka podataka" (arhiva tabela za sve mjesece u godini)
• Tenzor rang 4+ = arhive za sve godine, itd.

Od 1D papira, preko 2D ladice do 3D arhive.

Konkretno: Kada GPT procesira batch od 32 rečenica, svaka sa maksimalno 512 tokena, svaki token predstavljen vektorom od 768 dimenzija — radimo sa tenzorima dimenzija [32, 512, 768]. Ovo nema boljeg opisa osim "3D kocke podataka" koja živi u memoriji GPU-a. Veze između dimenzija omogućavaju modelu da "uči" kompleksne obrasce.

Zašto to zovemo "tenzori"? Naziv dolazi iz fizike (tenzori naprezanja u mehanici), ali u ML kontekstu se koristi jer biblioteka PyTorch u Pythonu podatke čuva i obrađuje u strukturama koje se zovu torch.Tensor. Svaka operacija u neuronskoj mreži je zapravo matematička operacija nad ovim tenzorima.

🏗️ Anatomija Transformera

Transformer je tip neuronske mreže koji je Google Brain tim opisao u naučnom radu "Attention Is All You Need" (2017). Za razliku od RNN-ova koji čitaju tekst sekvencijalno, Transformer obrađuje sve tokene u tekstu istovremeno koristeći mehanizam self-attention.

Originalni Transformer ima dvije komponente:

• Enkoder (Encoder) — Prima ulazni tekst i gradi njegovo matematičko razumijevanje. Svaki token dobija kontekstualni vektor koji uzima u obzir sve ostale tokene. Primjer: BERT (Google) je samo-enkoder model. Odlično za: klasifikaciju teksta, sentiment analiza, odgovaranje na pitanja.
• Dekoder (Decoder) — Generuje output token po token, koristeći razumijevanje encodera i već generisane tokene. Primjer: GPT (OpenAI) i Llama (Meta) su samo-dekoder modeli. Odlično za: generisanje teksta, chatboti, code assistenti.

Unutrašnja Arhitektura — Korak po Korak

Sada ćemo proći kroz ono što se dešava kada pošaljete tekst LLM modelu. Svaki korak je posebna matematička transformacija unutar neuronske mreže.

🎯 Self-Attention Mehanizam (Srce Transformera)

Ovo je najvažniji koncept u modernoj AI industriji. Razumijevanjem ovog mehanizma razumijete "zašto" LLM-ovi rade bolje od svega što je prethodilo.

Self-Attention dopušta modelu da za svaki token koji trenutno obrađuje "pogleda" sve ostale tokene u rečenici i odluči koliko su mu bitni (koliko im daje pažnje). Ovo radi paralelno za sve tokene istovremeno.

💡 Analogija: Soba stručnjaka

Zamislite da imate zadatak: odrediti šta tačno znači zamjenica "ona" u rečenici "Ana je pokrenula sistem, a potom ga je ona restartovala."

Stručnjaci ("Riječi") vijećaju o značenju riječi "Ona"

Vi pitate svakog stručnjaka u sobi ("Ana", "sistem", "restartovala") koliko misli da je relevantan za razumijevanje "one". "Ana" kaže: "Ja sam najrelevantnija! Ja sam imenica ženskog roda koja može vršiti radnju!" "sistem" kaže: "Manje sam relevantan, ja sam muški rod i više sam objekat." Ovi "glasovi" se sabiraju spram njihove težine i dobijena "ponderisana suma" (weighted sum) pomaže precizno razumjeti kontekst. Self-attention je upravo taj proces vijećanja stručnjaka formalizovan u mataričnu matematiku.

Query, Key, Value (Q, K, V) — Gledano kroz primjer "Ane"

Self-Attention koristi tri tenzora/matrice koje model uči kroz trening. Svaki ulazni token se multiplicira sa ove tri matrice i matematički "proizvodi" tri uloge za sebe (Q, K i V). Evo primjera logike za riječ "ona":

Ova formula radi sljedeće:

1. Množimo Q i K matricu transonovano (Q · K^T) — dobivamo "score" sličnosti između svakog para tokena
2. Dijelimo s √d_k (kvadratnim korijenom dimenzije) da spriječimo prepotentno numerički stabilne vrijednosti
3. Primjenjujemo softmax koji pretvara score-ove u distribuciju vjerovatnoća (sve se sabere na 1.0)
4. Množimo s Value matricom V — "ponderirano skupljamo" vrijednosti na temelju attention score-ova

"Server nije mogao pokrenuti aplikaciju jer je bio {preopterećen}."
"Server nije mogao pokrenuti aplikaciju jer je bila {korumpirana}."

Sa Query-em za token "bio/bila":
- U prvoj rečenici: attention score za "Server" = 0.90 | "aplikaciju" = 0.05
  → "bio" se odnosi na Server (muški rod)
  
- U drugoj rečenici: attention score za "aplikaciju" = 0.89 | "Server" = 0.06
  → "bila" se odnosi na aplikaciju (ženski rod)

Model ovo nije naučen "gramatičkim pravilima" — naučio je
statistički, iz milijardi rečenica, koji kontekstualni obrasci
prepoznaju referencu zamjenice.

Multi-Head Attention: Višestruka Perspektiva

Umjesto jedne kalkulacije pažnje, Transformer paralelno izračunava 12, 16, 96 (ovisno o modelu) odvojenih "głava" (heads) pažnje — each sa sa zasebnim Q, K, V matricama koja uče različite aspekte relacije:

• Głava 1 može tražiti gramatičke odnose (subjekat → predikat)
• Głava 2 može pratiti emociju ili ton rečenice
• Głava 3 može locirati imeničko-pridjevske veze
• Głava 4 može identificirati coreference (zamjenicu i imenicu)
• ... svaka głava spontano uči nešto korisno za predviđanje sljedećeg tokena

Na kraju, svi izlazi glava se konkateniraju i projiciraju natrag u dimenziju modela. GPT-3 ima 96 slojeva svaki sa 96 głava — to je 9,216 odvojenih "fokusiranih perspektiva" u jednom forward pass-u!

# Provjera Python verzije (trebate 3.9, 3.10 ili 3.11)
python --version
# Ako dobijete "Python 3.10.x" ili slično - OK.
# Ako ne prepoznaje python, probajte:
python3 --version

# Provjera pip (Python package manager)
pip --version

# 1. Kreirajte folder za ovaj kurs na Desktop-u
mkdir C:\Users\$env:USERNAME\Desktop\AI_Kurs
cd C:\Users\$env:USERNAME\Desktop\AI_Kurs

# 2. Kreirajte virtuelno okruženje nazvano "venv"
python -m venv venv
# Ovo kreira folder "venv" u vašem projektnom folderu

# 3. AKTIVIRAJTE virtualno okruženje (obavezno svaki put!)
.\venv\Scripts\Activate.ps1

# Znate da je aktivno kada vidite "(venv)" na početku prompt-a:
# (venv) PS C:\Users\...\AI_Kurs>

# Ako dobijete grešku o "Execution Policy", pokrenite:
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
# Zatim ponovo pokrenite Activate.ps1

# Uvjerite se da je (venv) aktivan (vidljiv u promptu)!

# PyTorch - matematička jezgra za tenzore (CPU verzija, dovoljna za lab)
pip install torch --index-url https://download.pytorch.org/whl/cpu

# HuggingFace Transformers - biblioteka za učitavanje GPT, BERT i ostalih modela
pip install transformers

# BertViz - interaktivna vizualizacija attention matrica
pip install bertviz

# Jupyter Lab - browser okruženje za interaktivno kodiranje
pip install jupyterlab ipywidgets

# Provjera instlacije:
pip list
# U listi trebate vidjeti: torch, transformers, bertviz, jupyterlab

# Pokrenite Jupyter Lab iz projektnog foldera:
jupyter lab

# Ovo će:
# 1. Pokrenuti lokalni web server na portu 8888
# 2. Automatski otvoriti browser na adresi: http://localhost:8888
# 3. Prikazati file manager vašeg projektnog foldera

# Uvozimo klase iz HuggingFace Transformers biblioteke
from transformers import AutoTokenizer, AutoModel
# BertViz pruža head_view funkciju za interaktivnu vizualizaciju
from bertviz import head_view
import torch  # PyTorch - radimo sa tenzorima

# Definišemo koji model koristimo
model_name = 'gpt2'  # Najmanji GPT-2 model

# AutoTokenizer automatski preuzima tokenizer za zadani model
# Tokenizer zna kako pretvoriti tekst u token ID-eve
tokenizer = AutoTokenizer.from_pretrained(model_name)

# AutoModel preuzima arhitekturu GPT-2 sa nasumičnim ili pretreniranim težinama
# output_attentions=True govori modelu da vrati attention matrice (inače ih ne vraća radi uštede memoria)
model = AutoModel.from_pretrained(model_name, output_attentions=True)

# Postavljamo model u evaluation mode (ne treniramo, samo koristimo)
model.eval()

print(f"✅ Model učitan! Broj parametara: {sum(p.numel() for p in model.parameters()):,}")
# Trebate vidjeti: ~124,439,808 (124 miliona) parametara za GPT-2 small

# Testna rečenica iz domene sistemske administracije
text = "The firewall blocked the IP address because it was malicious."

# Korak 1: Tokenizacija — pretvaramo string u tensore token ID-eva
# return_tensors='pt' = vrati PyTorch tenzor (a ne Python listu)
# add_special_tokens=True = dodaj [BOS] Beginning-of-Sequence token
inputs = tokenizer.encode_plus(
    text,
    return_tensors='pt',   # pt = PyTorch format
    add_special_tokens=True
)
#########################################
# ako ne prodje iznad kod, probati ovo
inputs = tokenizer(
    text, 
    return_tensors='pt', 
    add_special_tokens=True
)
#########################################
input_ids = inputs['input_ids']  # Tenzor sa token ID-evima: [[50256, 464, 2046, ...]]

print("Token IDs:", input_ids)
print("Oblik tenzora (shape):", input_ids.shape)  # [1, 11] = 1 rečenica, 11 tokena

# Konvertujemo ID-eve natrag u čitljive tokene (da vidimo proces tokenizacije):
tokens = tokenizer.convert_ids_to_tokens(input_ids[0].tolist())
print("\nTokeni:", tokens)
# Primit ćete listu poput: ['The', 'Ġfirewall', 'Ġblocked', 'Ġthe', 'ĠIP', ...]
# Ġ (G sa kružićem) = space ispred tokena (BPE konvencija)

# torch.no_grad() = ne računamo gradijente (nije trening, štedimo memoriju)
with torch.no_grad():
    # Prosljeđujemo input_ids tenzor kroz sve slojeve GPT-2 modela
    outputs = model(input_ids)

# outputs je tuple. Zadnji element je lista attention tenzora (1 per layer)
# GPT-2 small ima 12 slojeva, svaki vraća attention matricu
attention = outputs[-1]  # Lista od 12 tenzora, svaki oblika [1, 12_heads, seq_len, seq_len]

print(f"Broj slojeva: {len(attention)}")  # 12 za GPT-2 small
print(f"Oblik attention tenzora (1. sloj): {attention[0].shape}")
# [1, 12, 11, 11] = 1 batch × 12 głava × 11 tokena × 11 tokena

# Ovo je ono o čemu smo pričali teorijski! 11×11 matrica "ko gleda koga" po svakoj głavi

# BertViz head_view prikazuje sve głave za sve slojeve interaktivno
# tokens = lista tagova za osi vizualizacije
head_view(attention, tokens)

import numpy as np

# Uzimamo attention iz prvog sloja, prve głave
# Oblik: [1, 12, seq_len, seq_len]
layer_0_head_0 = attention[0][0, 0, :, :].numpy()  # Konvertujemo tenzor u numpy array

# Pronalazimo indeks tokena "it"
it_idx = tokens.index('Ġit') if 'Ġit' in tokens else -1

if it_idx >= 0:
    print(f"\nAttention score-ovi za token 'it' (la głava 0, sloj 0):")
    for i, (tok, score) in enumerate(zip(tokens, layer_0_head_0[it_idx])):
        bar = "█" * int(score * 30)  # Vizualni bar
        print(f"  {tok:20s} | {score:.4f} | {bar}")

print("\n💡 Zapamtite: ovo je samo 1 od 144 (12 slojeva × 12 głava) attention pattern-a!")

✅ Zaključak i Sljedeći Koraci

U ovoj lekciji smo objasnili temelje: šta su skalari, vektori, matrice i tenzori (matematički objekti kojim barata svaka AI biblioteka). Zatim smo prošli kroz arhitekturu Transformera korak po korak — Embed → Positional Encode → Multi-Head Attention → Feed-Forward → Output.

Kroz BertViz lab, vidjeli smo vizualno kako attention matrice "uče" da prate relacije između riječi bez ijednog eksplicitnog pravila. Ovo je temelj razumijevanja zašto GPT-4 može odgovoriti na kompleksna pitanja bolje od bilo kojeg sistema koji mu je prethodio.

U sljedećoj lekciji (11:15h) ulazimo dublje u Tokenizaciju — kako model tačno lomi tekst na tokene, zašto bosanski jezik "košta više" od engleskog, i kako upravljati Context Window limitima.