Google Gemma का फाइन-ट्यूनिंग: कस्टम निर्देशों से LLMs को बेहतर बनाना

AI की दुनिया में यह बेहद रोमांचक समय है। Google, Meta और Twitter जैसी बड़ी कंपनियाँ अपने बड़े भाषा मॉडल (LLMs) को ओपन-सोर्स बनाने पर तेज़ी से ध्यान दे रही हैं। हाल ही में, Google DeepMind टीम ने Gemma लॉन्च किया है — हल्के और ओपन-सोर्स LLMs का एक परिवार, जिसे Google के Gemini मॉडलों को बनाने में इस्तेमाल हुई उसी रिसर्च और तकनीक से बनाया गया है।

छवि स्रोत

यहाँ, हम Gemma मॉडलों के बारे में जानेंगे, क्लाउड GPUs और TPUs का उपयोग करके उन्हें कैसे एक्सेस करें, और role-play डेटासेट पर नवीनतम Gemma 7b-it मॉडल को कैसे ट्रेन करें।

Google के Gemma को समझना

Gemma (लैटिन शब्द जिसका अर्थ है “कीमती पत्थर”) टेक्स्ट-टू-टेक्स्ट, डिकोडर-ओनली, ओपन मॉडलों का एक परिवार है, जिसे Google की विभिन्न टीमों, विशेषकर Google DeepMind, ने विकसित किया है। यह Gemini मॉडलों से प्रेरित है और इसे हल्का तथा सभी प्रमुख फ्रेमवर्क्स के साथ संगत होने के लिए डिज़ाइन किया गया है।

Google ने Gemma के दो आकारों के लिए मॉडल वेट्स जारी किए हैं — Gemma 2B और Gemma 7B — जो प्री-ट्रेंड और इंस्ट्रक्शन-ट्यून किए गए वेरिएंट्स (जैसे Gemma 2B-it और Gemma 7B-it) में उपलब्ध हैं।

जैसा कि हम जानते हैं, Gemma के तकनीकी घटक Gemini से मिलते-जुलते हैं, और यह अपने आकार वर्ग में Meta के Llama-2 जैसे अन्य ओपन मॉडलों की तुलना में सर्वश्रेष्ठ प्रदर्शन देता है। इसने सभी LLM बेंचमार्क्स पर Llama-2 को पीछे छोड़ दिया है।

छवि स्रोत

Gemma कई टूल्स और सिस्टम्स को सपोर्ट करता है, जिनमें Keras 3.0, native PyTorch, JAX, और Hugging Face Transformers जैसे मल्टी-फ्रेमवर्क टूल्स शामिल हैं। यह लैपटॉप, डेस्कटॉप, IoT, मोबाइल और क्लाउड सहित लोकप्रिय डिवाइस प्रकारों पर चलता है।

अब आप Keras 3.0 जैसे अपने पसंदीदा मशीन लर्निंग फ्रेमवर्क का उपयोग करके मुफ़्त Cloud TPUs पर इन्फ़रेंस और supervised fine-tuning (SFT) चला सकते हैं।

Google ने Gemma के साथ Responsible Generative AI Toolkit भी पेश किया है, जो डेवलपर्स को सुरक्षित AI एप्लिकेशन बनाने के लिए दिशा-निर्देश, आवश्यक टूल्स और सेफ्टी क्लासिफिकेशन विधियाँ प्रदान करता है।

यदि आप AI और LLMs की दुनिया में नए हैं, तो AI Fundamentals स्किल ट्रैक करने की सलाह दी जाती है। इससे आप ChatGPT, बड़े भाषा मॉडल, जेनरेटिव AI, इत्यादि जैसे लोकप्रिय AI विषयों का व्यावहारिक ज्ञान हासिल करेंगे।

Google के Gemma मॉडल तक कैसे पहुँचें

