# Tokens और Byte-Pair Encoding — Large Language Models

Source: https://www.geekswithgeeks.com/hi/llms/f-tokens

> समझें कि पाठ tokens में कैसे बँटता है और BPE शब्दावली कैसे बनाता है।

## शब्द नहीं, टुकड़े

मॉडल अक्षर या पूरे शब्द नहीं, **tokens** पढ़ते हैं: `the`, ` ing`, `Hel` जैसे बार-बार आने वाले टुकड़े या एक अक्षर। अधिकतर आधुनिक tokenizers **byte-pair encoding (BPE)** के रूप का उपयोग करते हैं: अलग-अलग अक्षरों से शुरू करें, सबसे आम पास-पास की जोड़ी को बार-बार नए प्रतीक में मिलाएँ, और चुने शब्दावली-आकार (अक्सर दसियों हज़ार से कुछ लाख tokens) पर रुकें। आम शब्द एक token बनते हैं; दुर्लभ शब्द टुकड़ों में बँटते हैं। अंग्रेज़ी में एक token लगभग तीन-चौथाई शब्द होता है, पर हिंदी सहित अन्य लिपियों में उसी अर्थ के लिए अक्सर ज़्यादा tokens लगते हैं, जो लागत और context लंबाई को प्रभावित करता है।

## Merges सीखना, चलाकर

मैंने यह सादा-Python (सिर्फ़ standard library) उदाहरण चलाया। छोटे corpus पर पहले merges `e+s` फिर `es+t` (newest/widest से) और `l+o`, `lo+w` (low/lower से) हैं। अंतिम सूची हर शब्द को उन tokens में दिखाती है जो BPE उपयोग करता।

```python
from collections import Counter

def get_pairs(words):
    pairs = Counter()
    for w, f in words.items():
        for a, b in zip(w, w[1:]):
            pairs[(a, b)] += f
    return pairs

def merge(words, pair):
    out = {}
    for w, f in words.items():
        new, i = [], 0
        while i < len(w):
            if i < len(w) - 1 and (w[i], w[i + 1]) == pair:
                new.append(w[i] + w[i + 1]); i += 2
            else:
                new.append(w[i]); i += 1
        out[tuple(new)] = f
    return out

corpus = {"low": 5, "lower": 2, "newest": 6, "widest": 3}
words = {tuple(w): f for w, f in corpus.items()}
for step in range(5):
    pair = get_pairs(words).most_common(1)[0][0]
    words = merge(words, pair)
    print(step + 1, "merge", pair)
print(list(words))

```

Output:

```
1 merge ('e', 's')
2 merge ('es', 't')
3 merge ('l', 'o')
4 merge ('lo', 'w')
5 merge ('n', 'e')
[('low',), ('low', 'e', 'r'), ('ne', 'w', 'est'), ('w', 'i', 'd', 'est')]
```

## शब्द नहीं, tokens गिनें

सीमाएँ और क़ीमतें tokens में होती हैं। गिनने को अपने provider का tokenizer उपयोग करें; सटीकता चाहिए तो शब्द-गणना से अनुमान न लगाएँ।

**Quiz:** BPE बार-बार क्या करता है?

- [ ] वर्णमाला sort करता है
- [ ] दुर्लभ अक्षर हटाता है
- [ ] शब्दों का अनुवाद करता है
- [x] सबसे आम पास-पास की जोड़ी को नए token में मिलाता है

*Answer:* सबसे आम पास-पास की जोड़ी को नए token में मिलाता है. आम जोड़ियाँ मिलाने से उपयोगी टुकड़ों की शब्दावली बनती है।