🧩 धडा 03 — Tokens: text चे puzzle तुकड्यांत कापणे

📍 तुम्ही इथे आहात: 12 पैकी धडा 03 · मागे: lesson-02-training · पुढे: lesson-04-embeddings

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

धडे 01–02, आणि तुम्ही कधीही type केलेल्या प्रत्येक prompt ला सर्वात आधी होणारी गोष्ट: tokenization. खरी file: demo/tokenizer_toy.py — tokenizer आपले तुकडे शिकताना पाहा.

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

model हा एक calculator आहे — तो आकडे खातो, अक्षरे नाही. म्हणून बाकी काहीही होण्याआधी, text puzzle तुकड्यांत 🧩 कापला जातो आणि प्रत्येक तुकड्याला एक ID क्रमांक मिळतो. कोणते तुकडे? इथेच हुशारी आहे — ते कोणीही हाताने निवडत नाही. tokenizer ते data मधून शिकतो, एकाच, ऐकायला मूर्ख वाटणाऱ्या नियमाने, जो हजारो वेळा पुन्हा केला जातो:

"एकमेकांच्या शेजारी सर्वात जास्त वेळा येणारे दोन तुकडे शोधा. त्यांना चिकटवून एक तुकडा करा. पुन्हा करा." (हेच BPE — byte-pair encoding.)

हे पुरेसा वेळ चालवा आणि तुकडे अप्रतिम समजूतदार बनतात: नेहमीचे शब्द एकच तुकडा बनतात (the, school), दुर्मीळ शब्द उप-तुकड्यांतून बनतात (un + believ + able), आणि काहीही — कोणतीही typo, कोणतीही भाषा, कोणतेही emoji — छोट्या तुकड्यांतून अजूनही लिहिता येते. ~50–100 हजार तुकडे संपूर्ण मानवी text व्यापतात.

यातून तुम्ही अनुभवलेल्या खऱ्या विचित्रपणांचे स्पष्टीकरण मिळते:

"strawberry मध्ये किती R आहेत?" यात अडचण येते — model ला [st][raw][berry]-सारखे IDs दिसतात, अक्षरे कधीच नाहीत. गोठलेल्या puzzle तुकड्यांमधून अक्षरे मोजणे खरोखरच अवघड आहे! 🍓
Pricing आणि limits "per token" असतात — काय मोजले जाते ते आता तुम्हाला नेमके माहीत आहे (English मध्ये प्रत्येकी ~¾ शब्द).
काही भाषांना 2–3× जास्त tokens लागतात — training data मध्ये त्यांचे तुकडे दुर्मीळ होते, म्हणून त्यांना छोटे तुकडे मिळाले.

🗺️ आकृती

flowchart LR
    t["📝 text<br/>'the robot reads'"]
    bpe["🧩 tokenizer - BPE<br/>glue the most frequent pair,<br/>repeat thousands of times"]
    ids["🔢 token IDs<br/>[464, 9379, 9743]"]
    m["🧠 model<br/>sees ONLY these numbers -<br/>never words, never letters"]
    t -->|"1 cut into learned pieces"| bpe -->|"2 look up IDs"| ids -->|"3"| m

❓ काय

Token = ID असलेला, शिकलेला एक text तुकडा. ढोबळ नियम: 1 token ≈ 4 अक्षरे ≈ ¾ English शब्द; "1,000 tokens ≈ 750 शब्द".
vocabulary (सगळे तुकडे + IDs) training च्या वेळीच ठरते — त्यानंतर कायमसाठी ती model ची वर्णमाला.
पुढचे सगळे tokens मध्ये मोजले जाते: context windows (धडा 09), API pricing, वेग ("tokens per second"), आणि model चा output सुद्धा एकेक token करून निवडला जातो (धडा 05).
Subword बाकी पर्यायांपेक्षा सरस: word-level नवे शब्द हाताळू शकत नाही; character-level मुळे sequences भयंकर लांब होतात. BPE ही जिंकलेली तडजोड आहे.

🤔 का

Tokens ही model ची संवेदना-व्यवस्था आहे — याहून बारीक काहीही त्याला अक्षरशः जाणवू शकत नाही. "LLMs X मध्ये विचित्रपणे वाईट आहेत" या यादीचा अर्धा भाग (spelling चे खेळ, लांब आकड्यांवरचे गणित, काही भाषांतील यमक) "अर्थातच — त्याला खरोखर दिसणारे तुकडे पाहा" यात विरघळतो. model च्या वागण्याचे debugging त्याला काय दिसले इथून सुरू होते, आणि त्याला हेच दिसते.