Gemma तक पहुँचना बहुत आसान है; आप इसे HuggingChat और Poe पर मुफ़्त में उपयोग करना शुरू कर सकते हैं। आप Hugging Face से मॉडल वेट्स डाउनलोड करके और GPT4ALL या LMStudio में से किसी एक का उपयोग करके इसे लोकली भी चला सकते हैं।

इस सेक्शन में, हम Kaggle प्लेटफ़ॉर्म द्वारा उपलब्ध कराए गए मुफ़्त GPUs और TPUs का उपयोग करके Gemma मॉडल को लोड करना और इन्फ़रेंस चलाना सीखेंगे।

TPUs पर Gemma इन्फ़रेंस चलाना

आप Keras/Gemma पर जाएँ, नीचे स्क्रॉल करें, “gemma_instruct_2b_en” मॉडल वेरिएंट चुनें, और “New Notebook” बटन पर क्लिक करें। यह Gemma मॉडल को इनपुट डायरेक्टरी में रखते हुए एक Cloud Notebook लॉन्च करेगा।

दाएँ पैनल में जाकर और नीचे स्क्रॉल करके एक्सेलेरेटर के रूप में “TPU VM v3-8” चुनें।

सुनिश्चित करें कि आपने आवश्यक सभी Python लाइब्रेरीज़ इंस्टॉल और अपडेट कर ली हैं।

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

उपलब्ध TPUs की संख्या जाँचने के लिए आप `jax` लाइब्रेरी और `device` फ़ंक्शन का उपयोग करके TPU डिवाइस डिस्प्ले कर सकते हैं। हमारे पास 8 TPUs की पहुँच है।

import jax

jax.devices()संचालित द्वारा

[TpuDevice(id=0, process_index=0, coords=(0,0,0), core_on_chip=0),
 TpuDevice(id=1, process_index=0, coords=(0,0,0), core_on_chip=1),
 TpuDevice(id=2, process_index=0, coords=(1,0,0), core_on_chip=0),
 TpuDevice(id=3, process_index=0, coords=(1,0,0), core_on_chip=1),
 TpuDevice(id=4, process_index=0, coords=(0,1,0), core_on_chip=0),
 TpuDevice(id=5, process_index=0, coords=(0,1,0), core_on_chip=1),
 TpuDevice(id=6, process_index=0, coords=(1,1,0), core_on_chip=0),
 TpuDevice(id=7, process_index=0, coords=(1,1,0), core_on_chip=1)]संचालित द्वारा

अब हम Keras 3 के लिए TPU सक्षम करेंगे, इसके लिए `jax` को Keras बैकएंड के रूप में सेट करेंगे।

import os

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

प्रारंभिक सेटअप के बाद, Gemma मॉडल तक पहुँच बनाना और प्रतिक्रिया जनरेट करना काफ़ी आसान है। हम Kaggle से मॉडल लोड करने के लिए `keras_nlp` लाइब्रेरी का उपयोग करेंगे और फिर प्रॉम्प्ट को `generate` फ़ंक्शन में देंगे।

import keras
import keras_nlp

model_name = "/kaggle/input/gemma/keras/gemma_instruct_2b_en/2"
gemma_lm = keras_nlp.models.GemmaCausalLM.from_preset(model_name)
prompt = "Can you share an interesting fact about Leonardo da Vinci?"

gemma_lm.generate(prompt, max_length=100)संचालित द्वारा

यह रहा परिणाम:

"Can you share an interesting fact about Leonardo da Vinci?\n\nSure, here's an interesting fact about Leonardo da Vinci:\n\nLeonardo da Vinci was born in a village called Vinci, Italy, which is now part of the city of Florence."

आप आसानी से Kaggle नोटबुक (Gemma-2B-V2 Simple Inference on TPU) चला सकते हैं और मुफ़्त TPUs का उपयोग करके प्रतिक्रियाएँ जनरेट करना शुरू कर सकते हैं।

GPUs पर Gemma इन्फ़रेंस चलाना

