🧠 Transformer Playground

Vše začíná a končí u starého známého MLP. Každé slovo (token) má svou vlastní malou neuronovou síť. Ta se stará o embedding – převede "hloupé" číslo (ID slova) na bohatou vektorovou reprezentaci v n-rozměrném prostoru. Díky tomu jazykový model pochopí, že slova "Babička" a "Babča" leží v prostoru blízko sebe.

Funguje jako "chytrá ústředna". Vektory se transformují na Query (Q), Key (K) a Value (V). Každé slovo se "podívá" na ostatní a podle shody Q a K si "přimíchá" informace od souvisejících slov. Vzniká tak kontext (např. "koruna" v kontextu "platit" = peníze, ne královský klenot).

Obohacené vektory, které nyní nesou svůj význam i kontext celé věty, vstupují do hlavní velké sítě. Toto MLP s mnoha skrytými vrstvami funguje jako mozek operace – hledá v datech hluboké nelineární vztahy a "chápe" sémantiku příběhu.

Na konci hlavní sítě vypadnou nová čísla. Funkce Softmax je převede na pravděpodobnosti a vybere ze slovníku slovo, které s největší jistotou patří na chybějící místo.

💡 Attention Is All You Need: Tento simulátor ukazuje "Jednovrstvý Transformer s jednou hlavou" (Single-Head Attention).

Rozdíly oproti GPT-4:
1. Single-Head vs Multi-Head: My máme 1 sadu Q/K/V (jednu "hlavu"), takže síť sleduje jen jeden typ vztahu. GPT jich má tisíce, aby sledovala gramatiku, význam i styl naráz.
2. Hloubka: GPT má těchto bloků (Attention + FFNN) třeba 96 za sebou. My máme jeden.
3. Layer Norm: Reálné sítě normalizují data po každém kroku. My to řešíme malým Learning Rate.

💡 Proč se to děje?

1. Malý dataset (16 příkladů)
Síť zná jen přesné kombinace slov, které viděla při tréninku. Změna pozice [?] je pro ni úplně nová situace.

2. Pattern matching místo porozumění
Naše "nanosíť" nemá dost kapacity, aby pochopila sémantický vztah mezi "Vlk" a "Babička". Naučila se jen rozpoznávat konkrétní vzory sekvencí.

3. Omezená attention
S 8-dimenzionálním embeddingem a jednou attention hlavou nemůže zachytit složité jazykové vztahy nezávisle na pozici slov.

💡 Intuice: Query = "Co hledám?", Key = "Co nabízím?", Value = "Jakou informaci nesu?". Čím více se Q a K shodují, tím více se přimíchá odpovídající V.

function oneHot(idx, vocabSize) {

    const vec = new Array(vocabSize).fill(0);

    if (idx >= 0 && idx < vocabSize) vec[idx] = 1;

    return vec;

}

function softmax(logits) {

    const maxLogit = Math.max(...logits);  // Numerická stabilita

    const exps = logits.map(x => Math.exp(x - maxLogit));

    const sum = exps.reduce((a, b) => a + b, 0);

    return exps.map(x => x / sum);

}

function attention(embeddings, Wq, Wk, Wv) {

    const seqLen = embeddings.length;

    const dim = embeddings[0].length;

    

    // 1. Compute Q, K, V

    const Q = embeddings.map(e => matMul(e, Wq));

    const K = embeddings.map(e => matMul(e, Wk));

    const V = embeddings.map(e => matMul(e, Wv));

    

    // 2. Attention scores

    const scores = [];

    for (let i = 0; i < seqLen; i++) {

        const row = [];

        for (let j = 0; j < seqLen; j++) {

            const dot = Q[i].reduce((sum, q, d) => sum + q * K[j][d], 0);

            row.push(dot / Math.sqrt(dim));  // Scaled dot-product

        }

        scores.push(row);

    }

    

    // 3. Softmax per row

    const weights = scores.map(row => softmax(row));

    

    // 4. Weighted sum of V

    const output = [];

    for (let i = 0; i < seqLen; i++) {

        const contextVec = new Array(dim).fill(0);

        for (let j = 0; j < seqLen; j++) {

            for (let d = 0; d < dim; d++) {

                contextVec[d] += weights[i][j] * V[j][d];

            }

        }

        output.push(contextVec);

    }

    return output;

}

function crossEntropyGradient(probs, targetIdx) {

    // Elegantní vzorec: gradient = p - y

    return probs.map((p, i) => p - (i === targetIdx ? 1 : 0));

}



// Loss pro logging

const loss = -Math.log(probs[targetIdx] + 1e-10);