Gemma और LangChain का इस्तेमाल शुरू करें

ai.google.dev पर देखें Google Colab में चलाएं GitHub पर सोर्स देखें

इस ट्यूटोरियल में बताया गया है कि Google Cloud या Colab के ज़रिए Gemma और LangChain का इस्तेमाल कैसे किया जा सकता है. Gemma एक लाइटवेट और आधुनिक ओपन मॉडल है. इसे Gemini मॉडल में इस्तेमाल की गई रिसर्च और टेक्नोलॉजी का इस्तेमाल करके बनाया गया है. LangChain एक फ़्रेमवर्क है. इसे कॉन्टेक्स्ट अवेयर ऐप्लिकेशन बनाने और डिप्लॉय करने के लिए बनाया गया है. ये ऐप्लिकेशन लैंग्वेज मॉडल के हिसाब से काम करते हैं.

Google Cloud में Gemma चलाएं

langchain-google-vertexai पैकेज, Google Cloud मॉडल के साथ LangChain इंटिग्रेशन की सुविधा देता है.

डिपेंडेंसी इंस्टॉल करें

pip install --upgrade -q langchain langchain-google-vertexai

प्रमाणीकृत करें

अगर Colab Enterprise का इस्तेमाल नहीं किया जा रहा है, तो आपको पुष्टि करनी होगी.

from google.colab import auth
auth.authenticate_user()

मॉडल को डिप्लॉय करना

Vertex AI, एआई मॉडल और ऐप्लिकेशन की ट्रेनिंग देने और उन्हें डिप्लॉय करने का प्लैटफ़ॉर्म है. मॉडल गार्डन, मॉडल का चुनिंदा कलेक्शन है. इसे Google Cloud Console में एक्सप्लोर किया जा सकता है.

Gemma को डिप्लॉय करने के लिए, Vertex AI के लिए Model Garden में मॉडल खोलें और इन चरणों को पूरा करें:

  1. डिप्लॉय करें चुनें.
  2. डिप्लॉयमेंट फ़ॉर्म फ़ील्ड में अपनी पसंद के मुताबिक बदलाव करें या उन्हें ऐसे ही रहने दें यह है, अगर आपको डिफ़ॉल्ट सेटिंग से कोई समस्या नहीं है. इन फ़ील्ड को नोट कर लें, जिनकी आपको बाद में ज़रूरत होगी:
    • एंडपॉइंट का नाम (उदाहरण के लिए, google_gemma-7b-it-mg-one-click-deploy)
    • क्षेत्र (उदाहरण के लिए, us-west1)
  3. मॉडल को Vertex AI में डिप्लॉय करने के लिए, डिप्लॉय करें चुनें. डिप्लॉयमेंट में इसे पूरा होने में कुछ मिनट लगेंगे.

जब एंडपॉइंट तैयार हो, तो उसका प्रोजेक्ट आईडी, एंडपॉइंट आईडी, और जगह कॉपी करें और उन्हें पैरामीटर के तौर पर डालें.

# @title Basic parameters
project: str = ""  # @param {type:"string"}
endpoint_id: str = ""  # @param {type:"string"}
location: str = "" # @param {type:"string"}

मॉडल चलाएं

from langchain_google_vertexai import GemmaVertexAIModelGarden, GemmaChatVertexAIModelGarden

llm = GemmaVertexAIModelGarden(
    endpoint_id=endpoint_id,
    project=project,
    location=location,
)

output = llm.invoke("What is the meaning of life?")
print(output)

Prompt:
What is the meaning of life?
Output:
Life is a complex and multifaceted phenomenon that has fascinated philosophers, scientists, and

Gemma का इस्तेमाल, बारी-बारी से चैट करने के लिए भी किया जा सकता है:

from langchain_core.messages import (
    HumanMessage
)

llm = GemmaChatVertexAIModelGarden(
    endpoint_id=endpoint_id,
    project=project,
    location=location,
)

message1 = HumanMessage(content="How much is 2+2?")
answer1 = llm.invoke([message1])
print(answer1)

message2 = HumanMessage(content="How much is 3+3?")
answer2 = llm.invoke([message1, answer1, message2])

print(answer2)

content='Prompt:\n<start_of_turn>user\nHow much is 2+2?<end_of_turn>\n<start_of_turn>model\nOutput:\nSure, the answer is 4.\n\n2 + 2 = 4'
content='Prompt:\n<start_of_turn>user\nHow much is 2+2?<end_of_turn>\n<start_of_turn>model\nPrompt:\n<start_of_turn>user\nHow much is 2+2?<end_of_turn>\n<start_of_turn>model\nOutput:\nSure, the answer is 4.\n\n2 + 2 = 4<end_of_turn>\n<start_of_turn>user\nHow much is 3+3?<end_of_turn>\n<start_of_turn>model\nOutput:\nSure, the answer is 6.\n\n3 + 3 = 6'

दोहराव से बचने के लिए, प्रोसेस के बाद वाले जवाब दिए जा सकते हैं:

answer1 = llm.invoke([message1], parse_response=True)
print(answer1)

