न्यूरल नेटवर्क को समझना

Home PDF

ज़िवेई:

क्या आप कोड समझा सकते हैं?

        self.weights = [w-(eta/len(mini_batch))*nw
                        for w, nw in zip(self.weights, nabla_w)]
        self.biases = [b-(eta/len(mini_batch))*nb
                       for b, nb in zip(self.biases, nabla_b)]

इस कोड को हिंदी में समझाएं:

यह कोड एक न्यूरल नेटवर्क के वज़न (weights) और पूर्वाग्रह (biases) को अपडेट करने के लिए है। यह ग्रेडिएंट डिसेंट (gradient descent) एल्गोरिदम का उपयोग करता है, जहां eta सीखने की दर (learning rate) है और mini_batch ट्रेनिंग डेटा का एक छोटा हिस्सा है।

self.weights और self.biases नेटवर्क के वर्तमान वज़न और पूर्वाग्रह हैं।
nabla_w और nabla_b वज़न और पूर्वाग्रह के लिए ग्रेडिएंट हैं।
eta/len(mini_batch) सीखने की दर को मिनी-बैच के आकार से विभाजित करता है, जिससे प्रत्येक अपडेट छोटा हो जाता है।
zip(self.weights, nabla_w) और zip(self.biases, nabla_b) वज़न और ग्रेडिएंट, तथा पूर्वाग्रह और ग्रेडिएंट को जोड़ते हैं, ताकि प्रत्येक वज़न और पूर्वाग्रह को उसके संबंधित ग्रेडिएंट के साथ अपडेट किया जा सके।

अंत में, self.weights और self.biases को नए मानों के साथ अपडेट किया जाता है, जो नेटवर्क को बेहतर ढंग से ट्रेन करने में मदद करता है।

चैटजीपीटी (ChatGPT)

बिल्कुल! आपके द्वारा प्रदान किया गया कोड एक मशीन लर्निंग एल्गोरिदम का हिस्सा प्रतीत होता है, विशेष रूप से न्यूरल नेटवर्क के प्रशिक्षण प्रक्रिया के दौरान वज़न और पूर्वाग्रहों को अपडेट करने के लिए स्टोकेस्टिक ग्रेडिएंट डिसेंट (SGD) का एक कार्यान्वयन है। आइए इसे चरण दर चरण समझते हैं:

self.weights और self.biases: ये वेरिएबल्स संभवतः एक न्यूरल नेटवर्क क्लास का हिस्सा हैं, जो नेटवर्क के वज़न और बायस को प्रदर्शित करते हैं। एक न्यूरल नेटवर्क में, वज़न वे पैरामीटर होते हैं जो विभिन्न लेयर्स के न्यूरॉन्स के बीच कनेक्शन की ताकत को समायोजित करते हैं, जबकि बायस वे पैरामीटर होते हैं जो न्यूरॉन के एक्टिवेशन थ्रेशोल्ड को नियंत्रित करते हैं।
nabla_w और nabla_b: ये चर संभवतः वज़न और पूर्वाग्रहों के संबंध में लागत फ़ंक्शन के ग्रेडिएंट्स को संग्रहीत करते हैं। प्रशिक्षण प्रक्रिया के दौरान, ग्रेडिएंट्स की गणना की जाती है ताकि यह निर्धारित किया जा सके कि लागत फ़ंक्शन वज़न और पूर्वाग्रहों के संबंध में कैसे बदलता है, और इस जानकारी का उपयोग पैरामीटर्स को अपडेट करने के लिए किया जाता है ताकि लागत को कम किया जा सके।
eta: यह लर्निंग रेट है, जो पैरामीटर अपडेट के दौरान ग्रेडिएंट्स की दिशा में लिए गए कदम के आकार को नियंत्रित करता है। एक उच्च लर्निंग रेट प्रशिक्षण के दौरान तेजी से अभिसरण (convergence) का कारण बन सकता है, लेकिन यह अस्थिरता भी पैदा कर सकता है। एक छोटा लर्निंग रेट स्थिरता में सुधार कर सकता है लेकिन प्रशिक्षण समय को बढ़ा सकता है।
mini_batch: यह स्टोकेस्टिक ग्रेडिएंट डिसेंट के प्रत्येक पुनरावृत्ति के लिए उपयोग किए जाने वाले प्रशिक्षण डेटा का एक उपसमूह है। मिनी-बैच ग्रेडिएंट डिसेंट SGD का एक प्रकार है जहां पूरे प्रशिक्षण डेटासेट को छोटे बैचों में विभाजित किया जाता है, और प्रत्येक मिनी-बैच का उपयोग करके पैरामीटर अपडेट किए जाते हैं।

