Google के Gemma मॉडल को TPUs के साथ फाइन-ट्यून करें और बेहतर गति व प्रदर्शन के लिए इंफरेंस चलाएँ

यह लेख बड़े भाषा मॉडलों को उन्नत तकनीकों से फाइन-ट्यून करने पर एक विस्तृत ट्यूटोरियल है। हम Tensor Processing Units, LoRA नामक तकनीक, और वितरित कंप्यूटिंग के उदाहरणों से गुजरेंगे—सब कुछ अधिक गति और दक्षता के लिए। अपनी तकनीकों को दिखाने के लिए, हम Gemma मॉडलों तक पहुँचेंगे और उन्हें फाइन-ट्यून करेंगे—Google द्वारा बनाए गए नए, हल्के और अत्याधुनिक LLMs का परिवार।

ट्यूटोरियल के अंत तक, आपके पास Google Cloud पर उपलब्ध TPUs का उपयोग करके किसी भी बड़े भाषा मॉडल को फाइन-ट्यून करने और उस पर इंफरेंस चलाने की कौशल होगी। वहाँ तक पहुँचने के लिए, हम क्रम से निम्नलिखित विषय कवर करेंगे:

• कंप्यूट प्रकारों का परिचय: हम TPUs के बारे में जानेंगे और वे क्यों महत्वपूर्ण हैं। 

• TPUs के साथ Gemma का उपयोग: हम Kaggle वातावरण को TPUs के लिए सेटअप करना सीखेंगे।

• मॉडल सेटअप और इंफरेंस: हम Python में Keras लाइब्रेरी का उपयोग करके Gemma चलाएँगे।

• फाइन-ट्यूनिंग: हम LoRA नामक तकनीक से Gemma मॉडल को फाइन-ट्यून करेंगे। 

• वितरित प्रशिक्षण: हम प्रशिक्षण दक्षता के लिए वितरित फाइन-ट्यूनिंग करेंगे। 

यदि आप AI और LLMs में नए हैं, तो इस ट्यूटोरियल में उपयोग हुए शब्दों से परिचित होने के लिए व्यापक AI Fundamentals स्किल ट्रैक करने पर विचार करें। 

आइए शुरू करें!

Google का Gemma मॉडल क्या है?

Google Gemma लोगो

Google का Gemma मॉडल Google द्वारा 2024 में पेश किए गए, ओपन-सोर्स और हल्के बड़े भाषा मॉडलों के परिवार का हिस्सा है। Gemma को Google Gemini मॉडलों जैसी ही रिसर्च और टेक्नोलॉजी से बनाया गया है, और Gemini की तरह, Gemma भी Keras और Pytorch जैसे प्रमुख मशीन लर्निंग फ्रेमवर्क्स के साथ संगत है। यह दो आकारों में उपलब्ध है—2B या 7B पैरामीटर्स के साथ।

Gemini जहाँ मुख्य रूप से एंड-यूज़र्स के लिए ऐप्स और APIs के माध्यम से था, वहीं Gemma डेवलपर्स द्वारा व्यापक संशोधन और इंटिग्रेशन के लिए ओपन-सोर्स्ड है। Gemma मॉडल छोटे भी हैं, जिससे वे अधिक पोर्टेबल और किफायती बनते हैं। 

Tensor Processing Units क्या हैं?

CPUs, GPUs, TPUs की छवियाँ: Freepik और Flaticon

प्रसंग के लिए, मशीन लर्निंग के अलग-अलग हार्डवेयर विकल्पों की तुलना करते हैं। हार्डवेयर को विशिष्ट प्रकारों में वर्गीकृत किया जाता है, जिनमें से प्रत्येक प्रोसेसिंग और कंप्यूटेशन में विशिष्ट भूमिकाओं के लिए डिज़ाइन किया गया है। 

• सेंट्रल प्रोसेसिंग यूनिट्स: CPUs लगभग सभी कंप्यूटिंग डिवाइसों में ऑपरेटिंग सिस्टम चलाते हैं। ये क्रमिक रूप से कार्यों को प्रोसेस करने के लिए जाने जाते हैं।

• ग्राफिक्स प्रोसेसिंग यूनिट्स: GPUs एक साथ कई कार्यों को प्रोसेस करते हैं, जिससे वे ग्राफिक्स रेंडरिंग के लिए आदर्श बनते हैं।

• टेंसर प्रोसेसिंग यूनिट्स: TPUs Google द्वारा मशीन लर्निंग में उपयोग के लिए विकसित विशेष प्रोसेसर हैं। इन्हें उन मैट्रिक्स गणनाओं को तेजी से करने के लिए डिज़ाइन किया गया है जो न्यूरल नेटवर्क्स के प्रशिक्षण और चलाने में महत्वपूर्ण होती हैं।

