एक LLM बनाएँमध्यमपाठ 376 मिनट का पाठ

स्टेप 1 · टोकनाइज़र

इससे पहले कि कोई मॉडल भाषा को समझे, किसी चीज़ को टेक्स्ट को टुकड़ों में काटना पड़ता है। अगर यह गलत हो गया, तो आगे की सारी चीजें चुपके से खराब हो जाती हैं।

पाठ वीडियो में

60 सेकंड में

स्टेप 1 · टोकनाइज़र

इससे पहले कि कोई मॉडल भाषा को समझे, किसी चीज़ को टेक्स्ट को टुकड़ों में काटना पड़ता है। अगर यह गलत हो गया, तो आगे की सारी चीजें चुपके से खराब हो जाती हैं।

1/5
आसान शब्दों में
कंप्यूटर अक्षर नहीं पढ़ सकते। इसलिए हम एक डिक्शनरी बनाते हैं: अक्षरों के हर आम टुकड़े को एक नंबर मिलता है। "Hello" नंबर 15496 हो सकता है। मॉडल हमेशा सिर्फ़ नंबर ही देखता है।
एक टोकनाइज़र टेक्स्ट को integers की एक लिस्ट में बदलता है और वापस भी। इसके तीन विकल्प हैं, और सभी मॉडर्न मॉडल तीसरे विकल्प को चुनते हैं:
तरीकाVocabularyसमस्या
हर कैरेक्टर के लिए एक टोकन~100सीक्वेंस बहुत ज़्यादा लंबे हो जाते हैं; मॉडल अपनी क्षमता स्पेलिंग पर बर्बाद करता है
हर शब्द के लिए एक टोकनलाखों में, और फिर भी अधूरीहर टाइपो और दुर्लभ नाम एक unknown टोकन बन जाता है
सबवर्ड (BPE)30k–200kकोई गंभीर समस्या नहीं — इसीलिए हर कोई इसका इस्तेमाल करता है

बाइट-पेयर एन्कोडिंग, एक पैराग्राफ में

हर बाइट को एक अलग टोकन मानकर शुरुआत करें। गिनें कि आपके कॉर्पस में पास-पास वाले टोकन्स का कौन सा पेयर सबसे ज़्यादा आता है। उस जोड़े को मिलाकर एक नया टोकन बना लें। इसे कुछ हज़ार बार दोहराएं। आम शब्द अकेले टोकन बन जाते हैं; दुर्लभ शब्द पहचाने जा सकने वाले टुकड़ों में टूट जाते हैं; और कुछ भी कभी अज्ञात नहीं रहता, क्योंकि आप हमेशा रॉ बाइट्स (raw bytes) पर लौट सकते हैं।
Train a byte-pair encoderpython
from collections import Counter

def get_pairs(ids):
    return Counter(zip(ids, ids[1:]))

def merge(ids, pair, new_id):
    out, i = [], 0
    while i < len(ids):
        if i < len(ids) - 1 and (ids[i], ids[i+1]) == pair:
            out.append(new_id); i += 2
        else:
            out.append(ids[i]); i += 1
    return out

def train_bpe(text, vocab_size=512):
    ids = list(text.encode("utf-8"))       # start: raw bytes, 0-255
    merges = {}
    for new_id in range(256, vocab_size):
        pairs = get_pairs(ids)
        if not pairs: break
        best = max(pairs, key=pairs.get)   # most frequent adjacent pair
        ids = merge(ids, best, new_id)
        merges[best] = new_id
    return merges

def encode(text, merges):
    ids = list(text.encode("utf-8"))
    for pair, new_id in merges.items():    # apply in training order
        ids = merge(ids, pair, new_id)
    return ids

def decode(ids, merges):
    vocab = {i: bytes([i]) for i in range(256)}
    for (a, b), new_id in merges.items():
        vocab[new_id] = vocab[a] + vocab[b]
    return b"".join(vocab[i] for i in ids).decode("utf-8", errors="replace")