अब, आइए कोड को ही देखें:

self.weights = [w-(eta/len(mini_batch))*nw
                for w, nw in zip(self.weights, nabla_w)]

इस कोड को हिंदी में समझाएं:

यह कोड self.weights को अपडेट कर रहा है। यहां w वर्तमान वजन (weight) है और nw ग्रेडिएंट (gradient) है जो nabla_w से आता है। eta लर्निंग रेट (learning rate) है और mini_batch मिनी-बैच का आकार है।

फॉर्मूला के अनुसार, नया वजन w को eta/len(mini_batch) से गुणा किए गए nw को घटाकर प्राप्त किया जाता है। यह प्रक्रिया self.weights और nabla_w के प्रत्येक जोड़े के लिए की जाती है।

यह पंक्ति न्यूरल नेटवर्क के वज़न को अपडेट करती है। यह प्रत्येक वज़न w और उसके संगत ग्रेडिएंट nw के माध्यम से लूप करने के लिए एक लिस्ट कॉम्प्रिहेंशन का उपयोग करती है। प्रत्येक वज़न के लिए, यह मूल वज़न से ग्रेडिएंट के एक हिस्से (जो लर्निंग रेट eta और मिनी-बैच के आकार से स्केल किया गया है) को घटाती है। यही तरीका है जिससे वज़न को कॉस्ट फ़ंक्शन को कम करने के लिए अपडेट किया जाता है।

self.biases = [b-(eta/len(mini_batch))*nb
               for b, nb in zip(self.biases, nabla_b)]

इस कोड को हिंदी में समझाएं:

यह कोड self.biases को अपडेट कर रहा है। यहां self.biases एक लिस्ट है जिसमें बायस (bias) वैल्यूज़ हैं। nabla_b भी एक लिस्ट है जिसमें ग्रेडिएंट (gradient) वैल्यूज़ हैं।

zip(self.biases, nabla_b) का उपयोग करके self.biases और nabla_b की वैल्यूज़ को जोड़ा जाता है। फिर, प्रत्येक बायस b को उसके संबंधित ग्रेडिएंट nb से अपडेट किया जाता है। अपडेट फॉर्मूला है:

b - (eta / len(mini_batch)) * nb

यहां:

eta लर्निंग रेट (learning rate) है।
len(mini_batch) मिनी-बैच के आकार को दर्शाता है।

इस प्रकार, यह कोड ग्रेडिएंट डिसेंट (gradient descent) का उपयोग करके बायस वैल्यूज़ को अपडेट करता है।

यह पंक्ति न्यूरल नेटवर्क के बायस को एक समान तरीके से अपडेट करती है। यह प्रत्येक बायस b और उसके संबंधित ग्रेडिएंट nb के माध्यम से लूप करने के लिए एक लिस्ट कॉम्प्रिहेंशन का उपयोग करती है। प्रत्येक बायस के लिए, यह मूल बायस से ग्रेडिएंट के एक हिस्से (जो लर्निंग रेट eta और मिनी-बैच के आकार से स्केल किया गया है) को घटाती है।

संक्षेप में, ये कोड की पंक्तियां स्टोकेस्टिक ग्रेडिएंट डिसेंट (SGD) का उपयोग करके न्यूरल नेटवर्क के वजन और बायस को अपडेट करती हैं। यह प्रक्रिया प्रशिक्षण चरण के दौरान प्रत्येक मिनी-बैच के लिए दोहराई जाती है ताकि नेटवर्क के पैरामीटर्स को अनुकूलित किया जा सके और दिए गए कार्य पर इसके प्रदर्शन में सुधार किया जा सके।

ज़िवेई: SpaCy भाषा मॉडल क्या है?

ChatGPT: SpaCy एक ओपन-सोर्स प्राकृतिक भाषा प्रसंस्करण (NLP) लाइब्रेरी है जिसे Explosion AI द्वारा विकसित किया गया है। यह कुशल, तेज़ और प्रोडक्शन-रेडी होने के लिए डिज़ाइन की गई है, जिससे यह विभिन्न NLP कार्यों के लिए एक लोकप्रिय विकल्प बन गई है। SpaCy पूर्व-प्रशिक्षित भाषा मॉडल प्रदान करती है जो टेक्स्ट को प्रोसेस और समझ सकते हैं, जिससे डेवलपर्स विभिन्न NLP कार्य जैसे पार्ट-ऑफ-स्पीच टैगिंग, नामित इकाई पहचान, वाक्य पार्सिंग आदि कर सकते हैं।