अब, हम GPUs का उपयोग करके और Keras की बजाय एक ट्रांसफ़ॉर्मर फ्रेमवर्क का उपयोग करके प्रतिक्रिया जनरेट करना सीखेंगे।

आप google/gemma पर जाएँ, नीचे स्क्रॉल करें, transformers चुनें, “7b-it” मॉडल वेरिएंट चुनें, और “New Notebook” बटन पर क्लिक करें। यह इनपुट डायरेक्टरी में Gemma मॉडल के सही संस्करण के साथ एक Cloud Notebook लॉन्च करेगा।

नोट: आप पेज पर और नीचे स्क्रॉल करके इन्फ़रेंस सेक्शन तक भी पहुँच सकते हैं। यहाँ आप प्रॉम्प्ट देकर और प्रतिक्रिया जनरेट करके Gemma के सभी प्रकार के वेरिएंट्स टेस्ट कर सकते हैं। यह तेज़ और सुविधाजनक है।

नई नोटबुक में, शीर्षक बदलें और फिर एक्सेलेरेटर को GPT T4 x2 में बदलें।

आवश्यक सभी Python पैकेज इंस्टॉल और अपडेट करें।

%%capture
%pip install -U bitsandbytes
%pip install -U transformers
%pip install -U accelerateसंचालित द्वारा

सीमित VRAM के कारण हम Kaggle GPUs पर पूरा Gemma 7b-it मॉडल लोड नहीं कर सकते। इस समस्या को हल करने के लिए हम BitsAndBytes का उपयोग करते हुए NF4 टाइप कॉन्फ़िगरेशन के साथ 4-बिट क्वांटाइज़ेशन में मॉडल लोड करेंगे। साथ ही, tokenizer भी लोड करें।

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, AutoConfig

modelName = "/kaggle/input/gemma/transformers/7b-it/2"

bnbConfig = BitsAndBytesConfig(
    load_in_4bit = True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
)

model = AutoModelForCausalLM.from_pretrained(
    modelName,
    device_map = "auto",
    quantization_config=bnbConfig
)

tokenizer = AutoTokenizer.from_pretrained(modelName)संचालित द्वारा

System, User, और AI के साथ एक साधारण प्रॉम्प्ट टेम्पलेट बनाएँ। हमने मॉडल से Python का उपयोग करके स्टार पैटर्न दिखाने के लिए कोड जनरेट करने को कहा है।

अंतिम प्रॉम्प्ट को tokenizer से पास करें और फिर मॉडल को देकर prediction जनरेट करें। उसके बाद, हम उन predictions को डिकोड करेंगे और प्रतिक्रिया को एक स्ट्रिंग में बदलेंगे। अंत में, प्रतिक्रिया को Markdown शैली में दिखाने के लिए Markdown फ़ंक्शन का उपयोग करेंगे।

from IPython.display import Markdown, display
system =  "You are a skilled software engineer who consistently produces high-quality Python code."
user = "Write a Python code to display text in a star pattern."

prompt = f"System: {system} \n User: {user} \n AI: "
    
inputs = tokenizer(prompt, return_tensors='pt', padding=True, truncation=True).to("cuda")

outputs = model.generate(**inputs, max_length=500, num_return_sequences=1)

text = tokenizer.decode(outputs[0], skip_special_tokens=True)

Markdown(text.split("AI:")[1])संचालित द्वारा

जैसा कि हम देख सकते हैं, Gemma 7b-it ने बहुत अच्छा काम किया है।

आप Kaggle नोटबुक Gemma-7B Simple Inference on GPU को क्लोन करके स्वयं कोड चला सकते हैं।

Google के Gemma को कैसे फाइन-ट्यून करें: चरण-दर-चरण मार्गदर्शिका

इस सेक्शन में, हम hieunguyenminh/roleplay डेटासेट पर Gemma 7b-it मॉडल को फाइन-ट्यून करना सीखेंगे। हम Kaggle GPU P100 को एक्सेलेरेटर के रूप में उपयोग करेंगे।