यह चालीस लाइनों में बना एक काम करने वाला टोकनाइज़र है। प्रोडक्शन वर्ज़न में एक regex प्री-स्प्लिट (ताकि टोकन अजीब तरीके से शब्दों की सीमाओं को पार न करें), स्पेशल टोकन, और एक तेज़ Rust इम्प्लीमेंटेशन जोड़ा जाता है — लेकिन ऊपर दिया गया एल्गोरिदम ही असली है।

टोकनाइज़र से जुड़े फैसले आपको बाद में क्यों परेशान करते हैं

  1. 1

    Vocabulary का साइज़ एक समझौता है

    बड़ी vocabulary का मतलब है छोटे सीक्वेंस और तेज़ इन्फ़रेंस (inference), लेकिन एक बड़ा एम्बेडिंग मैट्रिक्स और ऐसे टोकन्स जो बहुत कम दिखते हैं। आज के समय में 32k से 128k एक सामान्य रेंज है।
  2. 2

    भाषा का दायरा राजनीतिक भी है और व्यावहारिक भी

    अगर आपका कॉर्पस मुख्य रूप से अंग्रेज़ी था, तो हिंदी या तमिल टेक्स्ट में वही बात कहने के लिए तीन से पांच गुना ज़्यादा टोकन खर्च होते हैं। यह उन यूज़र्स के लिए पैसे और लेटेंसी (देरी) दोनों का असली नुकसान है, जो टोकनाइज़र बनाते समय ही तय हो जाता है।
  3. 3

    नंबरों और कोड पर ध्यान देने की ज़रूरत होती है

    "12345" को अजीबोगरीब टुकड़ों में बांटने से अंकगणित (arithmetic) खराब हो जाता है। ज़्यादातर मॉडर्न टोकनाइज़र जानबूझकर अंकों को अलग-अलग तोड़ते हैं।
  4. 4

    आप इसे बाद में बदल नहीं सकते

    एम्बेडिंग टेबल टोकन id द्वारा इंडेक्स होती है। अगर टोकनाइज़र बदला, तो आपके ट्रेन किए गए सारे वेट्स (weights) बेकार हो जाएंगे। फैसला एक ही बार लें।
सावधान रहें
यही वजह है कि मॉडल किसी शब्द में अक्षरों को गिनने या किसी स्ट्रिंग को उलटने में संघर्ष करते हैं। वे कभी अक्षर देखते ही नहीं — वे टुकड़े देखते हैं। "strawberry में कितने r हैं" पूछना किसी से उन चीज़ों को गिनने के लिए कहने जैसा है जो वे देख ही नहीं सकते।
यह करें
व्यावहारिक सलाह: जब तक आप T3 या उससे ऊपर प्रीट्रेनिंग नहीं कर रहे हैं, अपना खुद का टोकनाइज़र ट्रेन न करें। जिस मॉडल पर आप काम कर रहे हैं, उसी के टोकनाइज़र का दोबारा इस्तेमाल करें। बेमेल टोकनाइज़र फाइन-ट्यूनिंग में सबसे आम साइलेंट बग्स में से एक हैं।

और देखें और पढ़ें

Let's build the GPT TokenizerAndrej Karpathy · 2 hr · video

लैब

आपके द्वारा लिखा गया एक BPE टोकनाइज़र, जिसे किसी असली टोकनाइज़र से बेंचमार्क किया गया हो।

~25 min

समस्या

Module 37 से BPE ट्रेनिंग और एन्कोडिंग लागू करें। इसे कुछ MB टेक्स्ट पर ट्रेन करें। फिर अंग्रेज़ी और किसी भारतीय भाषा के लिए प्रति शब्द टोकन मापें, और किसी प्रोडक्शन टोकनाइज़र से तुलना करें।
शुरुआती कोडpython
# Measure the fertility gap that decides who pays more per request
for lang, text in samples.items():
    n_tokens = len(encode(text, merges))
    n_words = len(text.split())
    print(f"{lang:10} {n_tokens/n_words:.2f} tokens/word")
Google Colab खोलें ↗इस कोड के लिए आपके अपने सेटअप की ज़रूरत है (एक मॉडल, एक GPU या अतिरिक्त पैकेज)। इसे Google Colab में चलाएं: File → Upload notebook।