SpaCy भाषा मॉडल की प्रमुख विशेषताएं निम्नलिखित हैं:

टोकनाइज़ेशन: SpaCy विभिन्न भाषाई नियमों और जटिलताओं को ध्यान में रखते हुए किसी पाठ को अलग-अलग शब्दों या टोकन में विभाजित कर सकता है।
पार्ट-ऑफ-स्पीच टैगिंग: यह लाइब्रेरी प्रत्येक टोकन को पार्ट-ऑफ-स्पीच टैग्स असाइन कर सकती है, जो यह दर्शाता है कि यह एक संज्ञा, क्रिया, विशेषण आदि है।
नामित इकाई पहचान (NER): SpaCy व्यक्तियों, संगठनों, स्थानों, तिथियों आदि के नामों जैसी इकाइयों को पहचान और वर्गीकृत कर सकता है।
डिपेंडेंसी पार्सिंग: यह वाक्य की व्याकरणिक संरचना का विश्लेषण कर सकता है और शब्दों के बीच संबंधों को निर्धारित कर सकता है।
लेम्माटाइज़ेशन: SpaCy शब्दों को उनके मूल या मूल रूप (लेम्मा) में परिवर्तित कर सकता है।
वर्ड वेक्टर्स: यह लाइब्रेरी वर्ड वेक्टर्स प्रदान करती है, जिन्हें वर्ड एम्बेडिंग्स के रूप में भी जाना जाता है। ये शब्दों के घने संख्यात्मक प्रतिनिधित्व होते हैं जो शब्दों के अर्थ को समझने में मदद करते हैं।

SpaCy कई भाषाओं का समर्थन करता है और विभिन्न भाषाओं के लिए पूर्व-प्रशिक्षित मॉडल के साथ आता है, जिससे यह विभिन्न NLP एप्लिकेशन्स में व्यापक रूप से उपयोग किया जाता है, जैसे कि सूचना निष्कर्षण, भावना विश्लेषण, चैटबॉट्स, भाषा अनुवाद, और भी बहुत कुछ। इसके अलावा, यह डेवलपर्स को अपने विशिष्ट डेटासेट पर कस्टम मॉडल को प्रशिक्षित करने की अनुमति देता है, यदि आवश्यक हो।

ज़िवेई: SpaCy भाषा मॉडल क्या है?

ChatGPT: SpaCy एक ओपन-सोर्स प्राकृतिक भाषा प्रसंस्करण (NLP) लाइब्रेरी है जिसे Explosion AI द्वारा विकसित किया गया है। यह कुशल, तेज़ और उपयोग में आसान होने के लिए डिज़ाइन की गई है, जिसके कारण यह विभिन्न NLP कार्यों के लिए एक लोकप्रिय विकल्प बन गई है। SpaCy कई भाषाओं के लिए पूर्व-प्रशिक्षित भाषा मॉडल प्रदान करती है, जिससे उपयोगकर्ता टोकनाइज़ेशन, पार्ट-ऑफ-स्पीच टैगिंग, नामित इकाई पहचान, डिपेंडेंसी पार्सिंग जैसे कार्य कर सकते हैं।

SpaCy की गति और दक्षता का मूल इसके अनुकूलित Cython कार्यान्वयन और डेटा संरचनाओं में निहित है, जो इसे विशेष रूप से उत्पादन वातावरण और वास्तविक दुनिया के अनुप्रयोगों के लिए उपयुक्त बनाता है। यह लाइब्रेरी Python में लिखी गई है और इसमें विभिन्न भाषाओं के लिए पूर्व-प्रशिक्षित मॉडल शामिल हैं, जिनमें अंग्रेजी, जर्मन, फ्रेंच, स्पेनिश और अन्य शामिल हैं।

SpaCy भाषा मॉडल प्राकृतिक भाषा डेटा में अंतर्निहित पैटर्न को सीखने के लिए डीप लर्निंग तकनीकों का उपयोग करते हैं। ये मॉडल बड़े पाठ संग्रह (corpora) पर प्रशिक्षित होते हैं, और सीखे गए प्रतिनिधित्व (representations) का उपयोग विभिन्न NLP कार्यों के लिए किया जा सकता है। पूर्व-प्रशिक्षित मॉडल को विशिष्ट डेटा पर और अधिक फाइन-ट्यून किया जा सकता है ताकि डोमेन-विशिष्ट कार्यों पर बेहतर प्रदर्शन प्राप्त किया जा सके।