अंतिम श्रेणी, TPUs, इस ट्यूटोरियल के लिए महत्वपूर्ण है। डीप न्यूरल नेटवर्क्स के प्रशिक्षण और इंफरेंस में TPUs, GPUs से तेज होते हैं; वे कम पावर भी उपयोग करते हैं। नकारात्मक पक्ष यह है कि TPU इकोसिस्टम कम परिपक्व है और टूल्स व फ्रेमवर्क्स कम उपलब्ध हैं। जो फ्रेमवर्क उपलब्ध हैं उनमें Google Cloud Platform, Colab, और Kaggle शामिल हैं।

मशीन लर्निंग हार्डवेयर तुलना तालिका

TPUs के साथ Google Gemma तक पहुँचना

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

Keras लाइब्रेरी यहाँ अच्छी तरह काम करती है क्योंकि यह Gemma मॉडलों के वितरित प्रशिक्षण का समर्थन करती है और TensorFlow और PyTorch सहित मल्टी-बैकएंड इम्प्लीमेंटेशन का लाभ लेती है।

इस खंड में, हम अपने Kaggle नोटबुक को TPUs के लिए कॉन्फ़िगर करेंगे, यह सुनिश्चित करते हुए कि सभी आवश्यक लाइब्रेरी और निर्भरताएँ स्थापना हो चुकी हों। इसके बाद, हम keras-nlp पैकेज का उपयोग करके Gemma 2B या 7B मॉडल में से किसी एक को लोड करेंगे। अंत में, हम मॉडल को कार्य करने के लिए डिप्लॉय करेंगे, ताकि TPU की शक्तिशाली कम्प्यूटिंग क्षमताओं का उपयोग करके प्रतिक्रियाओं को प्रभावी ढंग से प्रोसेस और जनरेट किया जा सके। 

सेटअप

पर्यावरण तैयार करने के लिए, हमें Gemma मॉडल का Keras संस्करण इंटीग्रेट करना होगा और बेहतर प्रदर्शन के लिए अपने कंप्यूटिंग एक्सेलेरेटर को TPU में स्विच करना होगा। हम keras-nlp जैसे आवश्यक पैकेज इंस्टॉल करेंगे, Keras को TensorFlow को बैकएंड के रूप में उपयोग करने के लिए कॉन्फ़िगर करेंगे, और TPU मेमोरी आवंटन को अनुकूलित करेंगे ताकि प्रशिक्षण और निष्पादन सुचारू रहे।

Gemma मॉडल में Keras इम्प्लीमेंटेशन जोड़ें

हमारे वातावरण को तैयार करने के लिए, हमें Gemma मॉडल में Keras इम्प्लीमेंटेशन जोड़ना होगा। इसका अर्थ है कि हम Gemma मॉडल के Keras-संगत संस्करण को शामिल करेंगे ताकि वह TensorFlow APIs के साथ सहजता से एकीकृत हो सके।

Keras इम्प्लीमेंटेशन जोड़ने के लिए, हम ये चरण अपनाते हैं:

• Kaggle में नया नोटबुक बनाएँ।

• दाएँ पैनल पर "Input" सेक्शन में जाएँ।

• + Add Input पर क्लिक करके Gemma मॉडल का Keras इम्प्लीमेंटेशन जोड़ें।

Gemma मॉडल में Keras इम्प्लीमेंटेशन जोड़ना

एक्सेलेरेटर को TPU में बदलें

अब, हमें एक्सेलेरेटर को TPU में बदलने की आवश्यकता होगी, यानी नोटबुक सेटिंग्स में कंप्यूटिंग एक्सेलेरेटर को TPU पर स्विच करेंगे ताकि प्रशिक्षण और इंफरेंस के लिए उसकी प्रोसेसिंग शक्ति का लाभ उठाया जा सके।

एक्सेलेरेटर बदलने के लिए, हम ये चरण अपनाते हैं। वातावरण के रीलोड होने में कुछ मिनट लगना सामान्य है।

• "Session options" सेक्शन में जाएँ।
• एक्सेलेरेटर को "None" से "TPU VM v3-8" में बदलें।

एक्सेलेरेटर के रूप में TPU सेट करना

फाइन-ट्यूनिंग और इंफरेंस के लिए आवश्यक Python पैकेज इंस्टॉल करें

अब हम अपडेटेड Python पैकेज इंस्टॉल करेंगे जिनका उपयोग हम फाइन-ट्यूनिंग और इंफरेंस के लिए करेंगे, जिनमें TensorFlow और keras-nlp शामिल हैं। 

