हर कोई OpenAI LLM Leaderboard और नए ओपन-सोर्स मॉडलों पर नज़र रख रहा है जो GPT-4 के प्रदर्शन की बराबरी करने का लक्ष्य रखते हैं। हाल ही में जिस मॉडल ने काफी चर्चा बटोरी है, वह है Zephyr-7B।
इस ट्यूटोरियल में, हम Zephyr-7B नामक एक नए भाषा मॉडल के बारे में जानेंगे। हम इसे Transformers पाइपलाइन के जरिए एक्सेस करेंगे और मॉडल को Agent-Instruct डेटासेट पर फाइन-ट्यून करेंगे।
यदि आप कृत्रिम बुद्धिमत्ता में नए हैं, तो AI Fundamentals स्किल ट्रैक देखें। यह आपको तैयार करेगा और भविष्य के AI इंजीनियर बनने की राह पर ले जाएगा।
Zephyr-7B को समझना
Zephyr-7B, WebPilot.AI द्वारा विकसित एक अत्याधुनिक भाषा मॉडल है। यह Zephyr श्रृंखला का हिस्सा है, जिन्हें सहायक की तरह मददगार व्यवहार के लिए प्रशिक्षित किया गया है। Zephyr-7B विभिन्न भाषा-आधारित कार्यों में उत्कृष्ट प्रदर्शन के लिए डिज़ाइन किया गया है, जैसे कि सुसंगत टेक्स्ट जनरेट करना, विभिन्न भाषाओं में अनुवाद करना, महत्वपूर्ण जानकारी का सार प्रस्तुत करना, भावना विश्लेषण करना, और संदर्भ के आधार पर प्रश्नों का उत्तर देना।
Zephyr-7B-β
Zephyr-7B-β इस श्रृंखला का दूसरा मॉडल है। यह Mistral-7B मॉडल का फाइन-ट्यून किया गया संस्करण है, जिसे सार्वजनिक और सिंथेटिक डेटासेट के संयोजन पर Direct Preference Optimization (DPO) का उपयोग करके प्रशिक्षित किया गया है। परिणामस्वरूप, Zephyr-7B-β जटिल प्रश्नों की व्याख्या करने से लेकर लंबे टेक्स्ट अंशों का सार निकालने तक की क्षमताओं का प्रदर्शन करता है।
रिलीज़ के समय, Zephyr-7B-β MT-Bench और AlpacaEval बेंचमार्क पर सबसे उच्च-श्रेणी का 7B चैट मॉडल है। यह मानव-सदृश टेक्स्ट को समझने और जनरेट करने में नई ऊँचाइयों तक पहुँचने के लिए प्राकृतिक भाषा प्रसंस्करण में नवीनतम प्रगति का लाभ उठाता है।
आप Zephyr Chat पर उपलब्ध मुफ्त डेमो आज़माकर इसके बेहतर प्रदर्शन का अनुभव कर सकते हैं।
Zephyr Chat से प्राप्त छवि
Zephyr-7B तक पहुँच
Mistral 7B ट्यूटोरियल की तरह ही, हम Hugging Face transformers का उपयोग करके Zephyr-7B-beta को लोड और उपयोग करेंगे। यह काफी सीधा-सादा है।
नोट: यदि आपको मॉडल लोड करने में समस्या आ रही है, तो Inference Kaggle Notebook देखें।
सबसे पहले, सभी आवश्यक लाइब्रेरी इंस्टॉल करें। सुनिश्चित करें कि आप नवीनतम संस्करण चला रहे हैं, अन्यथा यह काम नहीं करेगा।
!pip install -q -U transformers
!pip install -q -U accelerate
!pip install -q -U bitsandbytesफिर, Pytorch लाइब्रेरी और transformers से pipeline मॉड्यूल लोड करें।
import torch
from transformers import pipelineहम मॉडल नाम, torch_dtype, और device_map आर्ग्युमेंट्स का उपयोग करके टेक्स्ट जनरेशन पाइपलाइन बनाएँगे।
device_map में “auto” का मतलब है कि यह तेज़ी से प्रतिक्रिया जनरेट करने के लिए कई GPU का उपयोग कर सकता है।
torch.bfloat16 (ब्रेन फ़्लोट) 16-बिट फ्लोटिंग-पॉइंट डेटा टाइप है, जिसमें torch.float32 जितना ही एक्सपोनेंट साइज होता है, पर मैन्टिसा साइज कम होता है। इससे गणना तेज़ होती है और मेमोरी उपयोग कम होता है, लेकिन परिशुद्धता और सटीकता भी घट जाती है।
model_name = "HuggingFaceH4/zephyr-7b-beta"
pipe = pipeline(
"text-generation",
model=model_name,
torch_dtype=torch.bfloat16,
device_map="auto",
)हमें पाइपलाइन ऑब्जेक्ट को प्रॉम्प्ट और अन्य आवश्यक आर्ग्युमेंट्स देने हैं और प्रतिक्रिया प्रिंट करनी है।
prompt = "Write a Python function that can clean the HTML tags from the file:"
outputs = pipe(
prompt,
max_new_tokens=300,
do_sample=True,
temperature=0.7,
top_k=50,
top_p=0.95,
)
print(outputs[0]["generated_text"])प्रतिक्रिया उम्मीद से कहीं बेहतर है। इसमें टिप्पणियों के साथ Python कोड भी दिया गया है।
हम सिस्टम प्रॉम्प्ट को Zephyr-7B शैली में देकर मॉडल की प्रतिक्रिया को कस्टमाइज़ भी कर सकते हैं।
हम सूची के रूप में डिक्शनरी देकर प्रॉम्प्ट बनाने के लिए pipe.tokenizer.apply_chat_template फ़ंक्शन का उपयोग करेंगे। डिक्शनरी में चैट असिस्टेंट की भूमिका और व्यवहार, तथा उपयोगकर्ता प्रॉम्प्ट की जानकारी होती है।
messages = [
{
"role": "system",
"content": "You are a skilled software engineer who consistently produces high-quality Python code.",
},
{
"role": "user",
"content": "Write a Python code to display text in a star pattern.",
},
]
prompt = pipe.tokenizer.apply_chat_template(
messages, tokenize=False, add_generation_prompt=True
)अंत में, हम पाइपलाइन ऑब्जेक्ट को प्रॉम्प्ट और अतिरिक्त आर्ग्युमेंट्स देंगे ताकि प्रतिक्रिया जनरेट की जा सके।
outputs = pipe(
prompt,
max_new_tokens=300,
do_sample=True,
temperature=0.7,
top_k=50,
top_p=0.95,
)
print(outputs[0]["generated_text"])
Zephyr-7B ने सबसे अनुकूलित समाधान दिया है, साथ में व्याख्या और फ़ंक्शन का आउटपुट भी। यह कमाल है। लोगों को Python कोड जनरेट करने के लिए इसका उपयोग करना चाहिए।
Zephyr-7B की फाइन-ट्यूनिंग
इस खंड में, हम Kaggle के मुफ्त GPUs का उपयोग करके Zephyr-7B-beta मॉडल को कस्टम डेटासेट पर फाइन-ट्यून करना सीखेंगे। निर्देशों का पालन करके, आप सिर्फ दो घंटे में अपने मॉडल को डिप्लॉयमेंट के लिए तैयार कर सकेंगे।
नोट: यदि आपको मॉडल ट्रेनिंग में समस्या आ रही है, तो Fine-tuning Kaggle Notebook देखें।
सेटअप
सबसे पहले, डेटासेट और मॉडल लोड करने तथा फाइन-ट्यूनिंग के लिए आवश्यक Python लाइब्रेरी इंस्टॉल करें।
%%capture
%pip install -U bitsandbytes
%pip install -U transformers
%pip install -U peft
%pip install -U accelerate
%pip install -U trlफिर, हम आवश्यक मॉड्यूल लोड करेंगे जो सीमित मेमोरी में मॉडल ट्रेन करने में मदद करेंगे और काम आसान बनाएँगे।
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यह खंड Kaggle नोटबुक्स के लिए विशिष्ट है। हमने Hugging Face और Weights & Biases (wandb) के API कीज़ को Kaggle secrets में जोड़ा है। हम उन्हें सुरक्षित रूप से उपयोग करेंगे ताकि मॉडल को Hugging Face Hub पर अपलोड किया जा सके और Weights and Biases सर्वर पर ट्रेनिंग प्रक्रिया को लाइव मॉनिटर किया जा सके।
from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()
secret_hf = user_secrets.get_secret("HUGGINGFACE_TOKEN")
secret_wandb = user_secrets.get_secret("wandb")CLI और API कुंजी का उपयोग करके Hugging Face में लॉगिन करें।
!huggingface-cli login --token $secret_hfइसी तरह, wandb में लॉगिन करें और प्रोजेक्ट शुरू करें।
# Monitoring the LLM
wandb.login(key = secret_wandb)
run = wandb.init(
project='Fine tuning Zephyr 7B',
job_type="training",
anonymous="allow"
)
फाइन-ट्यूनिंग, सेविंग, और Hugging Face हब पर पुश करने के लिए बेस मॉडल, डेटासेट और नए मॉडल के नाम प्रदान करें।
base_model = "HuggingFaceH4/zephyr-7b-beta"
dataset_name = "THUDM/AgentInstruct"
new_model = "zephyr-7b-beta-Agent-Instruct"AgentInstruct डेटासेट
हम डेटासेट लोड करेंगे और फिर format_prompt फ़ंक्शन का उपयोग करके इसे Zephyr-7B प्रॉम्प्ट शैली में बदलेंगे। यह फ़ंक्शन डेटासेट से भूमिका और सामग्री निकालता है और उन्हें ऐसे लंबे स्ट्रिंग्स में बदल देता है जो सिस्टम प्रॉम्प्ट से शुरू होकर डिफ़ॉल्ट निर्देश पर समाप्त होते हैं।
#Importing the dataset
dataset = load_dataset("THUDM/AgentInstruct", split="train")
def format_prompt(sample):
intro = "Below is a conversation between a user and you."
end = "Instruction: Write a response appropriate to the conversation."
try:
formatted_conversations = "\n".join(
f"<{resp['from']}>: {resp['value']}"
for resp in sample["conversations"]
)
sample["text"] = f"{intro}\n\n{formatted_conversations}\n\n{end}"
except (TypeError, KeyError):
raise ValueError("Invalid format of the input sample.")
return sample
dataset = dataset.map(
format_prompt,
remove_columns=["conversations"]
)
dataset["text"][100]
मॉडल और टोकनाइज़र लोड करना
हम Hugging Face से 4-बिट प्रिसिशन वाला मॉडल डाउनलोड और लोड करेंगे ताकि ट्रेनिंग तेज़ी से हो सके। सीमित VRAM वाले GPUs पर फाइन-ट्यूनिंग के लिए यह आवश्यक है। उसके बाद, हम टोकनाइज़र लोड करेंगे और fp16 से संबंधित समस्या को ठीक करने के लिए उसे कॉन्फ़िगर करेंगे।
bnb_config = BitsAndBytesConfig(
load_in_4bit= True,
bnb_4bit_quant_type= "nf4",
bnb_4bit_compute_dtype= torch.bfloat16,
bnb_4bit_use_double_quant= False,
)
model = AutoModelForCausalLM.from_pretrained(
base_model,
load_in_4bit=True,
quantization_config=bnb_config,
torch_dtype=torch.bfloat16,
device_map="auto",
trust_remote_code=True,
)
model.config.use_cache = False
model.config.pretraining_tp = 1
model.gradient_checkpointing_enable()
# Load tokenizer
tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)
tokenizer.padding_side = 'right'
tokenizer.pad_token = tokenizer.eos_token
tokenizer.add_eos_token = True
tokenizer.add_bos_token, tokenizer.add_eos_tokenमॉडल बनाना
अब हम अपने मॉडल में एक एडेप्टर लेयर जोड़ेंगे, जिससे इसे अधिक कुशलता से फाइन-ट्यून किया जा सके। पूरे मॉडल को फाइन-ट्यून करने के बजाय, हम तेज़ ट्रेनिंग के लिए केवल एडेप्टर लेयर के पैरामीटर्स अपडेट करेंगे।
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=['up_proj', 'base_layer', 'down_proj']
)
model = get_peft_model(model, peft_config)मॉडल का प्रशिक्षण
ट्रेनिंग आर्ग्युमेंट्स में सही हाइपरपैरामीटर्स सेट करना महत्वपूर्ण है। आप प्रत्येक के बारे में Fine-Tuning LLaMA 2 ट्यूटोरियल पढ़कर जान सकते हैं।
फिर, हम HuggingFace की TRL लाइब्रेरी का उपयोग करके मॉडल, डेटासेट, Lora कॉन्फ़िगरेशन, टोकनाइज़र, और ट्रेनिंग पैरामीटर्स जैसे आवश्यक घटकों के साथ SFT Trainer बनाएँगे।
अंत में, हम ट्रेनिंग शुरू करेंगे।
#Hyperparamter
training_arguments = TrainingArguments(
output_dir="./results",
num_train_epochs=1,
per_device_train_batch_size=4,
gradient_accumulation_steps=1,
optim="paged_adamw_32bit",
save_steps=25,
logging_steps=25,
learning_rate=2e-4,
weight_decay=0.001,
fp16=False,
bf16=False,
max_grad_norm=0.3,
max_steps=-1,
warmup_ratio=0.03,
group_by_length=True,
lr_scheduler_type="constant",
report_to="wandb"
)
# Setting sft parameters
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,
)
trainer.train()लगभग 1 घंटा 40 मिनट बाद ट्रेनिंग पूरी हुई, और हमने ट्रेनिंग लॉस में धीरे-धीरे कमी देखी।
यह Weights & Biases से अधिक विस्तृत मॉडल मूल्यांकन है।
अब हम मॉडल को सेव करेंगे, wandb इंस्टेंस को समाप्त करेंगे, और मॉडल को Hugging Face Hub पर पुश करेंगे। इससे सेव्ड एडेप्टर फ़ाइल के साथ एक मॉडल रिपॉज़िटरी बन जाएगी।
# Save the fine-tuned model
trainer.model.save_pretrained(new_model)
wandb.finish()
trainer.model.push_to_hub(new_model, use_temp_dir=False)
यहाँ फाइन-ट्यून किया गया मॉडल रिपॉज़िटरी है, जिसे आप इस लिंक से एक्सेस कर सकते हैं: hf.co/kingabzpro/zephyr-7b-beta-Agent-Instruct
अब समय है कि हम अपने फाइन-ट्यून किए गए मॉडल को विभिन्न प्रॉम्प्ट्स पर परखें।
हमने अपने मॉडल से पूछा कि DataCamp के साथ ऑनलाइन Python का उपयोग कैसे करें।
logging.set_verbosity(logging.CRITICAL)
prompt = "How to use Python online with DataCamp?"
pipe = pipeline(task="text-generation", model=model, tokenizer=tokenizer, max_length=200)
result = pipe(prompt)
print(result[0]['generated_text'])हम देखते हैं कि प्रतिक्रिया AgentGPT के समान है—एक स्वचालित AI एजेंट जो विभिन्न एक्सटेंशन्स का उपयोग करके कई कार्य करता है और उन्नत AI मशीनों जैसे परिणाम प्राप्त करता है। ये मशीनें वेब सर्च करना, कोड अपडेट करना, और परीक्षण करना जैसे मानव-समान कार्य कर सकती हैं।
निर्देशों की सूची माँगने के बजाय, आइए DataCamp करियर ट्रैक के बारे में अपने मॉडल से एक सरल प्रश्न पूछें।
prompt = "What is Datacamp Career track?"
result = pipe(prompt)
print(result[0]['generated_text'])हमें उत्तर मिला, पर उसने आगे और प्रश्नों और उत्तरों को जन्म दिया (जो सभी सटीक नहीं हैं), जो रोचक है।
आपकी यात्रा का अगला चरण है इस मॉडल का उपयोग करके अपना AI अनुप्रयोग बनाना। इसके लिए आपको ऐसे टूल चाहिए जो काम आसान बनाएँ। यहाँ 7 आवश्यक जनरेटिव AI टूल्स की सूची है जो उच्च-स्तरीय AI अनुप्रयोग बनाने में आपकी मदद कर सकते हैं।
निष्कर्ष
Zephyr-7B-beta बड़े भाषा मॉडल ने समझने और सटीक प्रतिक्रियाएँ देने की शानदार क्षमता दिखाई है। इस ट्यूटोरियल में, हमने Zephyr-7B के बारे में सीखा और Transformers पाइपलाइन का उपयोग करके इसे कैसे एक्सेस करें, यह जाना। हमने इसे एक कस्टम Agent डेटासेट पर फाइन-ट्यून करना भी सीखा, जिससे इसे तर्क करने और AgentGPT जैसी निर्देशात्मक शैली की प्रतिक्रियाएँ देने की अतिरिक्त क्षमता मिली।
यह गाइड सीमित मेमोरी वाले GPUs पर बड़े भाषा मॉडलों के साथ प्रयोग करने और उन्हें फाइन-ट्यून करने के इच्छुक, सभी स्तरों के मशीन लर्निंग उत्साहियों के लिए एक व्यापक संसाधन है।
Master Large Language Models (LLMs) Concepts कोर्स में नामांकित हों और Zephyr-7B जैसे LLMs के बिल्डिंग ब्लॉक्स, प्रशिक्षण विधियाँ, और तकनीकों के बारे में सीखें।
