भाषा मॉडल टेक्स्ट कैसे बनाते हैं: Python में temperature और top-k

आसान शब्दों में अवधारणा

भाषा मॉडल हर संभावित अगले टोकन के लिए एक स्कोर (logit) देता है। सैंपलिंग सेटिंग तय करती हैं कि ये स्कोर चुनाव में कैसे बदलें; temperature अनियमितता को नियंत्रित करता है और top-k सिर्फ़ सबसे अच्छे विकल्प रखता है।

देखें कि भाषा मॉडल अगला टोकन कैसे चुनता है: शुद्ध Python में layer normalization, temperature और top-k सैंपलिंग।

मुख्य बातें

1 से कम temperature आउटपुट को ज़्यादा अनुमान योग्य बनाता है; 1 से ज़्यादा उसे ज़्यादा रचनात्मक बनाता है।
top-k सैंपलिंग कम संभावना वाले टोकन हटाती है ताकि टेक्स्ट विषय से न भटके।
टेक्स्ट एक-एक टोकन करके बनता है, और हर नया टोकन फिर से इनपुट में जाता है।
layer normalization कई लेयरों से गुज़रते समय मानों को स्थिर दायरे में रखता है।

इसका उपयोग कब करें?

समझें कि न्यूरल नेटवर्क और AI लाइब्रेरी के अंदर क्या होता है।
संबंधित चुनौतियों में खुद लागू करने से पहले विचार को समझें।
मशीन लर्निंग कोर्स, इंटरव्यू और प्रोजेक्ट की तैयारी करें।

इसे काम करते देखें

अगला शब्द चुनने के लिए पासे वाला बटन दबाएँ। चुनाव को ज़्यादा अनुमान योग्य बनाने के लिए temperature या top-k घटाएँ।

उदाहरण कोड

कोड चलाएँ →

main.py

import math
import random

# Layer normalization rescales a vector to mean 0 and variance 1.
def layer_norm(x, eps=1e-5):
    mean = sum(x) / len(x)
    var = sum((v - mean) ** 2 for v in x) / len(x)
    return [(v - mean) / math.sqrt(var + eps) for v in x]
print("layer norm:", [round(v, 3) for v in layer_norm([2.0, 4.0, 6.0, 8.0])])

# Next-token scores from a model; temperature and top-k shape the choice.
words = ["cat", "dog", "car", "sky"]
logits = [2.0, 1.5, 0.3, -1.0]

def probabilities(temperature=1.0, top_k=None):
    scores = [l / temperature for l in logits]
    if top_k:  # keep only the k best scores
        cutoff = sorted(scores, reverse=True)[top_k - 1]
        scores = [s if s >= cutoff else -1e9 for s in scores]
    exps = [math.exp(s - max(scores)) for s in scores]
    return [e / sum(exps) for e in exps]

for t, k in [(1.0, None), (0.5, None), (1.0, 2)]:
    print(f"temperature={t} top_k={k}:", [round(p, 2) for p in probabilities(t, k)])

random.seed(7)
print("sampled:", random.choices(words, weights=probabilities(0.8, 3), k=5))

अपेक्षित आउटपुट

layer norm: [-1.342, -0.447, 0.447, 1.342]
temperature=1.0 top_k=None: [0.54, 0.33, 0.1, 0.03]
temperature=0.5 top_k=None: [0.71, 0.26, 0.02, 0.0]
temperature=1.0 top_k=2: [0.62, 0.38, 0.0, 0.0]
sampled: ['cat', 'cat', 'dog', 'cat', 'cat']

यह कैसे काम करता है

layer_norm() वेक्टर को औसत 0 और प्रसरण 1 पर ले आता है, जैसा Transformer हर ब्लॉक में करते हैं। probabilities() logit को temperature से भाग देकर softmax लगाता है, इसलिए कम temperature से सबसे ऊपर वाले शब्द के चुने जाने की संभावना बढ़ जाती है। top-k, softmax से पहले सबसे अच्छे k के बाहर के हर स्कोर को लगभग −∞ कर देता है।

मान बदलें और Python इंस्टॉल किए बिना CodeUtility ऑनलाइन Python कंपाइलर में प्रोग्राम चलाएँ।

अभ्यास के कार्य

बड़े dataset पर जाने से पहले input बदलें और edge cases की जाँच करें।

इनपुट या वेट बदलें और रन करने से पहले आउटपुट का अनुमान लगाएँ।
हर गणना चरण को देखने के लिए बीच के मान प्रिंट करें।
नीचे दी गई चुनौतियाँ हल करके विचार को खुद लागू करें।

Python IDE में चलाएँ →

चैलेंज से अभ्यास करें

इस पाठ में सीखी बात से एक असली समस्या हल करें। हर चैलेंज ब्राउज़र में चलता है, तुरंत टेस्ट और AI रिव्यू के साथ।

सभी चैलेंज