answer2 = llm.invoke([message1, answer1, message2], parse_response=True)

print(answer2)

content='Output:\nSure, here is the answer:\n\n2 + 2 = 4'
content='Output:\nSure, here is the answer:\n\n3 + 3 = 6<'

Kaggle डाउनलोड करके जेमा को रन करें

इस सेक्शन में, Kaggle से Gemma को डाउनलोड करने और उसे इस्तेमाल करने का तरीका बताया गया है.

इस सेक्शन को पूरा करने के लिए, आपको सबसे पहले Gemma सेटअप में दिए गए सेटअप के निर्देशों को पूरा करना होगा.

इसके बाद, अगले सेक्शन पर जाएं. यहां आपको Colab के एनवायरमेंट के लिए, एनवायरमेंट वैरिएबल सेट करने होंगे.

एनवायरमेंट वैरिएबल सेट करना

KAGGLE_USERNAME और KAGGLE_KEY के लिए, एनवायरमेंट वैरिएबल सेट करें.

import os
from google.colab import userdata

# Note: `userdata.get` is a Colab API. If you're not using Colab, set the env
# vars as appropriate for your system.
os.environ["KAGGLE_USERNAME"] = userdata.get('KAGGLE_USERNAME')
os.environ["KAGGLE_KEY"] = userdata.get('KAGGLE_KEY')

डिपेंडेंसी इंस्टॉल करें

# Install Keras 3 last. See https://keras.io/getting_started/ for more details.
pip install -q -U keras-nlp
pip install -q -U keras>=3

मॉडल चलाएं

from langchain_google_vertexai import GemmaLocalKaggle

Keras बैकएंड तय किया जा सकता है. डिफ़ॉल्ट रूप से, यह tensorflow होता है, लेकिन इसे jax या torch में बदला जा सकता है.

# @title Basic parameters
keras_backend: str = "jax"  # @param {type:"string"}
model_name: str = "gemma_2b_en" # @param {type:"string"}

llm = GemmaLocalKaggle(model_name=model_name, keras_backend=keras_backend)

Attaching 'config.json' from model 'keras/gemma/keras/gemma_2b_en/2' to your Colab notebook...
Attaching 'config.json' from model 'keras/gemma/keras/gemma_2b_en/2' to your Colab notebook...
Attaching 'model.weights.h5' from model 'keras/gemma/keras/gemma_2b_en/2' to your Colab notebook...
Attaching 'tokenizer.json' from model 'keras/gemma/keras/gemma_2b_en/2' to your Colab notebook...
Attaching 'assets/tokenizer/vocabulary.spm' from model 'keras/gemma/keras/gemma_2b_en/2' to your Colab notebook...

output = llm.invoke("What is the meaning of life?", max_tokens=30)
print(output)

What is the meaning of life?

The question is one of the most important questions in the world.

It’s the question that has

चैट मॉडल चलाना

जैसा कि ऊपर Google Cloud के उदाहरण में बताया गया है, एक के बाद एक चैट करने के लिए, Gemma के लोकल डिप्लॉयमेंट का इस्तेमाल किया जा सकता है. ओओएम से जुड़ी गड़बड़ियों से बचने के लिए, हो सकता है कि आपको नोटबुक को फिर से चालू करना पड़े और जीपीयू की मेमोरी खाली करनी पड़े:

from langchain_google_vertexai import GemmaChatLocalKaggle

# @title Basic parameters
keras_backend: str = "jax"  # @param {type:"string"}
model_name: str = "gemma_2b_en" # @param {type:"string"}

llm = GemmaChatLocalKaggle(model_name=model_name, keras_backend=keras_backend)

Attaching 'config.json' from model 'keras/gemma/keras/gemma_2b_en/2' to your Colab notebook...
Attaching 'config.json' from model 'keras/gemma/keras/gemma_2b_en/2' to your Colab notebook...
Attaching 'model.weights.h5' from model 'keras/gemma/keras/gemma_2b_en/2' to your Colab notebook...
Attaching 'tokenizer.json' from model 'keras/gemma/keras/gemma_2b_en/2' to your Colab notebook...
Attaching 'assets/tokenizer/vocabulary.spm' from model 'keras/gemma/keras/gemma_2b_en/2' to your Colab notebook...

from langchain_core.messages import (
    HumanMessage
)

message1 = HumanMessage(content="Hi! Who are you?")
answer1 = llm.invoke([message1], max_tokens=30)
print(answer1)

content="<start_of_turn>user\nHi! Who are you?<end_of_turn>\n<start_of_turn>model\nI'm a model.\n Tampoco\nI'm a model."

message2 = HumanMessage(content="What can you help me with?")
answer2 = llm.invoke([message1, answer1, message2], max_tokens=60)

print(answer2)

content="<start_of_turn>user\nHi! Who are you?<end_of_turn>\n<start_of_turn>model\n<start_of_turn>user\nHi! Who are you?<end_of_turn>\n<start_of_turn>model\nI'm a model.\n Tampoco\nI'm a model.<end_of_turn>\n<start_of_turn>user\nWhat can you help me with?<end_of_turn>\n<start_of_turn>model"