!pip install -q tensorflow-cpu!pip install -q -U keras-nlp tensorflow-hub!pip install -q -U keras==3.1.1संचालित द्वारा

Keras बैकएंड सेट करें

हम TPUs तक निर्बाध पहुँच के लिए JAX के साथ Keras बैकएंड सेट करते हैं। आप TensorFlow या PyTorch भी आज़मा सकते हैं।  

TPU मेमोरी पहले से आवंटित करें

अंत में, हम मॉडल निष्पादन के दौरान प्रदर्शन को बेहतर बनाने और रनटाइम समस्याओं को रोकने के लिए TPU मेमोरी को पहले से आवंटित करते हैं। यहाँ हम JAX बैकएंड पर मेमोरी फ्रैगमेंटेशन से बचने के लिए कुल TPU मेमोरी का 100% प्री-अलोकेट करते हैं। 

import osos.environ["KERAS_BACKEND"] = "jax"os.environ["XLA_PYTHON_CLIENT_MEM_FRACTION"]="1.00"संचालित द्वारा

मॉडल लोड करना

हम मॉडल इंफरेंस के लिए आवश्यक Python पैकेज लोड करते हैं। 

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

इसके बाद हम अपना मॉडल लोड करते हैं और मॉडल का सारांश प्रदर्शित करते हैं। 

gemma_lm = keras_nlp.models.GemmaCausalLM.from_preset("gemma_instruct_2b_en")gemma_lm.summary()संचालित द्वारा

हमने एक ही कमांड से टोकनाइज़र और मॉडल सफलतापूर्वक लोड कर लिया। यह प्रभावशाली है क्योंकि सबसे छोटा Gemma मॉडल भी 2.5 बिलियन पैरामीटर्स और 9.34 GB का आकार रखता है। 

Gemma मॉडल सारांश

नोटबुक चलाने और सुपर-फास्ट प्रदर्शन का अनुभव करने के लिए आपको कुछ मिनट प्रतीक्षा करनी पड़ सकती है। इसका कारण है कि TPUs की माँग अधिक है। यदि आप रात में नोटबुक चलाते हैं, तो संभव है कि आपको इंतज़ार न करना पड़े। 

TPU एक्सेस के लिए कतार में लगना

मॉडल इंफरेंस

इंफरेंस चलाने का अर्थ है हमारे मॉडल का उपयोग करके नए, अनदेखे इनपुट्स के आधार पर आउटपुट जनरेट करना। हमारे संदर्भ में, हम .generate() फ़ंक्शन का उपयोग करके टेक्स्ट के रूप में ये इनपुट देंगे। हमें प्रतिक्रिया तुरंत मिल जाएगी। 

print(gemma_lm.generate("What is DataCamp?", max_length=30))संचालित द्वारा

What is DataCamp?DataCamp is a leading online data science education platform that empowers individuals and organizations to build data-driven careers. Theyसंचालित द्वारा

हम बैच इंफरेंस भी आज़मा सकते हैं, यानी हम कई प्रॉम्प्ट देंगे ताकि कई प्रतिक्रियाएँ उत्पन्न हों। आउटपुट सूची के रूप में आता है। 

print(gemma_lm.generate(["How far is the Sun from earth", "What is the Sun made of?"], max_length=30))संचालित द्वारा

['How far is the Sun from earth?\n\nThe Sun is about 149.6 million kilometers (93 million miles) away from', 'What is the Sun made of?\n\nThe Sun is primarily composed of hydrogen and helium. Hydrogen makes up about 73.4% of']संचालित द्वारा

अगले चरण में, हम अपने मॉडल को निर्देश और प्रतिक्रियाओं वाले टेम्पलेट से मार्गदर्शन देने की कोशिश करेंगे। आप सिस्टम प्रॉम्प्ट या कोई अतिरिक्त प्रारंभिक कमांड जोड़कर जनरेटेड प्रतिक्रिया को संशोधित कर सकते हैं। 

हम .format() फ़ंक्शन का उपयोग करके टेम्पलेट टेक्स्ट को उपयोगकर्ता तर्कों से भरेंगे। परिणामस्वरूप, हमारे पास Python सीखने के लिए कदमों की सूची होगी।

template = "Instruction:\n{instruction}\n\nResponse:\n{response}"prompt = template.format(    instruction="How do I start learning Python?",    response="",)print(gemma_lm.generate(prompt, max_length=250))संचालित द्वारा

