अपने डिवाइस पर Alpaca-LoRA कैसे चलाएँ

जैसे-जैसे जेनरेटिव AI गति पकड़ रहा है, दुनिया भर के डेवलपर नैचुरल लैंग्वेज का उपयोग करके रोचक एप्लिकेशन बनाने के अवसर का फायदा उठा रहे हैं। एक टूल जिसने हाल ही में काफी ध्यान आकर्षित किया है: ChatGPT।

ChatGPT, OpenAI द्वारा विकसित एक भाषा मॉडल है। इसका उद्देश्य एक AI-संचालित चैटबॉट के रूप में काम करना है जो इंसानों जैसी बातचीत कर सके। हालांकि यह एक अत्यंत उपयोगी टूल है, लेकिन इसकी कुछ सीमाएँ भी हैं। ChatGPT ओपन-सोर्स नहीं है, यानी इसका सोर्स कोड उपलब्ध नहीं है और इसमें बदलाव नहीं किया जा सकता। यह संसाधनों की दृष्टि से भी बेहद भारी है, जिससे अपनी स्वयं की इम्प्लीमेंटेशन बनाना एक बुरा विकल्प बन जाता है।

ऐसी समस्याओं ने ChatGPT के कई विकल्पों को जन्म दिया, जैसे Alpaca-LoRA, जो ChatGPT की तरह कार्य कर सकते हैं, लेकिन ओपन-सोर्स लाइसेंस और कम संसाधन आवश्यकताओं के साथ।

इस ट्यूटोरियल में, हम विशेष रूप से Alpaca-LoRA पर ध्यान केंद्रित करेंगे। हम यह कवर करेंगे कि यह क्या है, इसे अपने डिवाइस पर चलाने के लिए पूर्वापेक्षाएँ क्या हैं, और इसे निष्पादित करने के चरण क्या हैं।

Alpaca LoRA क्या है?

मार्च 2023 की शुरुआत में, Eric J. Wang ने Alpaca-LoRA प्रोजेक्ट जारी किया। यह एक प्रोजेक्ट है जिसमें Stanford Alpaca के परिणामों को Parameter-Efficient Fine-Tuning (PEFT) का उपयोग करके पुन: प्रस्तुत करने का कोड शामिल है; यह एक लाइब्रेरी है जो डेवलपर्स को LoRA का उपयोग करके ट्रांसफॉर्मर-आधारित मॉडलों को फाइन-ट्यून करने में सक्षम बनाती है।

LoRA को समझना

लो-रैंक एडेप्टेशन ऑफ लार्ज लैंग्वेज मॉडल्स (LoRA) एक ऐसी विधि है जो बड़े मॉडलों के प्रशिक्षण की प्रक्रिया को तेज करते हुए कम मेमोरी का उपभोग करती है।

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

• मौजूदा वेट्स को फ्रीज करना। मॉडल को आपस में जुड़े नोड्स के एक जाल के रूप में सोचें (ये ही "वेट्स" हैं)। सामान्य तौर पर, प्रशिक्षण के दौरान आप प्रदर्शन सुधारने के लिए इन सभी नोड्स को समायोजित करते हैं। LoRA कहता है, "इन्हें मत छुएँ; इन्हें जैसा है वैसा रहने दें।"
• नए वेट्स जोड़ना। LoRA तब इस जाल में कुछ नए, सरल कनेक्शन (नए वेट्स) जोड़ देता है।
• केवल नए वेट्स को ट्रेन करना। पूरे जटिल जाल को समायोजित करने के बजाय, आप केवल इन नए, सरल कनेक्शनों को बेहतर बनाने पर ध्यान केंद्रित करते हैं।

ऐसा करके, आप समय और कंप्यूटर मेमोरी दोनों बचाते हैं, जबकि आपका मॉडल अपने कार्यों में बेहतर होता जाता है।

LoRA के लाभ

LoRA के लाभों में शामिल हैं:

• पोर्टेबिलिटी - रैंक-डिकम्पोजीशन वेट मैट्रिसेज़ में मूल मॉडल की तुलना में बहुत कम ट्रेन करने योग्य पैरामीटर्स होते हैं; इसलिए, प्रशिक्षित LoRA वेट्स आसानी से पोर्टेबल होते हैं और Rasberry Pi पर भी चल सकते हैं।
• एक्सेसिबिलिटी – पारंपरिक फाइन-ट्यूनिंग की तुलना में, LoRA ने GPU मेमोरी उपयोग को काफी हद तक कम करने में प्रभाव दिखाया है; इससे Tesla T4, RTX 3080, या यहाँ तक कि RTX 2080 Ti जैसे कंज्यूमर GPUs पर भी फाइन-ट्यूनिंग करना संभव हो जाता है।

