PyTorch के साथ एक LLM को कैसे प्रशिक्षित करें

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

LangChain जैसी लाइब्रेरी उपरोक्त जैसे एंड-टू-एंड AI अनुप्रयोगों को लागू करने में सहूलियत देती हैं। हमारी ट्यूटोरियल Introduction to LangChain for Data Engineering & Data Applications LangChain से आप क्या कर सकते हैं, किन समस्याओं का समाधान यह करता है, और डेटा उपयोग के उदाहरणों सहित एक ओवरव्यू प्रदान करती है।

यह लेख वर्कस्पेस सेटअप से लेकर अंतिम इम्प्लीमेंटेशन तक बड़े भाषा मॉडल को प्रशिक्षित करने की संपूर्ण प्रक्रिया समझाएगा, जिसमें हम Pytorch 2.0.1 का उपयोग करेंगे—एक डायनेमिक और लचीला डीप लर्निंग फ्रेमवर्क जो मॉडल को सरल और स्पष्ट रूप से लागू करने की सुविधा देता है।

पूर्वापेक्षाएँ

इस सामग्री से अधिकतम लाभ उठाने के लिए, आपका Python प्रोग्रामिंग में सहज होना, डीप लर्निंग की बुनियादी अवधारणाओं और ट्रांसफॉर्मर्स की समझ होना, तथा Pytorch फ्रेमवर्क से परिचित होना आवश्यक है। पूरा सोर्स कोड GitHub पर उपलब्ध होगा।

मुख्य इम्प्लीमेंटेशन में जाने से पहले हमें संबंधित लाइब्रेरीज़ इंस्टॉल और इम्पोर्ट करनी होंगी। साथ ही, यह नोट करना महत्वपूर्ण है कि ट्रेनिंग स्क्रिप्ट Hugging Face की इस रिपॉजिटरी से प्रेरित है।

लाइब्रेरी इंस्टॉलेशन

इंस्टॉलेशन प्रक्रिया नीचे दी गई है:

सबसे पहले, हम Jupyter Notebook में %%bash स्टेटमेंट का उपयोग करते हैं ताकि सभी इंस्टॉल कमांड्स को एक ही सेल में bash कमांड के रूप में चलाया जा सके।

• Trl: रिइन्फोर्समेंट लर्निंग के साथ ट्रांसफॉर्मर भाषा मॉडलों को प्रशिक्षित करने के लिए।
• Peft: पैरामीटर-एफिशिएंट फाइन-ट्यूनिंग (PEFT) विधियों का उपयोग करके प्री-ट्रेन्ड मॉडल को कुशलतापूर्वक अनुकूल बनाने के लिए।
• Torch: व्यापक रूप से प्रयुक्त ओपन-सोर्स मशीन लर्निंग लाइब्रेरी।
• Datasets: सामान्य मशीन लर्निंग डेटासेट्स को डाउनलोड और लोड करने में सहायक।

Transformers: Hugging Face द्वारा विकसित एक लाइब्रेरी जिसमें वर्गीकरण, संक्षेपण और अनुवाद जैसे विभिन्न पाठ-आधारित कार्यों के लिए हजारों प्री-ट्रेन्ड मॉडल उपलब्ध हैं।

%%bash
pip -q install trl
pip -q install peft
pip -q install torch
pip -q install datasets
pip -q install transformers
संचालित द्वारा

अब इन मॉड्यूल्स को निम्न प्रकार इम्पोर्ट किया जा सकता है:

import torch
from trl import SFTTrainer
from datasets import load_dataset
from peft import LoraConfig, get_peft_model, prepare_model_for_int8_training
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArgumentsसंचालित द्वारा

डेटा लोडिंग और तैयारी

alpaca डेटासेट, जो Hugging Face पर निःशुल्क उपलब्ध है, का उपयोग इस उदाहरण में किया जाएगा। इस डेटासेट में तीन मुख्य कॉलम हैं: instructions, input, और output। इन कॉलमों को मिलाकर एक अंतिम text कॉलम बनाया जाता है।

डेटासेट लोड करने का निर्देश नीचे दिया गया है, जिसमें इच्छित डेटासेट का नाम tatsu-lab/alpaca प्रदान किया गया है:

train_dataset = load_dataset("tatsu-lab/alpaca", split="train")
print(train_dataset)संचालित द्वारा

हम देखते हैं कि प्राप्त डेटा दो कुंजियों वाले एक डिक्शनरी में है:

• Features: डेटा के मुख्य कॉलम समाहित करता है
• Num_rows: डेटा में कुल पंक्तियों की संख्या दर्शाता है

train_dataset की संरचना

पहली पाँच पंक्तियाँ निम्न निर्देश से प्रदर्शित की जा सकती हैं। पहले, डिक्शनरी को pandas डेटाफ़्रेम में बदलें, फिर पंक्तियाँ दिखाएँ।

pandas_format = train_dataset.to_pandas()
display(pandas_format.head())संचालित द्वारा

train_dataset की पहली पाँच पंक्तियाँ