प्रत्येक स्टेप को विस्तार से समझने के लिए हमारा गाइड An Introductory Guide to Fine-Tuning LLMs पढ़ें।

सेटअप करना

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

%%capture 
%pip install -U bitsandbytes 
%pip install -U transformers 
%pip install -U peft 
%pip install -U accelerate 
%pip install -U trl
%pip install -U datasetsसंचालित द्वारा

वे सभी पैकेज लोड करें जिनका उपयोग हम डेटासेट, मॉडल और tokenizer लोड करने, supervised fine-tuning (SFT) और इन्फ़रेंस करने के लिए करने वाले हैं।

from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    BitsAndBytesConfig,
    HfArgumentParser,
    TrainingArguments,
    pipeline,
    logging,
)
from peft import (
    LoraConfig,
    PeftModel,
    prepare_model_for_kbit_training,
    get_peft_model,
)
import os, torch, wandb
from datasets import load_dataset
from trl import SFTTrainerसंचालित द्वारा

बेस मॉडल और डेटासेट के नाम, साथ ही फाइन-ट्यून किए गए मॉडल का नाम परिभाषित करें, जिसे हम बाद में Hugging Face Hub पर अपलोड करेंगे।

इन वेरिएबल्स का उपयोग विभिन्न चरणों में किया जाएगा, जैसे डेटासेट और मॉडल लोड करना, टोकनाइज़ करना, ट्रेनिंग और मॉडल सेव करना।

base_model = "/kaggle/input/gemma/transformers/7b-it/2"
dataset_name = "hieunguyenminh/roleplay"
new_model = "gemma-7b-it-v2-role-play"संचालित द्वारा

Hugging Face CLI में लॉगिन

हम Kaggle secrets (environment variables) से Hugging Face API key लोड करेंगे।

from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()
secret_hf = user_secrets.get_secret("HUGGINGFACE_TOKEN")संचालित द्वारा

Hugging Face CLI में लॉगिन करने के लिए API key का उपयोग करें। इससे हमें मॉडल तक पहुँच मिलेगी और हम इसे Hugging Face Hub पर सेव भी कर सकेंगे।

!huggingface-cli login --token $secret_hfसंचालित द्वारा

W&B वर्कस्पेस प्रारंभ करना

W&B API key का उपयोग करके weights and biases (W&B) वर्कस्पेस शुरू करें। हम इस वर्कस्पेस का उपयोग मॉडल ट्रेनिंग ट्रैक करने के लिए करेंगे।

secret_wandb = user_secrets.get_secret("wandb")

# Monitoring the LLM
wandb.login(key = secret_wandb)
run = wandb.init(
    project='Fine tuning Gemma 7B', 
    job_type="training", 
    anonymous="allow"
)संचालित द्वारा

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

Hugging Face पर उपलब्ध role play डेटासेट से पहले 1000 पंक्तियाँ प्राप्त करें और `text` कॉलम का सैंपल प्रदर्शित करें।

#Loading the dataset
dataset = load_dataset(dataset_name, split="train[0:1000]")
dataset["text"][100]संचालित द्वारा

हमारा डेटासेट उपयोगकर्ता और सहायक के बीच सेलिब्रिटी शैली पर आधारित सतत वार्तालापों से बना है। यह role-playing है।

मॉडल और tokenizer लोड करना

मेमोरी समस्याओं से बचने के लिए हम मॉडल को 4-बिट precision में BitsAndBytesConfig का उपयोग करके लोड करेंगे। यह Kaggle से सीधे मॉडल लोड करेगा, डाउनलोड की आवश्यकता नहीं होगी।

# Load base model(Gemma 7B-it)
bnbConfig = BitsAndBytesConfig(
    load_in_4bit = True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
)

model = AutoModelForCausalLM.from_pretrained(
        base_model,
        quantization_config=bnbConfig,
        device_map="auto"
)