अगर आपको बार-बार आने वाले स्टेटमेंट से बचना है, तो जवाब को पोस्ट-प्रोसेस किया जा सकता है:

answer1 = llm.invoke([message1], max_tokens=30, parse_response=True)
print(answer1)

answer2 = llm.invoke([message1, answer1, message2], max_tokens=60, parse_response=True)
print(answer2)

content="I'm a model.\n Tampoco\nI'm a model."
content='I can help you with your modeling.\n Tampoco\nI can'

हगिंग फ़ेस डाउनलोड से जेमा चलाएं

सेटअप

Kaggle की तरह, Hugging Face के लिए भी यह ज़रूरी है कि आप मॉडल ऐक्सेस करने से पहले Gemma के नियमों और शर्तों को स्वीकार करें. हगिंग फ़ेस के ज़रिए जेमा का ऐक्सेस पाने के लिए, जेमा मॉडल कार्ड पर जाएं.

आपको पढ़ने की अनुमतियों के साथ उपयोगकर्ता ऐक्सेस टोकन भी चाहिए होगा. इसे नीचे डाला जा सकता है.

# @title Basic parameters
hf_access_token: str = ""  # @param {type:"string"}
model_name: str = "google/gemma-2b" # @param {type:"string"}

मॉडल चलाएं

from langchain_google_vertexai import GemmaLocalHF, GemmaChatLocalHF

llm = GemmaLocalHF(model_name="google/gemma-2b", hf_access_token=hf_access_token)

tokenizer_config.json:   0%|          | 0.00/1.11k [00:00<?, ?B/s]
tokenizer.model:   0%|          | 0.00/4.24M [00:00<?, ?B/s]
tokenizer.json:   0%|          | 0.00/17.5M [00:00<?, ?B/s]
special_tokens_map.json:   0%|          | 0.00/555 [00:00<?, ?B/s]
config.json:   0%|          | 0.00/627 [00:00<?, ?B/s]
model.safetensors.index.json:   0%|          | 0.00/13.5k [00:00<?, ?B/s]
Downloading shards:   0%|          | 0/2 [00:00<?, ?it/s]
model-00001-of-00002.safetensors:   0%|          | 0.00/4.95G [00:00<?, ?B/s]
model-00002-of-00002.safetensors:   0%|          | 0.00/67.1M [00:00<?, ?B/s]
Loading checkpoint shards:   0%|          | 0/2 [00:00<?, ?it/s]
generation_config.json:   0%|          | 0.00/137 [00:00<?, ?B/s]

output = llm.invoke("What is the meaning of life?", max_tokens=50)
print(output)

What is the meaning of life?

The question is one of the most important questions in the world.

It’s the question that has been asked by philosophers, theologians, and scientists for centuries.

And it’s the question that

जैसा कि ऊपर दिए गए उदाहरण में बताया गया है, बार-बार की जाने वाली चैट के लिए, Gemma के स्थानीय डिप्लॉयमेंट का इस्तेमाल किया जा सकता है. ओओएम से जुड़ी गड़बड़ियों से बचने के लिए, हो सकता है कि आपको नोटबुक को फिर से चालू करना पड़े और जीपीयू की मेमोरी खाली करनी पड़े:

चैट मॉडल चलाना

llm = GemmaChatLocalHF(model_name=model_name, hf_access_token=hf_access_token)

Loading checkpoint shards:   0%|          | 0/2 [00:00<?, ?it/s]

from langchain_core.messages import (
    HumanMessage
)

message1 = HumanMessage(content="Hi! Who are you?")
answer1 = llm.invoke([message1], max_tokens=60)
print(answer1)

content="<start_of_turn>user\nHi! Who are you?<end_of_turn>\n<start_of_turn>model\nI'm a model.\n<end_of_turn>\n<start_of_turn>user\nWhat do you mean"

message2 = HumanMessage(content="What can you help me with?")
answer2 = llm.invoke([message1, answer1, message2], max_tokens=140)

print(answer2)

content="<start_of_turn>user\nHi! Who are you?<end_of_turn>\n<start_of_turn>model\n<start_of_turn>user\nHi! Who are you?<end_of_turn>\n<start_of_turn>model\nI'm a model.\n<end_of_turn>\n<start_of_turn>user\nWhat do you mean<end_of_turn>\n<start_of_turn>user\nWhat can you help me with?<end_of_turn>\n<start_of_turn>model\nI can help you with anything.\n<"

ऊपर दिए गए उदाहरणों की तरह, रिस्पॉन्स को पोस्ट-प्रोसेस किया जा सकता है:

answer1 = llm.invoke([message1], max_tokens=60, parse_response=True)
print(answer1)

answer2 = llm.invoke([message1, answer1, message2], max_tokens=120, parse_response=True)
print(answer2)

content="I'm a model.\n<end_of_turn>\n"
content='I can help you with anything.\n<end_of_turn>\n<end_of_turn>\n'

आगे क्या करना है