Instruction:How do I start learning Python?Response:**Step 1: Choose a learning path*** **Online Courses:**    * DataCamp    * Codecademy    * Coursera    * edX    * Udemy* **Books:**    * "Automate the Boring Stuff with Python" by Al Sweigart    * "Python Crash Course" by Eric Matthes    * "Head First Python" by Kathy Sierra and Bert Bates* **Video Tutorials.........संचालित द्वारा

यदि आप TPUs का उपयोग करके मॉडल लोड करने और प्रतिक्रिया जनरेट करने में कठिनाई का सामना कर रहे हैं, तो इस Kaggle नोटबुक को देखें: Accessing Gemma-instruct-2b-en using TPUs।

यदि आप Gemma के उपयोग में सहज हो रहे हैं, तो हमारी Fine Tuning Google Gemma: Enhancing LLMs with Customized Instructions ट्यूटोरियल देखकर कस्टम निर्देशों से Gemma को बेहतर बनाने के बारे में और सीखें।

TPUs के साथ Gemma का फाइन-ट्यूनिंग

अब हम OpenHermes नामक सार्वजनिक डेटासेट का उपयोग करके Gemma मॉडल को फाइन-ट्यून करना सीखेंगे। OpenHermes डेटासेट में 2,42,000 पंक्तियाँ हैं, जिनमें दो कॉलम हैं—एक निर्देशों के लिए और एक प्रतिक्रियाओं के लिए—सभी GPT-4 मॉडल का उपयोग कर जनरेट की गई हैं।

जैसा कि हम देखेंगे, इस डेटासेट का फाइन-ट्यूनिंग TPUs का उपयोग करने पर भी काफ़ी समय लेगा। प्रक्रिया को तेज़ करने के लिए, हम LoRA नामक तकनीक को शामिल करेंगे।

LoRA, यानी Low-Rank Adaptation, बड़े भाषा मॉडलों के फाइन-ट्यूनिंग को अधिक कुशल और सुलभ बनाने के लिए डिज़ाइन की गई है। यह पारंपरिक फाइन-ट्यूनिंग तरीकों से जुड़ी चुनौतियों—जो प्रायः कम्प्यूटेशनल रूप से महँगी और संसाधन-गहन होती हैं—को संबोधित करती है।

तकनीकी स्तर पर, LoRA एक मॉडल के प्री-ट्रेंड वेट्स को फ्रीज़ करती है और मॉडल की आर्किटेक्चर के विशेष हिस्सों में परिवर्तन लाने के लिए लो-रैंक मैट्रिसेज़ प्रस्तुत करती है। इन लो-रैंक मैट्रिसेज़ पर ध्यान केंद्रित करके, LoRA आवश्यक कम्प्यूटेशनल संसाधनों को कम करती है, जिससे कम शक्तिशाली हार्डवेयर पर भी बड़े मॉडलों का फाइन-ट्यूनिंग संभव हो पाता है।

सेटअप

पहले किए गए मॉडल पर्यावरण सेटअप की तरह, हम Keras बैकएंड और मेमोरी प्री-अलोकेशन सेट करेंगे। हम jax. devices() फ़ंक्शन का उपयोग करके TPU डिवाइस की उपलब्धता भी जाँच सकते हैं। 

import osimport jaxos.environ["KERAS_BACKEND"] = "jax"os.environ["XLA_PYTHON_CLIENT_MEM_FRACTION"] = "0.9"jax.devices()संचालित द्वारा

कम्प्यूट डिवाइसों की संख्या

मॉडल और डेटासेट लोड करना

हम मॉडल लोड करते हैं और मॉडल सारांश दिखाते हैं। हमारे पास 2.5B ट्रेन योग्य पैरामीटर्स हैं।

import kerasimport keras_nlpgemma_lm = keras_nlp.models.GemmaCausalLM.from_preset("gemma_2b_en")gemma_lm.summary()संचालित द्वारा

Gemma मॉडल सारांश

अब हम डेटासेट को नोटबुक में लोड करते हैं। प्रक्रिया मॉडल जोड़ने जैसी ही है। हम ये चरण अपनाते हैं:

• "Add input" सेक्शन में जाएँ। 
• OpenHermes डेटासेट खोजें। 
• डेटासेट जोड़ें। स्पष्ट करने के लिए, हम वही चुन रहे हैं जो Volodymyr Pivoshenko द्वारा होस्ट किया गया है।

OpenHermes डेटासेट जोड़ना

अब हम pandas लाइब्रेरी का उपयोग करके डेटासेट पढ़ते हैं और शीर्ष 5 पंक्तियाँ दिखाते हैं। हम देखते हैं कि 2 कॉलम हैं—एक निर्देश के लिए और एक आउटपुट के लिए।

import pandas as pddf = pd.read_csv('/kaggle/input/openhermes/openhermes.csv')df.head()संचालित द्वारा