बेहतर विज़ुअलाइज़ेशन के लिए, चलिए पहले तीन पंक्तियों की जानकारी प्रिंट करते हैं, लेकिन उससे पहले, हमें textwrap लाइब्रेरी इंस्टॉल करनी होगी ताकि प्रति पंक्ति अधिकतम 50 शब्द निर्धारित किए जा सकें। पहला प्रिंट स्टेटमेंट प्रत्येक ब्लॉक को 15 डैश से अलग करता है।

import textwrap
संचालित द्वारा

for index in range(3):
   print("---"*15)
   print("Instruction:        
       {}".format(textwrap.fill(pandas_format.iloc[index]["instruction"],    
       width=50)))
   print("Output:  
       {}".format(textwrap.fill(pandas_format.iloc[index]["output"],  
       width=50)))
   print("Text: 
       {}".format(textwrap.fill(pandas_format.iloc[index]["text"],  
       width=50)))संचालित द्वारा

पहली तीन पंक्तियों का विवरण

मॉडल प्रशिक्षण

मॉडल को प्रशिक्षित करने से पहले, हमें कुछ पूर्वापेक्षाएँ सेट करनी होंगी:

• प्री-ट्रेन्ड मॉडल: हम Hugging Face पर उपलब्ध Salesforce/xgen-7b-8k-base प्री-ट्रेन्ड मॉडल का उपयोग करेंगे। Salesforce ने XGen-7B नामक 7B LLMs की इस श्रृंखला को स्टैंडर्ड डेंस अटेंशन के साथ 8K सीक्वेंस तक और 1.5T टोकन्स तक प्रशिक्षित किया है।
• Tokenizer: यह ट्रेनिंग डेटा पर टोकनाइज़ेशन कार्यों के लिए आवश्यक है। प्री-ट्रेन्ड मॉडल और टोकनाइज़र लोड करने का कोड निम्न है:

pretrained_model_name = "Salesforce/xgen-7b-8k-base"
model = AutoModelForCausalLM.from_pretrained(pretrained_model_name, torch_dtype=torch.bfloat16)
tokenizer = AutoTokenizer.from_pretrained(pretrained_model_name, trust_remote_code=True)संचालित द्वारा

ट्रेनिंग कॉन्फ़िगरेशन

ट्रेनिंग के लिए कुछ आर्ग्युमेंट्स और कॉन्फ़िगरेशन की आवश्यकता होती है, और दो महत्वपूर्ण कॉन्फ़िगरेशन ऑब्जेक्ट्स नीचे परिभाषित हैं—TrainingArguments का एक इंस्टेंस, LoraConfig मॉडल का एक इंस्टेंस, और अंत में SFTTrainer मॉडल।

TrainingArguments

यह मॉडल ट्रेनिंग के पैरामीटर्स को परिभाषित करने के लिए उपयोग किया जाता है।

इस विशेष परिदृश्य में, हम सबसे पहले output_dir एट्रिब्यूट का उपयोग करके वह स्थान निर्धारित करते हैं जहाँ प्रशिक्षित मॉडल संग्रहीत होगा, उसके बाद अतिरिक्त हाइपरपैरामीटर्स जैसे ऑप्टिमाइज़ेशन मेथड, learning rate, number of epochs, आदि परिभाषित करते हैं।

model_training_args = TrainingArguments(
       output_dir="xgen-7b-8k-base-fine-tuned",
       per_device_train_batch_size=4,
       optim="adamw_torch",
       logging_steps=80,
       learning_rate=2e-4,
       warmup_ratio=0.1,
       lr_scheduler_type="linear",
       num_train_epochs=1,
       save_strategy="epoch"
   )संचालित द्वारा

LoRAConfig

इस परिदृश्य के लिए मुख्य आर्ग्युमेंट्स में LoRA में लो-रैंक ट्रांसफॉर्मेशन मैट्रिक्स का रैंक शामिल है, जिसे 16 पर सेट किया गया है। फिर, LoRA में अतिरिक्त पैरामीटर्स के लिए स्केलिंग फैक्टर 32 पर सेट किया गया है।

इसके अतिरिक्त, ड्रॉपआउट अनुपात 0.05 है, यानी प्रशिक्षण के दौरान 5% इनपुट यूनिट्स को अनदेखा किया जाएगा। अंत में, चूँकि हम causal language modeling कर रहे हैं, इसलिए कार्य को CAUSAL_LM एट्रिब्यूट के साथ इनिशियलाइज़ किया जाता है।

SFTTrainer

इसका उद्देश्य ट्रेनिंग डेटा, टोकनाइज़र, और उपर्युक्त मॉडलों जैसी अतिरिक्त जानकारी का उपयोग करके मॉडल को प्रशिक्षित करना है।

चूँकि हम ट्रेनिंग डेटा के text फ़ील्ड का उपयोग कर रहे हैं, इसलिए किसी दिए गए सीक्वेंस में अधिकतम टोकन्स की संख्या निर्धारित करने में सहायता के लिए वितरण पर नज़र डालना महत्वपूर्ण है।

import matplotlib.pyplot as plt


pandas_format['text_length'] = pandas_format['text'].apply(len)