model.config.use_cache = False # silence the warnings. Please re-enable for inference!
model.config.pretraining_tp = 1
model.gradient_checkpointing_enable()संचालित द्वारा

tokenizer लोड करें और fp16 से संबंधित समस्या को ठीक करने के लिए pad token कॉन्फ़िगर करें।

# Load tokenizer
tokenizer = AutoTokenizer.from_pretrained(base_model)
tokenizer.padding_side = 'right'
tokenizer.pad_token = tokenizer.eos_token
tokenizer.add_eos_token = True
tokenizer.add_bos_token, tokenizer.add_eos_tokenसंचालित द्वारा

एडॉप्टर लेयर जोड़ना

मॉडल में adapter लेयर जोड़कर हम इसे अधिक कुशलता से फाइन-ट्यून कर सकते हैं। पूरे मॉडल को ट्रेन करने की बजाय, हमें केवल adapter लेयर्स के पैरामीटर्स अपडेट करने होते हैं, जिससे ट्रेनिंग प्रक्रिया तेज़ हो जाती है।

हमारे target modules होंगे: 'o_proj', 'q_proj', 'up_proj', 'v_proj', 'k_proj', 'down_proj', और 'gate_proj'।

model = prepare_model_for_kbit_training(model)
peft_config = LoraConfig(
    lora_alpha=16,
    lora_dropout=0.1,
    r=64,
    bias="none",
    task_type="CAUSAL_LM",
    target_modules=['o_proj', 'q_proj', 'up_proj', 'v_proj', 'k_proj', 'down_proj', 'gate_proj']
)
model = get_peft_model(model, peft_config)संचालित द्वारा

मॉडल को ट्रेन करना

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

यदि आप प्रत्येक हाइपरपैरामीटर को बेहतर समझना चाहते हैं, तो Fine-Tuning LLaMA 2 ट्यूटोरियल पढ़ने की सलाह दी जाती है।

training_arguments = TrainingArguments(
    output_dir="./gemma-7b-v2-role-play",
    num_train_epochs=1,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=1,
    optim="paged_adamw_32bit",
    save_strategy="epoch",
    logging_steps=100,
    logging_strategy="steps",
    learning_rate=2e-4,
    fp16=False,
    bf16=False,
    group_by_length=True,
    report_to="wandb"
)संचालित द्वारा

Supervised Fine-tuning (SFT) ट्रेनर सेट करने के लिए, हमें मॉडल, डेटासेट, Lora कॉन्फ़िगरेशन, tokenizer और ट्रेनिंग पैरामीटर्स बतौर आर्ग्युमेंट्स प्रदान करने होंगे।

trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,
    peft_config=peft_config,
    max_seq_length= 512,
    dataset_text_field="text",
    tokenizer=tokenizer,
    args=training_arguments,
    packing= False,
)संचालित द्वारा

अब हम `.train` फ़ंक्शन का उपयोग करके ट्रेनिंग प्रक्रिया चलाएँगे। फाइन-ट्यूनिंग में लगभग 1 घंटा 1 मिनट लगा। ट्रेनिंग लॉस धीरे-धीरे घटा, और आप epochs बढ़ाकर इस लॉस को और कम कर सकते हैं।

trainer.train()संचालित द्वारा

W&B सेशन समाप्त करें और मॉडल को इन्फ़रेंस के लिए कॉन्फ़िगर करें।

wandb.finish()
model.config.use_cache = Trueसंचालित द्वारा

हमने मॉडल को दो प्रकार के GPU एक्सेलेरेटर्स पर ट्रेन किया। लगता है कि P100, T4 2X से दोगुना तेज़ था।

मॉडल सहेजना

अब हम मॉडल adapter को लोकली सेव करेंगे और फिर मॉडल को Hugging Face hub पर अपलोड करेंगे। `push_to_hub` कमांड repo बनाएगा और adapter कॉन्फ़िग तथा adapter वेट्स को hub पर पुश करेगा।