OpenHermes डेटासेट

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

पता चलता है कि पूरे डेटासेट को ट्रेन करने में, TPUs पर भी, लगभग 23 घंटे लगेंगे। इसलिए, हम प्रशिक्षण समय कम करने के लिए सूची के शीर्ष 1,000 नमूने ही चुनेंगे।

template = "Instruction:\n{instruction}\n\nResponse:\n{output}"data = [template.format(**row) for index, row in df.iterrows()]संचालित द्वारा

data = data[:1000]print(data[0])संचालित द्वारा

OpenHermes डेटासेट का पहला नमूना

फाइन-ट्यूनिंग से पहले इंफरेंस

पहले हम एक बेसलाइन बनाएँगे, जिसके मुकाबले हम LoRA के उपयोग की सफलता की तुलना कर सकें। इसके लिए, हम template.format() फ़ंक्शन का उपयोग करके प्रतिक्रिया जनरेट करेंगे।

ध्यान से पढ़ने पर, निम्नलिखित आउटपुट दिखाता है कि बेसलाइन प्रतिक्रिया बहुत विस्तृत नहीं है। पहली प्रतिक्रिया के अंत के बाद Gemma स्वयं को दोहराने भी लगता है। यह अच्छा परिणाम नहीं है, लेकिन यह हमारे मॉडल को बेहतर उत्तर देने के लिए फाइन-ट्यून करने की आवश्यकता का अच्छा उदाहरण देता है।

prompt = template.format(    instruction="Plan a 5-day Bahamas trip.",    output="",)print(gemma_lm.generate(prompt, max_length=256))संचालित द्वारा

Instruction:Plan a 5-day Bahamas trip.Response:Day 1:Fly to Nassau, Bahamas.Visit the Atlantis Resort.Day 2:Visit the Exuma Cays.Day 3:Visit the Lucayan National Park.Day 4:Visit the Great Abaco Islands.Day 5:Fly home.Instruction:Plan a 5-day Bahamas trip.Response:Day 1:Fly to Nassau, Bahamas.Visit the Atlantis Resort.Day 2:Visit the Exuma Cays.Day 3:Visit the Lucayan National Park.Day 4:Visit the Great Abaco Islands.Day 5:Fly home.Instruction:Plan a 5-day Bahamas trip.Response:Day 1:Fly to Nassau, Bahamas.Visit the Atlantis Resort.Day 2:Visit the Exuma Cays.Day 3:Visit the Lucayan National Park.Day 4:Visit the Great Abaco Islands.Day 5:Fly home.Instruction:Plan a 5-dayसंचालित द्वारा

फाइन-ट्यूनिंग के लिए मॉडल कम्पाइल करना

अब LoRA के साथ अपने मॉडल में सुधार करते हैं, जो डाउनस्ट्रीम टास्क के लिए ट्रेन योग्य पैरामीटर्स की संख्या घटाता है। 

हमारे उदाहरण में, हम LoRA रैंक 4 का उपयोग कर मॉडल को फाइन-ट्यून करेंगे, जो सबसे छोटा कम्प्यूटेशनली कुशल रैंक है। यदि आप प्रदर्शन सुधारना चाहते हैं, तो LoRA रैंक 8 या 16 विकल्प हैं। LoRA और क्वांटाइज़ेशन के बारे में अधिक जानने के लिए Fine-Tuning LLaMA 2 गाइड पढ़ें।

इसके बाद हम उपयोग होने वाले ऑप्टिमाइज़र, लॉस फ़ंक्शन और एक्यूरेसी मेट्रिक निर्दिष्ट करेंगे।

gemma_lm.backbone.enable_lora(rank=4)संचालित द्वारा

gemma_lm.preprocessor.sequence_length = 512optimizer = keras.optimizers.AdamW(    learning_rate=5e-5,    weight_decay=0.01,)optimizer.exclude_from_weight_decay(var_names=["bias", "scale"])gemma_lm.compile(    loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),    optimizer=optimizer,    weighted_metrics=[keras.metrics.SparseCategoricalAccuracy()],)gemma_lm.summary()संचालित द्वारा

हमारे ट्रेन योग्य पैरामीटर्स 2.5 बिलियन से घटकर 1.3 मिलियन रह गए हैं। और एडेप्टर लेयर का आकार मात्र 5.2 MB है। 

Gemma मॉडल: कुल बनाम ट्रेन योग्य पैरामीटर्स

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

अब हम अपने डेटा को मॉडल पर फिट करेंगे। यहाँ हम 1 epoch और बैच साइज़ 1 चुनते हैं। आप पूरे डेटासेट पर कम से कम 5 epochs तक ट्रेनिंग करके मॉडल का प्रदर्शन सुधार सकते हैं। 