आपका काम तब पूरा होगा जब

कठिन सवाल

उत्तर देखने से पहले ख़ुद जवाब देने की कोशिश करें। अगर आप इनके जवाब दे सकते हैं, तो आप पाठ समझ गए हैं।

Q1आपके टोकनाइज़र को प्रति हिंदी शब्द 3.5 टोकन और प्रति अंग्रेज़ी शब्द 1.3 टोकन की ज़रूरत होती है। इसके हर परिणाम को बताएं।दिखाएं
हिंदी यूज़र्स हर रिक्वेस्ट के लिए ~2.7 गुना ज़्यादा पैसे चुकाते हैं और उन्हें ज़्यादा इंतज़ार करना पड़ता है; शब्दों के मामले में उनकी असरदार कॉन्टेक्स्ट विंडो ~2.7 गुना छोटी होती है, इसलिए लंबे दस्तावेज़ जल्दी कट जाते हैं; मॉडल की ज़्यादा क्षमता अर्थ समझने के बजाय टोकनाइज़ेशन पर खर्च होती है, जिससे क्वालिटी साफ़ तौर पर कम हो जाती है; और ट्रेनिंग के सीमित कंप्यूट में, खर्च किए गए प्रति टोकन के हिसाब से हिंदी टेक्स्ट से कम शब्दों की सीख मिलती है। टोकनाइज़र की निष्पक्षता एक प्रोडक्ट का फैसला है जो सिर्फ एक तकनीकी बारीकी जैसा दिखता है, और यह ट्रेनिंग के समय ही हमेशा के लिए तय हो जाता है।

जारी रखने के लिए कृपया साइन इन करें।

अक्सर पूछे जाने वाले सवाल

एक शब्द में कितने टोकन होते हैं?

अंग्रेज़ी में औसतन प्रति शब्द लगभग 1.3 टोकन होते हैं, या प्रति टोकन लगभग 4 कैरेक्टर। कोड, गैर-लैटिन लिपियों और असामान्य नामों में ज़्यादा टोकन खर्च होते हैं। सिर्फ़ अंदाज़े पर भरोसा करने के बजाय हमेशा अपने असली डेटा पर मापें।

स्पेशल टोकन क्या होते हैं?

ऐसे रिज़र्व किए गए id जो सामान्य टेक्स्ट से कभी अपने आप नहीं बन सकते: end-of-text, padding, और chat-role मार्कर्स जैसे beginning-of-turn। ये मॉडल को एक स्पष्ट स्ट्रक्चर देते हैं। फाइन-ट्यूनिंग में इन्हें गलत कर दिया, तो मॉडल को समझ नहीं आएगा कि टेक्स्ट जनरेट करना कब रोकना है।

कुछ मॉडल SentencePiece का इस्तेमाल क्यों करते हैं?

SentencePiece इनपुट को खाली जगहों (whitespace) सहित एक रॉ स्ट्रीम की तरह लेता है, जिससे भाषा-विशिष्ट प्री-टोकनाइज़ेशन नियमों से बचा जा सकता है। यह बहुभाषी मॉडलों के लिए मुफीद है। Byte-level BPE और SentencePiece unigram दो सबसे प्रमुख परिवार हैं।

क्या मैं vocabulary को बढ़ा सकता हूँ?

हाँ — नए टोकन जोड़ें और एम्बेडिंग मैट्रिक्स को बड़ा करें, नई पंक्तियों को समझदारी से इनिशियलाइज़ करें (अक्सर सब-टोकन एम्बेडिंग्स का औसत लेकर)। यह किसी खास डोमेन की शब्दावली या नई लिपि जोड़ने के लिए उपयोगी है। इसका कोई फायदा होने के लिए आगे ट्रेनिंग की ज़रूरत होती है।

पाठ का टेस्ट

5 सवाल। पास होने और इस पाठ को पूरा करने के लिए 3 सही होने चाहिए (60%)।

टेस्ट देने और अपनी प्रोग्रेस सेव करने के लिए साइन इन करें