SpaCy की वास्तुकला और उपयोग में आसानी ने इसे NLP समुदाय में डेवलपर्स और शोधकर्ताओं के बीच एक लोकप्रिय विकल्प बना दिया है। यह अक्सर सूचना निष्कर्षण, पाठ वर्गीकरण, नामित इकाई पहचान, शब्द-भाग टैगिंग और वाक्यात्मक पार्सिंग जैसे कार्यों के लिए उपयोग किया जाता है। इसके अलावा, SpaCy का मॉड्यूलर डिज़ाइन उपयोगकर्ताओं को इसे अपने मौजूदा NLP वर्कफ़्लो और पाइपलाइन में आसानी से एकीकृत करने की अनुमति देता है।

Zhiwei: क्या आप समझा सकते हैं?

class Llama:
    @staticmethod
    def build(
        ckpt_dir: str,
        tokenizer_path: str,
        max_seq_len: int,
        max_batch_size: int,
        model_parallel_size: Optional[int] = None,
    ) -> "Llama":
        if not torch.distributed.is_initialized():
            torch.distributed.init_process_group("nccl")
        if not model_parallel_is_initialized():
            if model_parallel_size is None:
                model_parallel_size = int(os.environ.get("WORLD_SIZE", 1))
            initialize_model_parallel(model_parallel_size)

(यह कोड ब्लॉक को हिंदी में अनुवाद करने की आवश्यकता नहीं है क्योंकि यह प्रोग्रामिंग कोड है और इसे मूल रूप में ही रखना चाहिए।)

local_rank = int(os.environ.get("LOCAL_RANK", 0))
torch.cuda.set_device(local_rank)

# सभी प्रक्रियाओं में seed समान होना चाहिए
torch.manual_seed(1)

if local_rank > 0:
    sys.stdout = open(os.devnull, "w")

        start_time = time.time()
        checkpoints = sorted(Path(ckpt_dir).glob("*.pth"))
        assert len(checkpoints) > 0, f"no checkpoint files found in {ckpt_dir}"
        assert model_parallel_size == len(
            checkpoints
        ), f"Loading a checkpoint for MP={len(checkpoints)} but world size is {model_parallel_size}"
        ckpt_path = checkpoints[get_model_parallel_rank()]
        checkpoint = torch.load(ckpt_path, map_location="cpu")
        with open(Path(ckpt_dir) / "params.json", "r") as f:
            params = json.loads(f.read())

कमांड चलाएं और फिर एरर लॉग प्राप्त करें।

% torchrun --nproc_per_node 1 example_text_completion.py \
    --ckpt_dir llama-2-7b/ \
    --tokenizer_path tokenizer.model \
    --max_seq_len 128 --max_batch_size 4