gemma_lm.fit(data, epochs=1, batch_size=1)संचालित द्वारा

फाइन-ट्यूनिंग के बाद इंफरेंस

अब वही प्रॉम्प्ट आज़माते हैं जो हमने बेसलाइन प्रयोग में उपयोग किया था, ताकि देखें कि मॉडल में सुधार हुआ है या नहीं। इस बार, एक-पंक्ति उत्तरों और दोहराव के बजाय, हमारा मॉडल बहामास के लिए विस्तृत यात्रा योजना प्रदान करता है।

prompt = template.format(    instruction="Plan a 5-day Bahamas trip.",    output="",)print(gemma_lm.generate(prompt, max_length=256))संचालित द्वारा

Instruction:Plan a 5-day Bahamas trip.Response:Day 1: Arrive in Nassau, BahamasUpon arrival in Nassau, you will be greeted by a local guide who will take you on a tour of the city. Visit the famous Straw Market, where you can shop for souvenirs and local crafts. Enjoy lunch at a local restaurant before heading to the Atlantis Resort for a day of fun and relaxation. Spend the afternoon exploring the resort's world-class amenities, including the Aquaventure Water Park, Dolphin Cay, and the massive marine habitat, The Dig.Day 2: Explore Paradise IslandOn day 2, you will explore Paradise Island, home to the world-famous Atlantis Resort. Visit the famous Atlantis Casino and enjoy a round of blackjack or roulette. Take a stroll along the beach and enjoy the crystal-clear waters of the Atlantic Ocean. Visit the Dolphin Cay, where you can swim with dolphins and other marine animals.Day 3: Snorkel at Cabbage BeachOn day 3, you will head to Cabbage Beach, a secluded beach located on Paradise Island. Snorkel in the crystal-clear waters and explore the coral reefs. Enjoy a delicious lunch at a local restaurant before heading back to Nassau.संचालित द्वारा

आप मॉडल वेट्स को इंफरेंस के लिए सेव कर सकते हैं और मॉडल को प्रोडक्शन में डिप्लॉय कर सकते हैं। 

gemma_lm.save_weights('gemma_2b_openhermes.weights.h5')संचालित द्वारा

हमारे फाइन-ट्यून किए गए मॉडल का कुल आकार 10.04GB है। 

Gemma फाइन-ट्यून किया गया और सेव मॉडल फ़ाइल

यदि आपको अपने मॉडल को फाइन-ट्यून करने में कठिनाई हो रही है, तो संदर्भ के लिए यह Kaggle नोटबुक देखें: Finetuning Gemma using TPUs

TPUs के साथ Gemma का वितरित फाइन-ट्यूनिंग और इंफरेंस

अंतिम खंड के रूप में, हम वितरित फाइन-ट्यूनिंग पर गहराई से नज़र डालेंगे। वितरित फाइन-ट्यूनिंग, मॉडल पैरेललिज़्म के माध्यम से हासिल की जाती है, जो एक ही मॉडल के वेट्स को कई डिवाइसों में वितरित करता है, क्षैतिज स्केलिंग सक्षम करता है और प्रशिक्षण को तेज करता है।

इस भाग में, हम बड़े मॉडल पर प्रशिक्षण समय को काफ़ी घटाएँगे। विशेष रूप से, हम Keras को JAX बैकएंड के साथ उपयोग करके TPUs पर LoRA और वितरित प्रशिक्षण के साथ Gemma को फाइन-ट्यून करेंगे। 

सेटअप

यहाँ हम नया Kaggle नोटबुक शुरू करते हैं और आवश्यक लाइब्रेरी इंस्टॉल करते हैं। फिर हम Keras बैकएंड सेट करते हैं और मेमोरी प्री-अलोकेट करते हैं।

!pip install -q tensorflow-cpu!pip install -q -U keras-nlp tensorflow-hub!pip install -q -U keras==3.1.1संचालित द्वारा

import osos.environ["KERAS_BACKEND"] = "jax"os.environ["XLA_PYTHON_CLIENT_MEM_FRACTION"] = "0.9"संचालित द्वारा

8 TPU के लिए डिस्ट्रीब्यूशन सेट करना

हम पहले DeviceMesh बनाएँगे ताकि मॉडल वेट्स और टेन्सर्स को कई TPU डिवाइसों में वितरित रूप से लोड करने में सहायता मिले। यह डेटा और मॉडल पैरेललिज़्म सक्षम करता है, जिससे कई एक्सेलेरेटर्स पर LLMs को कुशलतापूर्वक स्केल किया जा सकता है।

