जैक्स और फ़्लैक्स का इस्तेमाल करके जेम्मा के साथ अनुमान लगाना

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

जेम्मा मॉडल लोड और तैयार करें

  1. 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
  1. मॉडल वेट और टोकनाइज़र की लोकेशन देखें. इसके बाद, पाथ वैरिएबल सेट करें. टोकनाइज़र डायरेक्ट्री उस मुख्य डायरेक्ट्री में होगी जहां से आपने मॉडल डाउनलोड किया है. वहीं, मॉडल वेट किसी सब-डायरेक्ट्री में होगा. उदाहरण के लिए:
  • 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

सैंपल लेना/अनुमान लगाना

  1. gemma.params.load_and_format_params तरीके का इस्तेमाल करके, जेम्मा मॉडल चेकपॉइंट लोड और फ़ॉर्मैट करें:
from gemma import params as params_lib

params = params_lib.load_and_format_params(CKPT_PATH)
  1. sentencepiece.SentencePieceProcessor का इस्तेमाल करके बनाया गया जेमा टोकनाइज़र लोड करें:
import sentencepiece as spm

vocab = spm.SentencePieceProcessor()
vocab.Load(TOKENIZER_PATH)

True
  1. 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)
  1. जेम्मा मॉडल चेकपॉइंट/वेट और टोकनाइज़र के ऊपर, gemma.sampler.Sampler वाला sampler बनाएं:
from gemma import sampler as sampler_lib

sampler = sampler_lib.Sampler(
    transformer=transformer,
    vocab=vocab,
    params=params['transformer'],
)
  1. 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
  1. (ज़रूरी नहीं) अगर आपने notebook पूरी कर ली है और आपको कोई दूसरा प्रॉम्प्ट आज़माना है, तो मेमोरी खाली करने के लिए इस सेल को चलाएं. इसके बाद, तीसरे चरण में sampler को फिर से इंस्टैंशिएट किया जा सकता है. साथ ही, चौथे चरण में प्रॉम्प्ट को अपनी पसंद के मुताबिक बनाया और चलाया जा सकता है.
del sampler

ज़्यादा जानें