Alpaca: ओपन-सोर्स मॉडल

दूसरी ओर, Alpaca, Large Language Model Meta AI (LLaMA) पर आधारित एक ओपन-सोर्स, निर्देश-फाइन-ट्यून किया गया AI भाषा मॉडल है। इसे स्टैनफोर्ड यूनिवर्सिटी के शोधकर्ताओं की एक टीम ने विकसित किया ताकि लार्ज लैंग्वेज मॉडल्स (LLMs) अधिक सुलभ हो सकें।

और यहीं से Alpaca-LoRA की बात आती है।

Alpaca-LoRA मॉडल, Stanford Alpaca मॉडल का कम संसाधन-गहन संस्करण है, जो LoRA का उपयोग करके प्रशिक्षण प्रक्रिया को तेज करता है और कम मेमोरी का उपभोग करता है।

Alpaca-LoRA के पूर्वापेक्षाएँ

Alpaca-LoRA मॉडल को लोकली चलाने के लिए आपके पास GPU होना आवश्यक है। यह NVIDIA T4 जैसा लो-स्पेक GPU हो सकता है या 4090 जैसा कंज्यूमर GPU। प्रोजेक्ट के निर्माता Eric J. Wang के अनुसार, मॉडल “एकल RTX 4090 पर कुछ घंटों में चलता है।”

नोट: इस लेख में दिए गए निर्देश Eric J. Wang द्वारा Alpaca-LoRA रिपॉज़िटरी में उपलब्ध निर्देशों का अनुसरण करते हैं।

Alpaca-LoRA को 4 चरणों में कैसे चलाएँ

चरण 1: वर्चुअल एनवायरनमेंट बनाएँ (वैकल्पिक)

वर्चुअल एनवायरनमेंट अलग-थलग कंटेनर होते हैं जिनमें किसी विशेष प्रोजेक्ट के लिए आवश्यक Python-सम्बंधित निर्भरताएँ रखी जाती हैं। यह अलग-अलग प्रोजेक्ट्स की निर्भरताओं को अलग रखने में मदद करता है, जिससे प्रोजेक्ट साझा करना आसान होता है और डिपेंडेंसी कॉन्फ्लिक्ट कम होते हैं।

Alpaca-LoRA मॉडल चलाने के लिए वर्चुअल एनवायरनमेंट का उपयोग अनिवार्य नहीं है, लेकिन इसकी सिफारिश की जाती है।

Windows ऑपरेटिंग सिस्टम पर कमांड प्रॉम्प्ट का उपयोग करके वर्चुअल एनवायरनमेंट बनाने के लिए निम्न कमांड चलाएँ:

py -m venv venvसंचालित द्वारा

यह आपके वर्तमान कार्यशील डायरेक्टरी में venv नाम का एक वर्चुअल एनवायरनमेंट बना देगा।

नोट: आप दूसरे venv को अपनी पसंद के नाम से बदलकर अपने वर्चुअल एनवायरनमेंट का कोई भी नाम रख सकते हैं।

कोई भी डिपेंडेंसी इंस्टॉल करने से पहले आपको वर्चुअल एनवायरनमेंट को सक्रिय करना होगा। अपने वर्चुअल एनवायरनमेंट को सक्रिय करने के लिए निम्न कमांड चलाएँ:

venv\Scripts\activate.batसंचालित द्वारा

जब आप वर्चुअल एनवायरनमेंट का उपयोग नहीं कर रहे हों, तो इसे निष्क्रिय करने के लिए निम्न कमांड चलाएँ:

deactivateसंचालित द्वारा

अब आप Alpaca-LoRA चलाने पर काम शुरू करने के लिए तैयार हैं।

चरण 2: सेटअप

Alpaca-LoRA मॉडल चलाने का पहला चरण है GitHub से रिपॉज़िटरी को क्लोन करना और निष्पादन के लिए आवश्यक डिपेंडेंसीज़ इंस्टॉल करना।

GitHub रिपॉज़िटरी इंस्टॉल करने के लिए निम्न कमांड का उपयोग करें:

git clone https://github.com/tloen/alpaca-lora.gitसंचालित द्वारा