(1, 8) आकार के साथ DeviceMesh बनाएँ, ताकि मॉडल वेट्स सभी 8 TPUs में शार्ड हो जाएँ।

import kerasimport keras_nlpdevice_mesh = keras.distribution.DeviceMesh(    (1, 8), ["batch", "model"], devices=keras.distribution.list_devices())संचालित द्वारा

अगले चरण में, हम RegEx का उपयोग करके यह निर्दिष्ट करते हुए एक लेआउट मैप बनाएँगे कि वेट्स और टेन्सर्स को कैसे शार्ड या रेप्लिकेट किया जाना चाहिए।

निम्न बिंदु ध्यान रखें:

• जो वेट्स token_embedding/embeddings से मैच होते हैं वे साझा किए जाएँगे।

• डिकोडर के attention, attention_output, ffw_gating और ffw_linear लेयर्स में query, key और value मैट्रिसेज़ को मैच करने के लिए RegEx का उपयोग करें।

• मैच हुए टेन्सर्स को DeviceMesh का उपयोग करके शार्ड किया जाएगा, और बाकी पूर्णतः रेप्लिकेट होंगे।

model_dim = "model"layout_map = keras.distribution.LayoutMap(device_mesh)layout_map["token_embedding/embeddings"] = (None, model_dim)layout_map["decoder_block.*attention.*(query|key|value).*kernel"] = (    None,    model_dim,    None,)layout_map["decoder_block.*attention_output.*kernel"] = (None, None, model_dim)layout_map["decoder_block.*ffw_gating.*kernel"] = (model_dim, None)layout_map["decoder_block.*ffw_linear.*kernel"] = (None, model_dim)संचालित द्वारा

अब हम device_mesh और layout_map का उपयोग करके मॉडल पैरेललिज़्म सक्रिय करेंगे। 

model_parallel = keras.distribution.ModelParallel(    device_mesh, layout_map, batch_dim_name="batch")keras.distribution.set_distribution(model_parallel)संचालित द्वारा

मॉडल लोड करना

मॉडल पैरेललिज़्म सेटअप करने के बाद, हम अपना मॉडल लोड करते हैं। 

gemma_lm = keras_nlp.models.GemmaCausalLM.from_preset("gemma_7b_en")gemma_lm.summary()संचालित द्वारा

इस बार, क्योंकि हम Gemma 7B मॉडल का उपयोग कर रहे हैं, हम 8.5 बिलियन ट्रेन योग्य पैरामीटर्स देखते हैं। 

Gemma 7b मॉडल सारांश

यह सत्यापित करने के लिए कि मॉडल सही तरह से शार्ड हुआ है, हम decoder_block_1 लेयर वेट्स के path, shape और spec प्रिंट करेंगे। 

decoder_block_1 = gemma_lm.backbone.get_layer('decoder_block_1')print(type(decoder_block_1))for variable in decoder_block_1.weights:  print(f'{variable.path:<58}  {str(variable.shape):<16}  {str(variable.value.sharding.spec)}')संचालित द्वारा

डिकोडर ब्लॉक

डेटासेट लोड करना

आइए OpenHermes डेटासेट लोड करें। एक बार फिर, हम निर्देश और प्रतिक्रिया टेम्पलेट का उपयोग करके डेटा फ़्रेम को स्ट्रिंग्स की सूची में बदलते हैं, और प्रशिक्षण समय तेज करने के लिए शीर्ष 1,000 नमूने ही चुनते हैं। 

import pandas as pddf = pd.read_csv('/kaggle/input/openhermes/openhermes.csv')# Format and convert the dataframe into a list of strings.template = "Instruction:\n{instruction}\n\nResponse:\n{output}"data = [template.format(**row) for index, row in df.iterrows()]# Select a subset of the dataset. data = data[:1000]संचालित द्वारा

फाइन-ट्यूनिंग से पहले इंफरेंस

हम फ़ॉर्मेटेड प्रॉम्प्ट देकर अब बेसलाइन के लिए प्रतिक्रिया जनरेट करेंगे। दिलचस्प बात यह है कि प्रतिक्रिया छोटे मॉडल से भी खराब है, लेकिन आगे बढ़ते हैं। 

prompt = template.format(    instruction="Plan a 5-day Bahamas trip.",    output="",)print(gemma_lm.generate(prompt, max_length=256))संचालित द्वारा

 फाइन-ट्यूनिंग से पहले इंफरेंस परिणाम

फाइन-ट्यूनिंग के लिए मॉडल कम्पाइल करना