# Save the fine-tuned model
trainer.model.save_pretrained(new_model)
trainer.model.push_to_hub(new_model, use_temp_dir=False)संचालित द्वारा

नोट: यह केवल adapter है; पूरा मॉडल लगभग 18 GB का है जिसे हम सेव नहीं कर रहे।

हम प्रोफ़ाइल पेज पर जाकर और नए मॉडल को चेक करके Hugging Face पर मॉडल देख सकते हैं।

छवि स्रोत

मॉडल इन्फ़रेंस

हमारे फाइन-ट्यून किए गए मॉडल से प्रतिक्रिया जनरेट करने के लिए कुछ चरणों का पालन करना होगा।

पहले, हम role-play डेटासेट फ़ॉर्मेट में एक प्रॉम्प्ट बनाएँगे। फिर, प्रॉम्प्ट को tokenizer से पास करके मॉडल को देंगे ताकि predictions जनरेट हों।

अनुमानित आउटपुट को पठनीय टेक्स्ट में बदलने के लिए, हम इसे tokenizer का उपयोग करके डिकोड करेंगे।

prompt = '''<|system|>Harry Potter is a wizard known for his distinctive lightningshaped scar and his remarkable journey through magic and battles against the dark wizard Voldemort.
<|user|> What is the meaning of hate? 
<|assistant|>'''
    
inputs = tokenizer(prompt, return_tensors='pt', padding=True, truncation=True).to("cuda")

outputs = model.generate(**inputs, max_length=500, num_return_sequences=1)

text = tokenizer.decode(outputs[0], skip_special_tokens=True)

print(text)संचालित द्वारा

बुरा नहीं। यह प्रासंगिक फ़ॉलो-अप प्रश्न भी पूछ रहा है।

इसे एक नए किरदार: माइकल जॉर्डन के साथ फिर आज़माएँ।

prompt = '''<|system|>Michael Jordan an NBA legend known for his competitive drive six championship wins with the Chicago Bulls.
<|user|> What motivates you in the life? 
<|assistant|>'''
    
inputs = tokenizer(prompt, return_tensors='pt', padding=True, truncation=True).to("cuda")

outputs = model.generate(**inputs, max_length=500, num_return_sequences=1)

text = tokenizer.decode(outputs[0], skip_special_tokens=True)

print(text)संचालित द्वारा

मुझे लगता है कि हमने बेस मॉडल को नई प्रतिक्रिया शैली समझाने के लिए अच्छा फाइन-ट्यून किया है।

यदि आपको अपने डेटासेट पर मॉडल को फाइन-ट्यून करने में कठिनाई हो रही है, तो Gemma-7B 4-bit QLoRA Fine-tuning Kaggle नोटबुक देखें।

आप Fine-Tuning OpenAI's GPT-4 ट्यूटोरियल का अनुसरण करके शीर्ष-प्रदर्शन करने वाले और खेल बदल देने वाले मॉडल को फाइन-ट्यून करना भी सीख सकते हैं।

Role Play Adapter के साथ Gemma 7B इन्फ़रेंस

प्रतिक्रिया जनरेट करने के लिए, हम केवल सेव किए गए adapter को लोड नहीं कर सकते। हमें फाइन-ट्यून किए गए adapter को बेस मॉडल (Gemma 7b-it) के साथ मर्ज करना होगा।

इस सेक्शन में, हम सीखेंगे कि बेस मॉडल और adapter को कैसे लोड करें और प्रतिक्रिया जनरेट करने के लिए उन्हें कैसे मर्ज करें।

1. आवश्यक सभी Python लाइब्रेरीज़ इंस्टॉल करें।

%%capture
%pip install -U bitsandbytes
%pip install -U transformers
%pip install -U accelerate
%pip install -U peftसंचालित द्वारा

2. Kaggle secrets से API key लोड करें और Hugging Face CLI में लॉगिन करें।

from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()
secret_hf = user_secrets.get_secret("HUGGINGFACE_TOKEN")संचालित द्वारा