plt.figure(figsize=(10,6))
plt.hist(pandas_format['text_length'], bins=50, alpha=0.5, color='g')
plt.title('Distribution of Length of Text')
plt.xlabel('Length of Text')
plt.ylabel('Frequency')
plt.grid(True)
plt.show()संचालित द्वारा

text कॉलम की लंबाई का वितरण

उपरोक्त अवलोकन के आधार पर, हम देखते हैं कि अधिकांश पाठ की लंबाई 0 से 1000 के बीच है। साथ ही, नीचे हम देख सकते हैं कि केवल 4.5% टेक्स्ट डॉक्युमेंट्स की लंबाई 1024 से अधिक है।

mask = pandas_format['text_length'] > 1024
percentage = (mask.sum() / pandas_format['text_length'].count()) * 100


print(f"The percentage of text documents with a length greater than 1024 is: {percentage}%")
संचालित द्वारा

इसके बाद हम सीक्वेंस में अधिकतम टोकन्स की संख्या 1024 निर्धारित करते हैं ताकि इससे अधिक लंबा कोई भी पाठ ट्रंकेट हो जाए।

SFT_trainer = SFTTrainer(
       model=model,
       train_dataset=train_dataset,
       dataset_text_field="text",
       max_seq_length=1024,
       tokenizer=tokenizer,
       args=model_training_args,
       packing=True,
       peft_config=lora_peft_config,
   )संचालित द्वारा

ट्रेनिंग निष्पादन

सभी पूर्वापेक्षाएँ पूरी होने के साथ, अब हम मॉडल के ट्रेनिंग प्रोसेस को निम्न प्रकार चला सकते हैं:

tokenizer.pad_token = tokenizer.eos_token
model.resize_token_embeddings(len(tokenizer))
model = prepare_model_for_int8_training(model)
model = get_peft_model(model, lora_peft_config)
training_args = model_training_args
trainer = SFT_trainer
trainer.train()संचालित द्वारा

यह उल्लेख करना महत्वपूर्ण है कि यह ट्रेनिंग GPU वाले क्लाउड वातावरण में की जा रही है, जो समग्र ट्रेनिंग प्रक्रिया को तेज करती है। हालाँकि, स्थानीय कंप्यूटर पर ट्रेनिंग पूरी होने में अधिक समय लगेगा।

हमारा ब्लॉग Pros and Cons of Using LLMs in the Cloud Versus Running LLMs Locally LLMs के लिए सर्वोत्तम परिनियोजन रणनीति चुनने के लिए प्रमुख विचार प्रदान करता है।

आइए समझते हैं कि ऊपर दिए गए कोड स्निपेट में क्या हो रहा है:

• tokenizer.pad_token = tokenizer.eos_token: पैडिंग टोकन को एंड-ऑफ-सेंटेंस टोकन के समान सेट करता है।
• model.resize_token_embeddings(len(tokenizer)): टोकनाइज़र के शब्दावली आकार के अनुरूप मॉडल की टोकन एम्बेडिंग लेयर का आकार बदलता है।
• model = prepare_model_for_int8_training(model): मॉडल को INT8 प्रिसीजन के साथ ट्रेनिंग के लिए तैयार करता है, संभवतः क्वांटाइज़ेशन करते हुए।
• model = get_peft_model(model, lora_peft_config): दिए गए PEFT कॉन्फ़िगरेशन के अनुसार मॉडल को समायोजित करता है।
• training_args = model_training_args: पूर्वनिर्धारित ट्रेनिंग आर्ग्युमेंट्स को training_args में असाइन करता है।
• trainer = SFT_trainer: SFTTrainer इंस्टेंस को trainer वेरिएबल में असाइन करता है।
• trainer.train(): निर्दिष्ट विनिर्देशों के अनुसार मॉडल के ट्रेनिंग प्रोसेस को प्रारंभ करता है।

निष्कर्ष

इस लेख ने PyTorch का उपयोग करके एक बड़े भाषा मॉडल को प्रशिक्षित करने पर एक स्पष्ट मार्गदर्शिका प्रदान की। डेटासेट तैयारी से शुरू करते हुए, इसने पूर्वापेक्षाएँ तैयार करने, ट्रेनर सेटअप करने, और अंततः ट्रेनिंग प्रक्रिया चलाने के चरणों को कवर किया।

हालाँकि इसमें एक विशिष्ट डेटासेट और प्री-ट्रेन्ड मॉडल का उपयोग किया गया, लेकिन अन्य संगत विकल्पों के लिए प्रक्रिया काफी हद तक समान रहेगी। अब जबकि आप समझते हैं कि एक LLM को कैसे प्रशिक्षित किया जाता है, आप इस ज्ञान का उपयोग विभिन्न NLP कार्यों के लिए अन्य उन्नत मॉडलों को प्रशिक्षित करने में कर सकते हैं।

बड़े भाषा मॉडलों की शक्ति को और गहराई से समझने के लिए हमारा मार्गदर्शक LangChain के साथ LLM एप्लिकेशन कैसे बनाएं देखें। या, यदि आपको अभी भी बड़े भाषा मॉडल की अवधारणाओं का अन्वेषण करना है, तो अपनी सीख को आगे बढ़ाने के लिए हमारा कोर्स देखें।