👀 धडा 06 — Attention आणि transformers: वर्गात इकडे-तिकडे पाहणारी मुले

📍 तुम्ही इथे आहात: 12 पैकी धडा 06 · मागे: lesson-05-next-token · पुढे: lesson-07-rlhf-lora

📦 या ब्रँचमध्ये काय आहे

धडे 01–05, आणि 2017 चा तो शोध ज्यावर संपूर्ण AI ची लाट उभी आहे: attention आणि transformer. खरी file: demo/attention_toy.py — खरे attention गणित, 40 ओळी, कोणतीही libraries नाहीत.

🧒 5 वर्षांच्या मुलाला समजावल्यासारखे

हे वाचा: "The robot dropped the ball because it was heavy." "it" म्हणजे काय? तुम्ही व्याकरणाचे पुस्तक उघडायला गेला नाहीत — तुमचे डोळे मागे वळून पाहिले 👀, उमेदवारांचे वजन केले (robot? ball?), आणि "heavy" ने पारडे झुकवले. क्षणात, शांतपणे, वजन देत पाहणे.

Attention म्हणजे नेमके तेच, गणिताच्या रूपात. model प्रत्येक token वर प्रक्रिया करताना, त्या token ला context मधील प्रत्येक दुसऱ्या token कडे पाहून ठरवता येते — शिकलेल्या weights सह — आत्ता कोण महत्त्वाचे आहे:

it सर्वात जास्त ball कडे पाहतो — जड वस्तू — मग स्वतः heavy कडे (आपला demo छापतो: ball 69%!)
प्रत्येक नजर म्हणजे वजन दिलेले मिश्रण: token ची अर्थ-जागा (धडा 04!) ज्याच्याकडे लक्ष दिले त्याकडे ओढली जाते — it सुरुवातीला सर्वसाधारण असतो आणि ball-चव घेऊन बाहेर येतो ⚽
आणि हे अनेक वेळा parallel मध्ये होते (multi-head: एक head व्याकरण पाहतो, दुसरा नावे, तिसरा अंतर…) आणि layer मागून layer, प्रत्येक फेरीत अर्थ अधिक धारदार होतात.

transformer = या युक्तीभोवती बांधलेली रचना, खोलवर रचलेली: पाहा-आणि-मिसळा, मग विचार करा (प्रत्येक token साठी छोटे dial-network), ×डझनभर वेळा पुन्हा. जुन्या models पेक्षा त्याची महाशक्ती: सगळे tokens एकाच वेळी attend करतात (RNNs सारखे एकामागून एक नव्हे) — GPU parallelism साठी परिपूर्ण → आपण शेवटी संपूर्ण internet वर train करू शकलो. 2017 च्या paper चे शीर्षक सगळे सांगून जाते: "Attention Is All You Need."

🗺️ आकृती

flowchart TB
    s["'The robot dropped the ball because IT was heavy'"]
    subgraph att["👀 attention - for the token 'it'"]
        q["'it' asks: who am I about?"]
        w["learned weights:<br/>ball 69% · heavy 16% · robot 6%"]
        blend["blend: 'it' comes out<br/>BALL-flavored ⚽"]
        q --> w --> blend
    end
    subgraph tf["🏗️ transformer = stack it deep"]
        l1["glance + think - layer 1"]
        l2["… ×32 layers, ×many heads,<br/>ALL tokens in parallel"]
        l1 --> l2
    end
    s --> att --> tf
    tf --> out["📊 next-piece scoreboard - lesson 05"]

❓ काय

एका ओळीत यंत्रणा: प्रत्येक token एक query ("मी काय शोधतोय"), एक key ("मी काय देतो") आणि एक value ("मला निवडले तर तुम्हाला काय मिळते") बनवतो; scores = query·key साम्य (embeddings वरचे dot products — धडा 04 ची भूमिती कामाला लागते); softmax → weights → values चे मिश्रण. आपला demo अक्षरशः हेच करतो.
Multi-head: प्रत्येक layer मध्ये अनेक attention नमुने, स्वतंत्रपणे शिकलेले. Layers: पाहा-मग-विचार-करा ची डझनभर पुनरावृत्ती.
Context window (धडा 08 ची मर्यादा!) अस्तित्वात आहे कारण प्रत्येक token प्रत्येक दुसऱ्याकडे attend करतो: खर्च लांबीनुसार ~quadratically वाढतो. लांब context = गंभीर engineering.
transformer ने recurrent networks ची जागा घेतली कारण parallelism मुळे training वाढवता आले — रचनेने data खुला केला, data ने क्षमता खुल्या केल्या.

🤔 का

"एका परिच्छेदभर 'it' कशाला उद्देशून आहे हे ते कसे काय पकडू शकते?" याचे हे उत्तर आहे — आणि "2017 च का?" याचेही. जेव्हा तुम्ही model चे specs ऐकता — "32 layers, 96 heads, 128k context" — तेव्हा आता तुम्ही डोळ्यासमोर आणता: पाहण्याच्या किती फेऱ्या, किती parallel नजरा, डोळे किती मागे पोहोचू शकतात.