नोट: Windows या MacOS में रीडायरेक्ट्स वर्तमान में समर्थित नहीं हैं।
Traceback (सबसे हालिया कॉल अंतिम):
  फ़ाइल "/Users/lzwjava/projects/llama/example_text_completion.py", लाइन 55, <module> में
    fire.Fire(main)
  फ़ाइल "/Users/lzwjava/anaconda3/lib/python3.10/site-packages/fire/core.py", लाइन 141, Fire में
    component_trace = _Fire(component, args, parsed_flag_args, context, name)
  फ़ाइल "/Users/lzwjava/anaconda3/lib/python3.10/site-packages/fire/core.py", लाइन 475, _Fire में
    component, remaining_args = _CallAndUpdateTrace(
  फ़ाइल "/Users/lzwjava/anaconda3/lib/python3.10/site-packages/fire/core.py", लाइन 691, _CallAndUpdateTrace में
    component = fn(*varargs, **kwargs)
  फ़ाइल "/Users/lzwjava/projects/llama/example_text_completion.py", लाइन 18, main में
    generator = Llama.build(
  फ़ाइल "/Users/lzwjava/projects/llama/llama/generation.py", लाइन 62, build में
    torch.distributed.init_process_group("nccl")
  फ़ाइल "/Users/lzwjava/anaconda3/lib/python3.10/site-packages/torch/distributed/distributed_c10d.py", लाइन 907, init_process_group में
    default_pg = _new_process_group_helper(
  फ़ाइल "/Users/lzwjava/anaconda3/lib/python3.10/site-packages/torch/distributed/distributed_c10d.py", लाइन 1013, _new_process_group_helper में
    raise RuntimeError("Distributed package doesn't have NCCL " "built in")
RuntimeError: Distributed package में NCCL बिल्ट-इन नहीं है
ERROR:torch.distributed.elastic.multiprocessing.api:विफल (exitcode: 1) local_rank: 0 (pid: 23273) बाइनरी का: /Users/lzwjava/anaconda3/bin/python

Traceback (सबसे हालिया अंतिम): फ़ाइल “/Users/lzwjava/anaconda3/bin/torchrun”, लाइन 33, में sys.exit(load_entry_point('torch==2.0.1', 'console_scripts', 'torchrun')()) फ़ाइल "/Users/lzwjava/anaconda3/lib/python3.10/site-packages/torch/distributed/elastic/multiprocessing/errors/__init__.py", लाइन 346, wrapper में return f(*args, **kwargs) फ़ाइल "/Users/lzwjava/anaconda3/lib/python3.10/site-packages/torch/distributed/run.py", लाइन 794, main में run(args) फ़ाइल "/Users/lzwjava/anaconda3/lib/python3.10/site-packages/torch/distributed/run.py", लाइन 785, run में elastic_launch( फ़ाइल "/Users/lzwjava/anaconda3/lib/python3.10/site-packages/torch/distributed/launcher/api.py", लाइन 134, __call__ में return launch_agent(self._config, self._entrypoint, list(args)) फ़ाइल "/Users/lzwjava/anaconda3/lib/python3.10/site-packages/torch/distributed/launcher/api.py", लाइन 250, launch_agent में raise ChildFailedError( torch.distributed.elastic.multiprocessing.errors.ChildFailedError: ============================================================ example_text_completion.py FAILED ------------------------------------------------------------ Failures:

------------------------------------------------------------ Root Cause (पहली बार देखी गई विफलता): [0]: time : 2023-08-03_15:35:37 host : 1.0.0.127.in-addr.arpa rank : 0 (local_rank: 0) exitcode : 1 (pid: 23273) error_file: <N/A> traceback : ट्रेसबैक देखने के लिए यहां देखें: https://pytorch.org/docs/stable/elastic/errors.html ============================================================ ``` त्रुटि स्टैक ट्रेस सीखें। Pytorch में Backend.NCCL का क्या मतलब है, इसके बारे में ChatGPT से पूछें? --- ज़िवेई: कोड: ```python import torch from transformers import LlamaTokenizer, LlamaForCausalLM ``` ```python model_path = '.' # model_path = 'openlm-research/open_llama_7b' ``` ```python tokenizer = LlamaTokenizer.from_pretrained(model_path) model = LlamaForCausalLM.from_pretrained( model_path, torch_dtype=torch.float16, device_map='auto', ) ``` prompt = 'Q: सबसे बड़ा जानवर कौन सा है?\nA:' input_ids = tokenizer(prompt, return_tensors="pt").input_ids generation_output = model.generate( input_ids=input_ids, max_new_tokens=32 ) print(tokenizer.decode(generation_output[0])) ``` त्रुटि: ```shell /home/lzw/anaconda3/envs/llama/lib/python3.11/site-packages/transformers/generation/utils.py:1445: UserWarning: आप `.generate()` को `input_ids` के साथ कॉल कर रहे हैं जो आपके मॉडल के डिवाइस से अलग डिवाइस पर है। `input_ids` cpu पर है, जबकि मॉडल cuda पर है। आपको अप्रत्याशित व्यवहार या धीमी जनरेशन का अनुभव हो सकता है। कृपया सुनिश्चित करें कि आपने `.generate()` को चलाने से पहले `input_ids` को सही डिवाइस पर रखा है, उदाहरण के लिए `input_ids = input_ids.to('cuda')` को कॉल करके। warnings.warn( Traceback (most recent call last): File "/home/lzw/Projects/open_llama_3b/run.py", line 17, in generation_output = model.generate( ^^^^^^^^^^^^^^^ File "/home/lzw/anaconda3/envs/llama/lib/python3.11/site-packages/torch/utils/_contextlib.py", line 115, in decorate_context return func(*args, **kwargs) ^^^^^^^^^^^^^^^^^^^^^ File "/home/lzw/anaconda3/envs/llama/lib/python3.11/site-packages/transformers/generation/utils.py", line 1515, in generate return self.greedy_search( ^^^^^^^^^^^^^^^^^^^ File "/home/lzw/anaconda3/envs/llama/lib/python3.11/site-packages/transformers/generation/utils.py", line 2332, in greedy_search outputs = self( ^^^^^ File "/home/lzw/anaconda3/envs/llama/lib/python3.11/site-packages/torch/nn/modules/module.py", line 1501, in _call_impl return forward_call(*args, **kwargs) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/home/lzw/anaconda3/envs/llama/lib/python3.11/site-packages/transformers/models/llama/modeling_llama.py", line 688, in forward outputs = self.model( ^^^^^^^^^^^ File "/home/lzw/anaconda3/envs/llama/lib/python3.11/site-packages/torch/nn/modules/module.py", line 1501, in _call_impl return forward_call(*args, **kwargs) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/home/lzw/anaconda3/envs/llama/lib/python3.11/site-packages/transformers/models/llama/modeling_llama.py", line 531, in forward inputs_embeds = self.embed_tokens(input_ids) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/home/lzw/anaconda3/envs/llama/lib/python3.11/site-packages/torch/nn/modules/module.py", line 1501, in _call_impl return forward_call(*args, **kwargs) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/home/lzw/anaconda3/envs/llama/lib/python3.11/site-packages/torch/nn/modules/sparse.py", line 162, in forward return F.embedding( ^^^^^^^^^^^^ File "/home/lzw/anaconda3/envs/llama/lib/python3.11/site-packages/torch/nn/functional.py", line 2210, in embedding return torch.embedding(weight, input, padding_idx, scale_grad_by_freq, sparse) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ RuntimeError: सभी टेंसर्स को एक ही डिवाइस पर होने की उम्मीद थी, लेकिन कम से कम दो डिवाइस मिले, cuda:0 और cpu! (जब तर्क के लिए तर्क इंडेक्स की जांच की जा रही थी method wrapper_CUDA__index_select में) ``` कैसे ठीक करें? चैटजीपीटी (ChatGPT) आपके सामने आने वाला त्रुटि संदेश यह दर्शाता है कि आपके इनपुट टेंसर (`input_ids`) और आपके मॉडल (`LlamaForCausalLM`) के बीच डिवाइस प्रकार में असंगति है। इनपुट टेंसर CPU (`cpu`) पर है, जबकि मॉडल GPU (`cuda`) पर है। इसे ठीक करने के लिए, आपको यह सुनिश्चित करना होगा कि मॉडल का उपयोग करके टेक्स्ट जनरेट करने से पहले इनपुट टेंसर उसी डिवाइस पर हो जहां मॉडल है। यहां समस्या को ठीक करने के लिए संशोधित कोड दिया गया है: ```python import torch from transformers import LlamaTokenizer, LlamaForCausalLM ``` ```python model_path = '.' # model_path = 'openlm-research/open_llama_7b' ``` ```python tokenizer = LlamaTokenizer.from_pretrained(model_path) model = LlamaForCausalLM.from_pretrained( model_path, torch_dtype=torch.float16, device_map='auto', ) ``` prompt = 'Q: सबसे बड़ा जानवर कौन सा है?\nA:' input_ids = tokenizer(prompt, return_tensors="pt").input_ids # input_ids टेंसर को मॉडल के समान डिवाइस पर ले जाएं input_ids = input_ids.to(model.device) ```python generation_output = model.generate( input_ids=input_ids, max_new_tokens=32 ) print(tokenizer.decode(generation_output[0])) ``` यह कोड एक मॉडल का उपयोग करके टेक्स्ट जनरेशन करता है। `model.generate` फ़ंक्शन `input_ids` और `max_new_tokens` पैरामीटर लेता है, जहां `input_ids` इनपुट टोकन्स को दर्शाता है और `max_new_tokens` यह निर्धारित करता है कि कितने नए टोकन जनरेट किए जाएंगे। फिर `tokenizer.decode` फ़ंक्शन का उपयोग करके जनरेट किए गए टोकन्स को वापस टेक्स्ट में डिकोड किया जाता है और प्रिंट किया जाता है। इस कोड में, मैंने टोकनाइज़र से `input_ids` टेंसर प्राप्त करने के बाद `input_ids = input_ids.to(model.device)` लाइन जोड़ी है। यह लाइन `input_ids` टेंसर को मॉडल के समान डिवाइस (या तो CPU या GPU) पर ले जाती है, टेक्स्ट जनरेट करने से पहले। इससे "Expected all tensors to be on the same device" त्रुटि को हल करना चाहिए। याद रखें कि यदि आप इस कोड को GPU-सक्षम मशीन पर चला रहे हैं और आपका मॉडल GPU पर है, तो आमतौर पर मॉडल और इनपुट डेटा दोनों को GPU पर रखना अधिक कुशल होता है ताकि समानांतर प्रसंस्करण क्षमताओं का लाभ उठाया जा सके। --- ज़िवेई: क्या आप नीचे दिए गए कोड्स को समझा सकते हैं? ```python def generate( self, prompt_tokens: List[List[int]], max_gen_len: int, temperature: float = 0.6, top_p: float = 0.9, logprobs: bool = False, echo: bool = False, ) -> Tuple[List[List[int]], Optional[List[List[float]]]]: params = self.model.params bsz = len(prompt_tokens) assert bsz <= params.max_batch_size, (bsz, params.max_batch_size) ``` ```python min_prompt_len = min(len(t) for t in prompt_tokens) max_prompt_len = max(len(t) for t in prompt_tokens) assert max_prompt_len <= params.max_seq_len total_len = min(params.max_seq_len, max_gen_len + max_prompt_len) ``` इस कोड में: - `min_prompt_len` प्रॉम्प्ट टोकन्स की सबसे छोटी लंबाई को दर्शाता है। - `max_prompt_len` प्रॉम्प्ट टोकन्स की सबसे बड़ी लंबाई को दर्शाता है। - `assert max_prompt_len <= params.max_seq_len` यह सुनिश्चित करता है कि प्रॉम्प्ट की अधिकतम लंबाई `params.max_seq_len` से अधिक न हो। - `total_len` यह निर्धारित करता है कि कुल अनुक्रम की लंबाई `params.max_seq_len` और `max_gen_len + max_prompt_len` में से जो भी छोटा हो, वह होगी। ```python pad_id = self.tokenizer.pad_id tokens = torch.full((bsz, total_len), pad_id, dtype=torch.long, device="cuda") for k, t in enumerate(prompt_tokens): tokens[k, : len(t)] = torch.tensor(t, dtype=torch.long, device="cuda") if logprobs: token_logprobs = torch.zeros_like(tokens, dtype=torch.float) ``` ```python prev_pos = 0 eos_reached = torch.tensor([False] * bsz, device="cuda") input_text_mask = tokens != pad_id for cur_pos in range(min_prompt_len, total_len): logits = self.model.forward(tokens[:, prev_pos:cur_pos], prev_pos) if logprobs: token_logprobs[:, prev_pos + 1 : cur_pos + 1] = -F.cross_entropy( input=logits.transpose(1, 2), target=tokens[:, prev_pos + 1 : cur_pos + 1], reduction="none", ignore_index=pad_id, ) if temperature > 0: probs = torch.softmax(logits[:, -1] / temperature, dim=-1) next_token = sample_top_p(probs, top_p) else: next_token = torch.argmax(logits[:, -1], dim=-1) ``` ```python next_token = next_token.reshape(-1) # केवल टोकन को बदलें यदि प्रॉम्प्ट पहले ही जनरेट हो चुका है next_token = torch.where( input_text_mask[:, cur_pos], tokens[:, cur_pos], next_token ) tokens[:, cur_pos] = next_token eos_reached |= (~input_text_mask[:, cur_pos]) & ( next_token == self.tokenizer.eos_id ) prev_pos = cur_pos if all(eos_reached): break ``` ```python if logprobs: token_logprobs = token_logprobs.tolist() out_tokens, out_logprobs = [], [] for i, toks in enumerate(tokens.tolist()): # max gen len तक काटें start = 0 if echo else len(prompt_tokens[i]) toks = toks[start : len(prompt_tokens[i]) + max_gen_len] probs = None if logprobs: probs = token_logprobs[i][start : len(prompt_tokens[i]) + max_gen_len] # eos tok तक काटें, यदि कोई हो if self.tokenizer.eos_id in toks: eos_idx = toks.index(self.tokenizer.eos_id) toks = toks[:eos_idx] probs = probs[:eos_idx] if logprobs else None out_tokens.append(toks) out_logprobs.append(probs) return (out_tokens, out_logprobs if logprobs else None) ``` ChatGPT: ज़रूर! प्रदान किया गया कोड एक `generate` नामक मेथड है जो एक प्रॉम्प्ट (इनपुट टेक्स्ट) लेता है और एक लैंग्वेज मॉडल का उपयोग करके टेक्स्ट जनरेट करता है। यह मेथड एक विशिष्ट मॉडल और टोकनाइज़र के साथ काम करने के लिए डिज़ाइन की गई है और यह टेक्स्ट जनरेशन को या तो ग्रीडी सैंपलिंग या टॉप-पी सैंपलिंग का उपयोग करके करती है। यहां बताया गया है कि यह मेथड कैसे काम करती है: 1. **मेथड पैरामीटर्स:** - `prompt_tokens`: टोकनाइज़्ड प्रॉम्प्ट्स की एक सूची, जहां प्रत्येक प्रॉम्प्ट को पूर्णांकों (टोकन आईडी) की सूची के रूप में दर्शाया गया है। - `max_gen_len`: जनरेट किए गए आउटपुट की अधिकतम लंबाई (टोकन में)। - `temperature`: जनरेशन की यादृच्छिकता को नियंत्रित करने वाला एक पैरामीटर। उच्च मान (जैसे 1.0) आउटपुट को अधिक यादृच्छिक बनाते हैं, जबकि निम्न मान (जैसे 0.6) इसे अधिक निर्धारित बनाते हैं। - `top_p`: जनरेट किए गए टेक्स्ट की विविधता को नियंत्रित करने वाला एक पैरामीटर। उच्च मान (जैसे 0.9) अधिक विविध सैंपलिंग की अनुमति देते हैं। - `logprobs`: यदि `True` है, तो मेथड जनरेट किए गए टोकन्स के लॉग-प्रोबेबिलिटीज़ भी लौटाता है। - `echo`: यदि `True` है, तो जनरेट किया गया आउटपुट प्रॉम्प्ट को भी शामिल करेगा। 2. **आरंभीकरण (Initialization):** यह विधि `params`, `bsz` (बैच आकार), `min_prompt_len`, और `max_prompt_len` जैसे चरों को आरंभ करती है। यह `total_len` की भी गणना करती है, जो प्रॉम्प्ट सहित उत्पन्न आउटपुट की कुल लंबाई है। 3. **टोकन जनरेशन:** यह विधि आउटपुट टेक्स्ट के लिए टोकन उत्पन्न करती है। यह जनरेटेड अनुक्रम में स्थितियों पर लूप का उपयोग करके पुनरावृत्ति करती है, जो प्रॉम्प्ट के अंत से शुरू होकर आगे बढ़ती है। - प्रत्येक स्थिति के लिए लॉगिट्स को आंशिक अनुक्रम को मॉडल के फॉरवर्ड फ़ंक्शन में पास करके प्राप्त किया जाता है। - यदि `temperature` 0 से अधिक है, तो लॉगिट्स को दिए गए तापमान मान के साथ सॉफ्टमैक्स का उपयोग करके प्रायिकताओं में बदल दिया जाता है। यदि `temperature` 0 है, तो सबसे उच्च लॉगिट वाले टोकन को `torch.argmax` का उपयोग करके चुना जाता है। - अगला टोकन जनरेटेड प्रायिकताओं या argmax के आधार पर निर्धारित किया जाता है, और इसे `tokens` टेंसर के संबंधित स्थिति में रखा जाता है। - EOS (अनुक्रम-समाप्ति) टोकन का पता लगाया जाता है, और यदि सभी अनुक्रम EOS टोकन तक पहुंच गए हैं, तो जनरेशन प्रक्रिया को रोक दिया जाता है। - जनरेटेड टोकन को `tokens` टेंसर में रखा जाता है। 4. **जनरेटेड आउटपुट का प्रसंस्करण:** - जनरेट किए गए टोकन को वांछित अधिकतम लंबाई (`max_gen_len`) तक ट्रिम करने के लिए प्रसंस्कृत किया जाता है। - यदि `echo` `True` है, तो प्रॉम्प्ट को जनरेटेड आउटपुट में शामिल किया जाता है। - यदि `eos` टोकन मिलता है, तो जनरेटेड टेक्स्ट को उस बिंदु पर काट दिया जाता है। 5. **वापसी:** यह मेथड उत्पन्न टोकन और, यदि `logprobs` `True` है, तो उत्पन्न टोकन के लॉग-प्रायिकताओं को शामिल करने वाला एक टपल लौटाता है। यह विधि पाठ उत्पन्न करने के लिए प्रॉम्प्ट और पहले से उत्पन्न टोकन द्वारा प्रदान किए गए संदर्भ के आधार पर टोकन का पुनरावृत्ति से अनुमान लगाती है। यह उत्पन्न पाठ की यादृच्छिकता और विविधता को नियंत्रित करने के लिए निर्दिष्ट जनरेशन पैरामीटर्स का उपयोग करती है। यह विधि एक विशिष्ट मॉडल आर्किटेक्चर और टोकनाइज़र के साथ उपयोग करने के लिए डिज़ाइन की गई है, क्योंकि यह पाठ उत्पन्न करने के लिए उनके गुणों और विधियों पर निर्भर करती है। ---

Back 2025.01.18 Donate