इसके बाद अभी-अभी इंस्टॉल की गई alpaca-lora रिपॉज़िटरी में जाएँ:

cd alpaca-loraसंचालित द्वारा

और डिपेंडेंसीज़ इंस्टॉल करने के लिए निम्न कमांड चलाएँ:

pip install -r requirements.txtसंचालित द्वारा

चरण 3: मॉडल का फाइन-ट्यूनिंग (वैकल्पिक)

alpaca-lora रिपॉज़िटरी में finetune.py नाम की फ़ाइल है। finetune.py में अन्य बातों के साथ LLaMA मॉडल पर लागू Parameter-Efficient Fine-Tuning (PEFT) का एक सरल अनुप्रयोग शामिल है।

यदि आप मॉडल के हाइपरपैरामीटर्स में बदलाव करना चाहते हैं, तो आपको इसी फ़ाइल को चलाना होगा, लेकिन यह अनिवार्य नहीं है। रिपॉज़िटरी के लेखक के अनुसार, “बिना हाइपरपैरामीटर ट्यूनिंग के, LoRA मॉडल, Stanford Alpaca मॉडल के तुलनीय आउटपुट देता है। आगे की ट्यूनिंग बेहतर प्रदर्शन हासिल कर सकती है [...].”

यहाँ finetune.py फ़ाइल का उपयोग करने का एक उदाहरण प्रस्तुत है:

python -m finetune.py \
    --base_model 'decapoda-research/llama-7b-hf' \
    --data_path 'yahma/alpaca-cleaned' \
    --output_dir './lora-alpaca' \
    --batch_size 128 \
    --micro_batch_size 4 \
    --num_epochs 3 \
    --learning_rate 1e-4 \
    --cutoff_len 512 \
    --val_set_size 2000 \
    --lora_r 8 \
    --lora_alpha 16 \
    --lora_dropout 0.05 \
    --lora_target_modules '[q_proj,v_proj]' \
    --train_on_inputs \
    --group_by_lengthसंचालित द्वारा

चरण 4: मॉडल चलाना / इन्फेरेंस

alpaca-lora रिपॉज़िटरी में generate.py नाम की एक फ़ाइल भी है। generate.py को चलाने पर निम्न कार्य होंगे:

• Hugging Face मॉडल हब से बेस मॉडल को पढ़ना
• tloen/alpaca-lora-7b से मॉडल वेट्स पढ़ना
• एक Gradio इंटरफ़ेस शुरू करना जहाँ दिए गए इनपुट पर इन्फेरेंस किया जाता है।

लिखे जाने के समय, मॉडल को ट्रेन करने के लिए उपयोग किया गया सबसे हालिया Alpaca-LoRA एडेप्टर alpaca-lora-7b है। यह 26 मार्च, 2023 को निम्न कमांड का उपयोग करके किया गया था:

python finetune.py \
    --base_model='decapoda-research/llama-7b-hf' \
    --num_epochs=10 \
    --cutoff_len=512 \
    --group_by_length \
    --output_dir='./lora-alpaca' \
    --lora_target_modules='[q_proj,k_proj,v_proj,o_proj]' \
    --lora_r=16 \
    --micro_batch_size=8संचालित द्वारा

यदि आप कोई अलग एडेप्टर उपयोग करना चाहें, तो आप generate.py फ़ाइल को अपने पसंदीदा एडेप्टर के गंतव्य लिंक के साथ चलाकर ऐसा कर सकते हैं।

python generate.py \
    --load_8bit \
    --base_model 'decapoda-research/llama-7b-hf' \
    --lora_weights 'tloen/alpaca-lora-7b'संचालित द्वारा

समापन

Alpaca-LoRA, Stanford Alpaca मॉडल का कम संसाधन-गहन संस्करण है। यह बड़े भाषा मॉडलों के लो-रैंक एडेप्टेशन (LoRA) का लाभ उठाकर इस लक्ष्य को प्राप्त करता है, जो प्रशिक्षण प्रक्रिया को तेज करता है और मूल Alpaca मॉडल की तुलना में कहीं कम मेमोरी का उपयोग करता है।

निम्न ट्यूटोरियल्स के साथ लार्ज लैंग्वेज मॉडल्स (LLMs) और जेनरेटिव AI के बारे में और जानें:

• Meta AI LLaMA का परिचय
• PyTorch के साथ एक LLM कैसे ट्रेन करें: चरण-दर-चरण मार्गदर्शिका