🧪 करून पाहा

python3 demo/attention_toy.py

खरे dot-products, खरे softmax, हाताने बनवलेल्या जागा: it ने 69% ने ball निवडताना पाहा — जड वस्तू. मग it ला robot-आकाराचा करा ([0.5, 0.6, 0.1, 0.1], जणू वाक्य "…because it was tired" ने संपले) आणि पुन्हा चालवा — नजर robot कडे वळताना पाहा. training लाल पेनने जे करते ते तुम्ही आत्ता केले: एक जागा हलवली, एक मत बदलले.

⏭️ पुढे

आता आपण संपूर्ण ग्रंथालय वाचलेले एक भव्य autocomplete बनवू शकतो. एक अडचण: ते पूर्ण करते — ते नीट वागत नाही. कच्चा model → मदत करणारा assistant: fine-tuning, RLHF आणि LoRA.

git checkout lesson-07-rlhf-lora

👀 Lesson 06 — Attention & transformers: kids glancing around the class

📍 You are here: Lesson 06 of 12 · Previous: lesson-05-next-token · Next: lesson-07-rlhf-lora

📦 What's in this branch

Lessons 01–05, plus the 2017 invention the whole AI boom stands on: attention and the transformer. Real file: demo/attention_toy.py — real attention math, 40 lines, no libraries.

🧒 Explain like I'm 5

Read this: "The robot dropped the ball because it was heavy." What's "it"? You didn't go ask a grammar book — your eyes glanced back 👀, weighed the candidates (robot? ball?), and "heavy" tipped the scales. Instant, silent, weighted glancing.

Attention is exactly that, as math. When the model processes each token, that token gets to look at every other token in the context and decide — with learned weights — who matters right now:

it glances hardest at ball — the heavy thing — then at heavy itself (our demo prints: ball 69%!)
each glance is a weighted blend: the token's meaning-seat (lesson 04!) gets pulled toward what it attended to — it starts generic and comes out ball-flavored ⚽
and it happens many times in parallel (multi-head: one head tracking grammar, another names, another distance…) and layer after layer, meanings sharpening each pass.

The transformer = the architecture built around this trick, stacked deep: glance-and-blend, then think (a small dial-network per token), repeat ×dozens. Its superpower vs older models: all tokens attend at once (not one-by-one like RNNs) — perfect for GPU parallelism → we could finally train on the whole internet. The 2017 paper's title says everything: "Attention Is All You Need."

🗺️ Diagram

flowchart TB
    s["'The robot dropped the ball because IT was heavy'"]
    subgraph att["👀 attention - for the token 'it'"]
        q["'it' asks: who am I about?"]
        w["learned weights:<br/>ball 69% · heavy 16% · robot 6%"]
        blend["blend: 'it' comes out<br/>BALL-flavored ⚽"]
        q --> w --> blend
    end
    subgraph tf["🏗️ transformer = stack it deep"]
        l1["glance + think - layer 1"]
        l2["… ×32 layers, ×many heads,<br/>ALL tokens in parallel"]
        l1 --> l2
    end
    s --> att --> tf
    tf --> out["📊 next-piece scoreboard - lesson 05"]

❓ What

Mechanics in one line: each token makes a query ("what I'm looking for"), a key ("what I offer") and a value ("what you get if you pick me"); scores = query·key similarity (dot products on embeddings — lesson 04's geometry working); softmax → weights → blend of values. Our demo does literally this.
Multi-head: several attention patterns per layer, learned independently. Layers: dozens of glance-then-think repeats.
Context window (lesson 08's limit!) exists because every token attends to every other: cost grows ~quadratically with length. Long context = serious engineering.
The transformer replaced recurrent networks because parallelism let training scale — architecture unlocked the data, data unlocked the abilities.

🤔 Why

This is the "how can it possibly track what 'it' refers to across a paragraph?" answer — and the "why 2017?" answer. When you hear model specs — "32 layers, 96 heads, 128k context" — you now picture: how many glance-rounds, how many parallel glances, how far back eyes can reach.

🧪 Try it

python3 demo/attention_toy.py

Real dot-products, real softmax, hand-made seats: watch it choose ball at 69% — the heavy thing. Then make it robot-shaped ([0.5, 0.6, 0.1, 0.1], as if the sentence ended "…because it was tired") and rerun — watch the glance flip to robot. You just did what training does with the red pen: moved a seat, changed a mind.

⏭️ Next

We can now build a magnificent autocomplete that read the whole library. One problem: it completes — it doesn't behave. Raw model → helpful assistant: fine-tuning, RLHF and LoRA.

git checkout lesson-07-rlhf-lora

← Previousnext token Next →rlhf lora

This page is the lesson's README from the lesson-06-attention branch, shown here so the whole School stays on one site. Code files open on GitHub at the same branch.