हम वही मॉडल कॉन्फ़िगरेशन, LoRA रैंक, ऑप्टिमाइज़र, लॉस फ़ंक्शन और एक्यूरेसी मेट्रिक उपयोग करते हुए मॉडल कम्पाइल करेंगे। अब हमारे पास 11 मिलियन ट्रेन योग्य पैरामीटर्स हैं, जिनका आकार 42.22 MB है।

gemma_lm.backbone.enable_lora(rank=4)gemma_lm.preprocessor.sequence_length = 512optimizer = keras.optimizers.AdamW(    learning_rate=5e-5,    weight_decay=0.01,)optimizer.exclude_from_weight_decay(var_names=["bias", "scale"])gemma_lm.compile(    loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),    optimizer=optimizer,    weighted_metrics=[keras.metrics.SparseCategoricalAccuracy()],)gemma_lm.summary()संचालित द्वारा

Gemma 7b LoRA मॉडल सारांश

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

एक epoch को फाइन-ट्यून करने में हमें 305 सेकंड लगे, जो मॉडल के आकार को देखते हुए बहुत अच्छा है। 

gemma_lm.fit(data, epochs=1, batch_size=1)संचालित द्वारा

यदि आपको फाइन-ट्यूनिंग चुनौतीपूर्ण लग रही है, तो आप OpenAI के API का उपयोग करना सीख सकते हैं और GPT-4 को फाइन-ट्यून करने के स्टेप-बाय-स्टेप गाइड का अनुसरण कर सकते हैं। 

फाइन-ट्यूनिंग के बाद इंफरेंस

आइए प्रतिक्रिया जनरेट करें और उसे बेसलाइन परिणाम से तुलना करें। 

prompt = template.format(    instruction="Plan a 5-day Bahamas trip.",    output="",)print(gemma_lm.generate(prompt, max_length=256))संचालित द्वारा

फाइन-ट्यून किया गया मॉडल उत्कृष्ट है। इसने पाँच-दिवसीय बहामास यात्रा का आनंद लेने के लिए करने योग्य कार्यों की सूची के साथ प्रतिक्रिया जनरेट की है। 

नोट: आप मॉडल पैरेललिज़्म के साथ फुल-पैरामीटर ट्यूनिंग के लिए LoRA बंद कर सकते हैं—यह धीमा होगा लेकिन अधिक सटीक।

फाइन-ट्यूनिंग के बाद इंफरेंस परिणाम

gemma_lm.save_weights('gemma_7b_openhermes.weights.h5')संचालित द्वारा

यदि आपको वितरित फाइन-ट्यूनिंग में कठिनाई हो रही है, तो एक अतिरिक्त संसाधन के रूप में इस Kaggle नोटबुक को देखें: Accessing Gemma-instruct-2b-en using TPUs. 

निष्कर्ष

इस ट्यूटोरियल में, हमने TPUs के बारे में सीखा और LLMs की प्रतिक्रिया जनरेशन को तेज करने के लिए उनका उपयोग कैसे करें, यह समझा। इसके अलावा, हमने TPUs और वितरित प्रशिक्षण का उपयोग करके OpenHermes डेटासेट पर Gemma मॉडलों को फाइन-ट्यून करना सीखा।

TPUs पर LLMs का फाइन-ट्यूनिंग और वितरित लर्निंग के लिए मॉडल पैरेललिज़्म का उपयोग प्रशिक्षण समय को तेज करने के महत्वपूर्ण तरीके हैं। वितरित लर्निंग का उपयोग करके, आप Gemma 7B जैसे बहुत बड़े मॉडलों को भी फाइन-ट्यून कर सकते हैं। TPUs—जो उच्च-प्रदर्शन मशीन लर्निंग कार्यों के लिए विशेष रूप से डिज़ाइन किए गए हैं—का लाभ उठाकर, आप प्रशिक्षण और इंफरेंस दोनों चरणों में उल्लेखनीय स्पीड-अप प्राप्त कर सकते हैं।

यदि आपने इस ट्यूटोरियल का आनंद लिया और बड़े भाषा मॉडलों की दुनिया के बारे में और सीखना चाहते हैं, तो Master Large Language Models (LLMs) Concepts कोर्स करें और LLMs के अनुप्रयोगों, प्रशिक्षण पद्धतियों, नैतिक पहलुओं और नवीनतम शोध की पूरी क्षमता जानें। यदि आप Gemma के साथ प्रतिस्पर्धा कर रहे अन्य बड़े भाषा मॉडलों में रुचि रखते हैं, तो हमारा Getting Started With Mixtral 8X22B ट्यूटोरियल देखें और Mistral AI के नए मॉडल तथा इसकी sparse mixture of experts (SMoE) आर्किटेक्चर के बारे में जानें।