🧪 करून पाहा

python3 demo/tokenizer_toy.py

पाहा BPE आधी e+a, मग t+he चिकटवतो, मग tea/ead वाढवतो — एका मूर्ख नियमातून समजूतदार तुकडे तुमच्या डोळ्यांसमोर तयार होतात. मग एका खऱ्याशी खेळा: OpenAI चे tokenizer playground किंवा tiktoken — त्यात unbelievable, strawberry, आणि एक Hindi वाक्य paste करा, आणि तुकडे मोजा.

⏭️ पुढे

प्रत्येक तुकड्याचा ID मग आकड्यांच्या यादीत बदलतो, जी त्याचा अर्थ साठवते — जवळजवळ समानार्थी शब्द शेजारी येतात: embeddings, अर्थांचा बैठक-तक्ता.

git checkout lesson-04-embeddings

🧩 Lesson 03 — Tokens: cutting text into puzzle pieces

📍 You are here: Lesson 03 of 12 · Previous: lesson-02-training · Next: lesson-04-embeddings

📦 What's in this branch

Lessons 01–02, plus the first thing that happens to every prompt you ever type: tokenization. Real file: demo/tokenizer_toy.py — watch a tokenizer learn its pieces.

🧒 Explain like I'm 5

A model is a calculator — it eats numbers, not letters. So before anything else, text is cut into puzzle pieces 🧩 and each piece gets an ID number. Which pieces? Here's the clever part — nobody chooses them by hand. The tokenizer learns them from data, by one dumb-sounding rule repeated thousands of times:

"Find the two pieces that appear next to each other most often. Glue them into one piece. Repeat." (That's BPE — byte-pair encoding.)

Run it long enough and the pieces become wonderfully sensible: common words end up as ONE piece (the, school), rare words get built from sub-pieces (un + believ + able), and anything — any typo, any language, any emoji — can still be spelled out from small pieces. ~50–100 thousand pieces cover all human text.

This explains real quirks you've met:

"How many R's in strawberry?" struggles — the model sees [st][raw][berry]-ish IDs, never letters. Counting letters through frozen puzzle pieces is genuinely hard! 🍓
Pricing & limits are "per token" — you now know exactly what's being counted (~¾ of a word each, in English).
Some languages cost 2–3× more tokens — their pieces were rarer in the training data, so they got smaller pieces.

🗺️ Diagram

flowchart LR
    t["📝 text<br/>'the robot reads'"]
    bpe["🧩 tokenizer - BPE<br/>glue the most frequent pair,<br/>repeat thousands of times"]
    ids["🔢 token IDs<br/>[464, 9379, 9743]"]
    m["🧠 model<br/>sees ONLY these numbers -<br/>never words, never letters"]
    t -->|"1 cut into learned pieces"| bpe -->|"2 look up IDs"| ids -->|"3"| m

❓ What

Token = one learned text piece with an ID. Rule of thumb: 1 token ≈ 4 characters ≈ ¾ English word; "1,000 tokens ≈ 750 words".
The vocabulary (all pieces + IDs) is fixed at training time — the model's alphabet forever after.
Everything downstream counts in tokens: context windows (lesson 09), API pricing, speed ("tokens per second"), and the model's output is chosen one token at a time (lesson 05).
Subword beats the alternatives: word-level can't handle new words; character-level makes sequences brutally long. BPE is the compromise that won.

🤔 Why

Tokens are the model's sensory system — it literally cannot perceive anything finer. Half the "LLMs are weirdly bad at X" list (spelling games, arithmetic on long numbers, rhyming in some languages) dissolves into "of course — look at the pieces it actually sees." Debugging model behavior starts with what did it see, and this is what it sees.

🧪 Try it

python3 demo/tokenizer_toy.py

Watch BPE glue e+a, then t+he, then grow tea/ead — sensible pieces emerging from a dumb rule, before your eyes. Then go play with a real one: OpenAI's tokenizer playground or tiktoken — paste unbelievable, strawberry, and a Hindi sentence, and count the pieces.

⏭️ Next

Each piece-ID then becomes a list of numbers that encodes its meaning — near-synonyms end up neighbors: embeddings, the seating chart of meanings.

git checkout lesson-04-embeddings

← Previoustraining Next →embeddings

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