ai.google.dev पर देखें | Google Colab में चलाएं | Vertex AI में खोलें | GitHub पर सोर्स देखें |
खास जानकारी
Gemma, Google DeepMind Gemini की रिसर्च और टेक्नोलॉजी पर आधारित, लाइटवेट और आधुनिक लार्ज लैंग्वेज मॉडल का फ़ैमिली ग्रुप है. इस ट्यूटोरियल में बताया गया है कि Google DeepMind की gemma
लाइब्रेरी का इस्तेमाल करके, Gemma 2B इंस्ट्रक्शन मॉडल का इस्तेमाल करके बुनियादी सैंपलिंग/अनुमान कैसे लगाया जाता है. इसे JAX (बहुत अच्छी परफ़ॉर्मेंस वाली न्यूमेरिक कंप्यूटिंग लाइब्रेरी), Flaxizer (JAX पर आधारित न्यूरल नेटवर्क लाइब्रेरी), Orbax (चेकपॉइंटिंग/चेकपॉइंटिंग टोकन (JAX) की ट्रेनिंग के लिए इस्तेमाल की जाने वाली लाइब्रेरी की मदद से लिखा जाता है. हालांकि, इस notebook में Flux का सीधे तौर पर इस्तेमाल नहीं किया गया है, लेकिन Gemma बनाने के लिए Flax का इस्तेमाल किया गया है.
यह notebook, Google Colab पर बिना किसी शुल्क के T4 जीपीयू (बदलाव करें > नोटबुक की सेटिंग पर जाएं) पर जाएं > हार्डवेयर ऐक्सेलरेटर में जाकर, T4 जीपीयू चुनें.
सेटअप
1. Gemma के लिए Kaggle का ऐक्सेस सेट अप करें
इस ट्यूटोरियल को पूरा करने के लिए, आपको सबसे पहले Gemma सेटअप पर जाकर, सेटअप से जुड़े निर्देशों का पालन करना होगा. इसमें, इन निर्देशों का पालन करने के बारे में बताया गया है:
- kaggle.com पर जाकर, Gemma चैनल का ऐक्सेस पाएं.
- जेम्मा मॉडल चलाने के लिए, ज़रूरत के मुताबिक संसाधनों वाला Colab रनटाइम चुनें.
- Kaggle उपयोगकर्ता नाम और एपीआई पासकोड जनरेट और कॉन्फ़िगर करें.
जेम्मा सेटअप पूरा करने के बाद, अगले सेक्शन पर जाएं. यहां आपको Colab के एनवायरमेंट के लिए एनवायरमेंट वैरिएबल सेट करने होंगे.
2. एनवायरमेंट वैरिएबल सेट करना
KAGGLE_USERNAME
और KAGGLE_KEY
के लिए एनवायरमेंट वैरिएबल सेट करें. जब "ऐक्सेस दें?" मैसेज दिखे, तो सीक्रेट ऐक्सेस देने के लिए सहमति दें.
import os
from google.colab import userdata # `userdata` is a Colab API.
os.environ["KAGGLE_USERNAME"] = userdata.get('KAGGLE_USERNAME')
os.environ["KAGGLE_KEY"] = userdata.get('KAGGLE_KEY')
3. gemma
लाइब्रेरी इंस्टॉल करें
इस notebook में, बिना किसी शुल्क के Colab जीपीयू का इस्तेमाल करने पर फ़ोकस किया गया है. हार्डवेयर से तेज़ी लाने के लिए, बदलाव करें > Notebook की सेटिंग > T4 जीपीयू > सेव करें चुनें.
इसके बाद, आपको github.com/google-deepmind/gemma
से Google DeepMind gemma
की लाइब्रेरी इंस्टॉल करनी होगी. अगर आपको "पीआईपी की डिपेंडेंसी रिज़ॉल्वर" के बारे में कोई गड़बड़ी मिलती है, तो आम तौर पर इसे अनदेखा किया जा सकता है.
pip install -q git+https://github.com/google-deepmind/gemma.git
जेम्मा मॉडल लोड और तैयार करें
- Gemma मॉडल को
kagglehub.model_download
के साथ लोड करें, जिसमें तीन आर्ग्युमेंट होते हैं:
handle
: Kaggle का मॉडल हैंडलpath
: (वैकल्पिक स्ट्रिंग) लोकल पाथforce_download
: (ज़रूरी नहीं बूलियन) मॉडल को फिर से डाउनलोड करता है
GEMMA_VARIANT = '2b-it' # @param ['2b', '2b-it'] {type:"string"}
import kagglehub
GEMMA_PATH = kagglehub.model_download(f'google/gemma/flax/{GEMMA_VARIANT}')
Downloading from https://www.kaggle.com/api/v1/models/google/gemma/flax/2b-it/2/download... 100%|██████████| 3.67G/3.67G [00:35<00:00, 110MB/s] Extracting model files...
print('GEMMA_PATH:', GEMMA_PATH)
GEMMA_PATH: /root/.cache/kagglehub/models/google/gemma/flax/2b-it/2
- मॉडल वेट और टोकनाइज़र की लोकेशन देखें. इसके बाद, पाथ वैरिएबल सेट करें. टोकनाइज़र डायरेक्ट्री उस मुख्य डायरेक्ट्री में होगी जहां से आपने मॉडल डाउनलोड किया है. वहीं, मॉडल वेट किसी सब-डायरेक्ट्री में होगा. उदाहरण के लिए:
tokenizer.model
फ़ाइल,/LOCAL/PATH/TO/gemma/flax/2b-it/2
में होगी).- मॉडल चेकपॉइंट
/LOCAL/PATH/TO/gemma/flax/2b-it/2/2b-it
में होगा).
CKPT_PATH = os.path.join(GEMMA_PATH, GEMMA_VARIANT)
TOKENIZER_PATH = os.path.join(GEMMA_PATH, 'tokenizer.model')
print('CKPT_PATH:', CKPT_PATH)
print('TOKENIZER_PATH:', TOKENIZER_PATH)
CKPT_PATH: /root/.cache/kagglehub/models/google/gemma/flax/2b-it/2/2b-it TOKENIZER_PATH: /root/.cache/kagglehub/models/google/gemma/flax/2b-it/2/tokenizer.model
सैंपल लेना/अनुमान लगाना
gemma.params.load_and_format_params
तरीके का इस्तेमाल करके, जेम्मा मॉडल चेकपॉइंट लोड और फ़ॉर्मैट करें:
from gemma import params as params_lib
params = params_lib.load_and_format_params(CKPT_PATH)
sentencepiece.SentencePieceProcessor
का इस्तेमाल करके बनाया गया जेमा टोकनाइज़र लोड करें:
import sentencepiece as spm
vocab = spm.SentencePieceProcessor()
vocab.Load(TOKENIZER_PATH)
True
- Gemma मॉडल चेकपॉइंट से सही कॉन्फ़िगरेशन अपने-आप लोड करने के लिए,
gemma.transformer.TransformerConfig
का इस्तेमाल करें.cache_size
आर्ग्युमेंट, जेमTransformer
कैश में कुल चरणों की संख्या है. इसके बाद,gemma.transformer.Transformer
(जोflax.linen.Module
से इनहेरिट किया जाता है) की मदद से, जेम्मा मॉडल कोtransformer
के तौर पर इंस्टैंशिएट करें.
from gemma import transformer as transformer_lib
transformer_config = transformer_lib.TransformerConfig.from_params(
params=params,
cache_size=1024
)
transformer = transformer_lib.Transformer(transformer_config)
- जेम्मा मॉडल चेकपॉइंट/वेट और टोकनाइज़र के ऊपर,
gemma.sampler.Sampler
वालाsampler
बनाएं:
from gemma import sampler as sampler_lib
sampler = sampler_lib.Sampler(
transformer=transformer,
vocab=vocab,
params=params['transformer'],
)
input_batch
में प्रॉम्प्ट लिखें और अनुमान लगाएं.total_generation_steps
(रिस्पॉन्स जनरेट करने के दौरान पूरे किए गए चरणों की संख्या) में बदलाव किया जा सकता है. इस उदाहरण में, होस्ट की मेमोरी को सुरक्षित रखने के लिए100
का इस्तेमाल किया गया है.
prompt = [
"\n# What is the meaning of life?",
]
reply = sampler(input_strings=prompt,
total_generation_steps=100,
)
for input_string, out_string in zip(prompt, reply.text):
print(f"Prompt:\n{input_string}\nOutput:\n{out_string}")
Prompt: # What is the meaning of life? Output: The question of what the meaning of life is one that has occupied the minds of philosophers, theologians, and individuals for centuries. There is no single, universally accepted answer, but there are many different perspectives on this complex and multifaceted question. **Some common perspectives on the meaning of life include:** * **Biological perspective:** From a biological standpoint, the meaning of life is to survive and reproduce. * **Existential perspective:** Existentialists believe that life is not inherently meaningful and that
- (ज़रूरी नहीं) अगर आपने notebook पूरी कर ली है और आपको कोई दूसरा प्रॉम्प्ट आज़माना है, तो मेमोरी खाली करने के लिए इस सेल को चलाएं. इसके बाद, तीसरे चरण में
sampler
को फिर से इंस्टैंशिएट किया जा सकता है. साथ ही, चौथे चरण में प्रॉम्प्ट को अपनी पसंद के मुताबिक बनाया और चलाया जा सकता है.
del sampler
ज़्यादा जानें
- Google DeepMind GitHub पर
gemma
लाइब्रेरी के बारे में ज़्यादा जानें. इसमें, इस ट्यूटोरियल में इस्तेमाल किए गए मॉड्यूल की डॉकस्ट्रिंग शामिल है. जैसे,gemma.params
,gemma.transformer
, औरgemma.sampler
. - इन लाइब्रेरी की अपनी दस्तावेज़ साइटें हैं: core JAX, Flax, और Orbax.
sentencepiece
टोकनाइज़र/डिटोकेनाइज़र दस्तावेज़ के लिए, Google काsentencepiece
GitHub रेपो देखें.kagglehub
दस्तावेज़ के लिए, Kaggle केkagglehub
GitHub रेपो परREADME.md
देखें.- Google Cloud Vertex AI के साथ Gemma मॉडल इस्तेमाल करने का तरीका जानें.