!huggingface-cli login --token $secret_hfसंचालित द्वारा

3. बेस मॉडल और adapter का लोकेशन प्रदान करें।

base_model = "/kaggle/input/gemma/transformers/7b-it/2"
new_model = "kingabzpro/gemma-7b-it-v2-role-play"संचालित द्वारा

4. बेस मॉडल लोड करें।

from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
from peft import PeftModel
import torch



base_model_reload = AutoModelForCausalLM.from_pretrained(
        base_model,
        return_dict=True,
        low_cpu_mem_usage=True,
        torch_dtype=torch.float16,
        device_map="auto",
        trust_remote_code=True,
)संचालित द्वारा

5. adapter को बेस मॉडल के साथ लोड करें और मर्ज करें

model = PeftModel.from_pretrained(base_model_reload, new_model)संचालित द्वारा

6. tokenizer लोड करें

tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "right"संचालित द्वारा

7. प्रतिक्रिया जनरेट करने के लिए प्रॉम्प्ट को tokenizer से और फिर मॉडल से पास करें।

prompt = '''<|system|> Alan Watts's colorful journey explored the depths of philosophy and religion, weaving together Eastern wisdom and Western insights.
<|user|> What does the self actually amount to? 
<|assistant|>'''
    
inputs = tokenizer(prompt, return_tensors='pt', padding=True, truncation=True).to("cuda")

outputs = model.generate(**inputs, max_length=500, num_return_sequences=1)

text = tokenizer.decode(outputs[0], skip_special_tokens=True)

print(text)संचालित द्वारा

Alan Watts ने “self” का अर्थ बहुत अच्छी तरह समझाया है।

बेस मॉडल को adapter के साथ मर्ज करने का कोड स्रोत यहाँ उपलब्ध है: Gemma 7B Inference with Role Play Adopter।

उद्योग विशेषज्ञ का वीडियो ट्यूटोरियल देखने के लिए Fine-Tuning Your Own Llama 2 मॉडल वेबिनार के लिए साइन अप करें।

अंतिम विचार

Google ने वर्षों पहले बड़े भाषा मॉडलों की क्रांति की शुरुआत की थी, लेकिन वह उसका पर्याप्त लाभ नहीं उठा सका। अब कंपनी दोबारा उद्योग की अग्रणी बनने के लिए अपनी रणनीति में आवश्यक बदलाव कर रही है।

हाल में जारी किए गए ओपन-सोर्स मॉडल Gemma के साथ, Google ने AI रिसर्च को बढ़ावा देने की दिशा में कदम उठाया है और इसके बदले में भविष्य में और भी बेहतर मॉडल बना पाएगा।

कंपनी ने अंततः ओपन-सोर्स समुदाय की शक्ति और उससे मिलने वाले फ़ायदों को समझ लिया है। Kaggle, Colab और Vertex AI जैसे क्लाउड प्लेटफ़ॉर्म्स, नेटिव फ्रेमवर्क्स और प्लेटफ़ॉर्म्स का उपयोग करके, Google ओपन-सोर्स समुदाय का अधिकतम लाभ लेने और प्रतिस्पर्धा में आगे रहने का लक्ष्य रखता है।

इस ट्यूटोरियल में, हमने Gemma मॉडलों के बारे में और क्लाउड GPUs तथा TPUs का उपयोग करके उन्हें एक्सेस करना सीखा। हमने role-play डेटासेट का उपयोग करके नवीनतम Gemma 7b-it मॉडल को फाइन-ट्यून करने की प्रक्रिया भी कवर की।

आपकी AI यात्रा का अगला चरण अपना खुद का LLM-आधारित एप्लिकेशन बनाना है। LangChain के साथ LLM एप्लिकेशन कैसे बनाते हैं पर ट्यूटोरियल देखें और अत्याधुनिक AI एप्लिकेशन विकसित करने के लिए एक शक्तिशाली Python फ्रेमवर्क का उपयोग करना सीखें।