LLM क्या है?
chat सहायकों के पीछे वाले जैसा एक बड़ा भाषा मॉडल (LLM), मूल रूप से, अगले token का एक विशाल अनुमान लगाने वाला है। कुछ शब्द पूरी चीज़ को समझा देते हैं।
- Tokens। टेक्स्ट को tokens कहे जाने वाले टुकड़ों में काटा जाता है, मोटे तौर पर शब्द या शब्दों के टुकड़े। मॉडल कच्चे अक्षर नहीं, tokens पढ़ता और लिखता है। एक मोटा नियम: एक token अंग्रेज़ी के लगभग चार अक्षर है।
- अनुमान। अब तक के tokens दिए जाने पर मॉडल हर संभव अगले token की एक प्रायिकता देता है। वह एक चुनता है, उसे जोड़ता है, और दोहराता है। इसी loop से वह पूरे अनुच्छेद लिखता है।
- Prompt। वह टेक्स्ट जो आप देते हैं। आपके अनुरोध के बारे में मॉडल जो कुछ जानता है वह prompt में रहता है, इसलिए आप उसे कैसे लिखते हैं वह बहुत मायने रखता है (अगले पाठ)।
- Temperature। उस चुनाव के रैंडमपन पर एक knob।
0के पास मॉडल लगभग हमेशा सबसे संभावित token लेता है (केंद्रित, दोहराव वाला)। ऊँचे मान उसे कम संभावित tokens चुनने देते हैं (ज़्यादा रचनात्मक, कम भरोसेमंद)। local मॉडल, जैसे इस कोर्स के कैपस्टोन वाला, अब भी यह knob लेते हैं। सबसे नए hosted Claude मॉडल नहीं लेते: वे अपना sampling ख़ुद तय करते हैं और temperature सेटिंग पर error देते हैं, इसलिए वहाँ आप prompt से आउटपुट चलाते हैं। - Hallucination। क्योंकि यह तथ्य देखने के बजाय विश्वसनीय टेक्स्ट का अनुमान लगाता है, एक LLM पूरे आत्मविश्वास से ग़लत बातें कह सकता है। उसके दिए तथ्य हमेशा जाँचें।
असली tokenizers subword-आधारित और डेटा से सीखे होते हैं। हम यहाँ वह नहीं बनाएँगे, पर tokens गिनना कैसा है यह महसूस करने के लिए सबसे सादा संभव tokenizer (ख़ाली जगह पर split) बना सकते हैं। इस्तेमाल और सीमाएँ token गिनतियों से मापी जाती हैं।
def tokenize(text):
return text.split() # whitespace tokens
tokenize("the cat sat") # ['the', 'cat', 'sat']ख़ाली जगह पर split करना बस महसूस करने वाला विकल्प है। असली tokenizers subword टुकड़ों में बाँटते हैं, इसलिए बजट का एक आम मोटा नियम tokens ≈ len(text) / 4 अक्षर है, और production कोड अंदाज़ा लगाने के बजाय API के लौटाए usage field (या एक ख़ास count-tokens endpoint) से सटीक गिनती पढ़ता है।
Reasoning मॉडल
ऊपर का सब कुछ एक ऐसे मॉडल को बताता है जो अपना जवाब सीधे देता है। एक नया परिवार, reasoning मॉडल, पहले समस्या पर क़दम दर क़दम काम करने में "सोचने" वाले tokens का एक छिपा बजट ख़र्च करता है, फिर आख़िरी जवाब लिखता है। वह अतिरिक्त सोच-विचार कठिन, कई-क़दमों वाले कामों (गणित, कोड, सावधान योजना) पर असली सटीकता देता है, और आपको अक्सर एक dial मिलता है: ऊँचा effort या thinking बजट मतलब ज़्यादा सोचने वाले tokens, ज़्यादा देरी, और ज़्यादा लागत। engineering की समझ बस यह है कि यह कब लायक है: सचमुच कठिन क़दम पर reasoning मॉडल इस्तेमाल करें, और रोज़ वालों के लिए तेज़, सस्ता मॉडल। आप बाद में ठीक यही अदला-बदली काम में लाएँगे जब आप एक लागत समझने वाला cascade बनाएँगे जो आसान अनुरोधों को सस्ते मॉडल तक भेजता है और सिर्फ़ कठिन वालों को आगे बढ़ाता है।
एक सादा ख़ाली-जगह tokenizer लिखें। tokenize(text) ख़ाली जगह से अलग tokens की सूची लौटाता है (.split() इस्तेमाल करें)। count_tokens(text) लौटाता है कि कितने हैं। फिर tokens = tokenize(sample) और n_tokens = count_tokens(sample) सेट करें।
इस पाठ में कोई समस्या दिखी? बताएँ · इस पाठ के बारे में पूछें
यह अभ्यास जल्द खुलेगा
इससे पहले वाला पाठ पूरा करें और यह खुल जाएगा। पूरा कोर्स मुफ़्त है, कोई खाता नहीं चाहिए, और आप यह पाठ अभी पढ़ सकते हैं।
यह ब्राउज़र learn.floati.life के लिए कुकी रोक रहा है, इसलिए यहाँ पूरे किए गए पाठ क्रम से नहीं खुल सकते। इस साइट के लिए कुकी की अनुमति दें और फिर से लोड करें।