Gemma 2 का फाइन-ट्यूनिंग और उसे लोकली इस्तेमाल करना

इस ट्यूटोरियल में, हम मरीज और डॉक्टर की बातचीत वाले डेटासेट पर Gemma 2 मॉडल को फाइन-ट्यून करना सीखेंगे। हम मॉडल को GGUF फॉर्मेट में भी बदलेंगे ताकि उसे लैपटॉप पर ऑफलाइन लोकली उपयोग किया जा सके।

हम पहले Gemma 2 और उसकी पिछली पीढ़ियों की तुलना में हुए सुधारों को समझेंगे, फिर मरीज-डॉक्टर बातचीत वाले डेटासेट पर Gemma 2 मॉडल का फाइन-ट्यूनिंग करेंगे। इसके बाद, सेव किए गए एडाप्टर को बेस मॉडल के साथ मर्ज करेंगे, पूरे मॉडल को Hugging Face Hub पर पुश करेंगे, और Hugging Face Space की मदद से मॉडल को कन्वर्ट व क्वांटाइज़ करेंगे। अंत में, क्वांटाइज़ किया हुआ मॉडल डाउनलोड करेंगे और Jan एप्लिकेशन के साथ लोकली उपयोग करेंगे।

चित्र: लेखक द्वारा

Gemma 2 को समझना

Gemma 2, Google के ओपन बड़े भाषा मॉडल (LLMs) परिवार की नवीनतम रिलीज़ है। यह शोधकर्ताओं और डेवलपर्स के लिए 9 बिलियन (9B) और 27 बिलियन (27B) पैरामीटर्स के आकार में एक व्यावसायिक-अनुकूल लाइसेंस के तहत उपलब्ध है। इसका अर्थ है कि आप इसे अपने निजी डेटासेट पर फाइन-ट्यून कर सकते हैं और बिना किसी प्रतिबंध के प्रोडक्शन में डिप्लॉय कर सकते हैं।

स्रोत: Google launches Gemma 2

Gemma 2 प्रदर्शन और इन्फ्रेंस दक्षता में उल्लेखनीय प्रगति प्रदान करता है। पुन:डिज़ाइन की गई आर्किटेक्चर विभिन्न हार्डवेयर सेटअप पर अत्यंत तेज़ इन्फ्रेंस सुनिश्चित करती है और Hugging Face Transformers, JAX, PyTorch, और TensorFlow जैसे प्रमुख AI फ्रेमवर्क्स के साथ सहज एकीकरण करती है।

Gemma 2 में सुरक्षित और नैतिक AI परिनियोजन के लिए मजबूत सेफ्टी उपाय और टूल्स भी शामिल हैं। यह विभिन्न बेंचमार्क्स पर Llama 3 और Groq-1 से बेहतर प्रदर्शन करता है और Keras 3 के साथ बेहतर इंटीग्रेशन प्रदान करता है, जिससे फाइन-ट्यूनिंग और मॉडल इन्फ्रेंस और भी सहज हो जाता है।

यदि आप Gemma मॉडलों की पहली पीढ़ी के बारे में सीखना चाहते हैं, तो हमारा ट्यूटोरियल Fine Tuning Google Gemma: Enhancing LLMs with Customized Instructions एक बेहतरीन संसाधन है। यह Gemma 7b-it जैसे मॉडलों को विशिष्ट डेटासेट्स और कार्यों पर फाइन-ट्यून करने की विस्तृत मार्गदर्शिका देता है।

Gemma 2 तक पहुँच

इस सेक्शन में, हम मॉडल डाउनलोड करेंगे, उसे 4-बिट क्वांटाइज़ेशन में लोड करेंगे, और फिर GPU पर इन्फ्रेंस चलाएँगे।

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

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

हम Kaggle को डेवलपर एनवायरनमेंट के रूप में इस्तेमाल कर रहे हैं। हमें "Secrets" फ़ंक्शन का उपयोग कर एक environment variable बनाना होगा और फिर उसे सक्रिय करना होगा। इस environment variable में Hugging Face टोकन होगा, जिसे आप Hugging Face वेबसाइट में लॉगिन करके जनरेट कर सकते हैं।

Kaggle Secrets से सुरक्षित रूप से Hugging Face टोकन प्राप्त करें और उसे Hugging Face CLI में लॉगिन के लिए उपयोग करें। लॉगिन करने से हम प्रतिबंधित मॉडल्स और डेटासेट्स डाउनलोड कर पाएँगे।

from huggingface_hub import login
from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()

hf_token = user_secrets.get_secret("HUGGINGFACE_TOKEN")
login(token = hf_token)संचालित द्वारा

Hugging Face पर Gemma 2 मॉडल के रिपॉजिटरी लिंक का उपयोग करके tokenizer लोड करें।
मॉडल को मॉडल नाम, 4-बिट क्वांटाइज़ेशन सेटिंग्स और डिवाइस मैप के साथ लोड करें। यह पहले पूरे मॉडल फाइल्स डाउनलोड करेगा और फिर 4-बिट में लोड करेगा ताकि compute और मेमोरी का बेहतर उपयोग हो सके।

नोट: Gemma 2 9B-It मॉडल बड़ा है, और 16GB GPU मेमोरी के साथ भी हम पूरा मॉडल लोड नहीं कर सकते। इसलिए हम मॉडल को 4-बिट क्वांटाइज़ेशन में लोड कर रहे हैं।

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

modelName = "google/gemma-2-9b-it"

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

tokenizer = AutoTokenizer.from_pretrained(modelName)

model = AutoModelForCausalLM.from_pretrained(
    modelName,
    device_map = "auto",
    quantization_config=bnbConfig
)संचालित द्वारा

सिस्टम निर्देशों और उपयोगकर्ता के प्रश्न का उपयोग कर प्रॉम्प्ट बनाएँ।
tokenizer की मदद से प्रॉम्प्ट्स को टोकन्स में बदलें।
रेस्पॉन्स जनरेट करें और फिर उसे पढ़ने योग्य अंग्रेज़ी टेक्स्ट में डिकोड करें।
Markdown स्टाइल को HTML फॉर्मेट में बदलकर परिणाम दिखाएँ।

from IPython.display import Markdown, display

system =  "You are a skilled software architect who consistently creates system designs for various applications."
user = "Design a system with the ASCII diagram for the customer support application."

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 2 मॉडल ने बहुत अच्छा काम किया है।

यदि आपको ऊपर दिया गया कोड चलाने में समस्या आ रही है, तो कृपया Kaggle Notebook देखें: Gemma 2 Simple Inference on GPU.

LoRA का उपयोग कर Gemma 2 का फाइन-ट्यूनिंग

इस सेक्शन में, हम हेल्थकेयर डेटासेट पर Gemma 2 9B-It मॉडल का फाइन-ट्यूनिंग करेंगे, जिसमें मरीजों और डॉक्टरों के बीच की बातचीत शामिल है। हम मॉडल और tokenizer लोड करेंगे, डेटासेट लोड व कन्वर्ट करेंगे, ट्रेनिंग आर्ग्युमेंट्स के साथ मॉडल सेटअप करेंगे, और Weights and Biases API से मॉडल के प्रदर्शन को ट्रैक करेंगे।

यदि आप फाइन-ट्यूनिंग के सैद्धांतिक पहलुओं को समझना चाहते हैं, तो हमारा गाइड पढ़ें An Introductory Guide to Fine-Tuning LLMs।

1. सेटअप

मेडिकल डेटासेट पर मॉडल को लोड करने, फाइन-ट्यून करने और मूल्यांकन करने के लिए आवश्यक Python पैकेज इंस्टॉल करें।

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

ज़रूरी Python पैकेज और फ़ंक्शंस लोड करें।

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, setup_chat_formatसंचालित द्वारा

Hugging Face CLI में Kaggle Secrets से सेव किए गए API key का उपयोग कर लॉगिन करें।

from huggingface_hub import login
from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()

hf_token = user_secrets.get_secret("HUGGINGFACE_TOKEN")
login(token = hf_token)
संचालित द्वारा

Weights and Biases API key को Kaggle Secrets से लोड करें ताकि मॉडल परफॉर्मेंस ट्रैकिंग के लिए प्रोजेक्ट इनिशिएट किया जा सके।

wb_token = user_secrets.get_secret("wandb")

wandb.login(key=wb_token)
run = wandb.init(
    project='Fine-tune Gemma-2-9b-it on HealthCare Dataset', 
    job_type="training", 
    anonymous="allow"
)संचालित द्वारा

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

base_model = "google/gemma-2-9b-it"
dataset_name = "lavita/ChatDoctor-HealthCareMagic-100k"
new_model = "Gemma-2-9b-it-chat-doctor"संचालित द्वारा

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

GPU के आधार पर डेटा टाइप और attention implementation सेट करें।

if torch.cuda.get_device_capability()[0] >= 8:
    !pip install -qqq flash-attn
    torch_dtype = torch.bfloat16
    attn_implementation = "flash_attention_2"
else:
    torch_dtype = torch.float16
    attn_implementation = "eager"संचालित द्वारा

हमें QLoRA कॉन्फ़िगरेशन बनाना होगा ताकि मॉडल 4-बिट प्रिसिजन में लोड हो, मेमोरी कम लगे और फाइन-ट्यूनिंग तेज़ हो।

# QLoRA config
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch_dtype,
    bnb_4bit_use_double_quant=True,
)
संचालित द्वारा

मॉडल URL, LoRA कॉन्फ़िगरेशन और attention implementation का उपयोग कर Gemma 2 9B-It मॉडल और tokenizer लोड करें।

# Load model
model = AutoModelForCausalLM.from_pretrained(
    base_model,
    quantization_config=bnb_config,
    device_map="auto",
    attn_implementation=attn_implementation
)

# Load tokenizer
tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)संचालित द्वारा

3. लेयर में एडाप्टर जोड़ना

ऐसा Python फ़ंक्शन बनाएँ जो मॉडल का उपयोग करके सभी linear मॉड्यूल्स के नाम निकाले।

import bitsandbytes as bnb

def find_all_linear_names(model):
    cls = bnb.nn.Linear4bit
    lora_module_names = set()
    for name, module in model.named_modules():
        if isinstance(module, cls):
            names = name.split('.')
            lora_module_names.add(names[0] if len(names) == 1 else names[-1])
    if 'lm_head' in lora_module_names:  # needed for 16 bit
        lora_module_names.remove('lm_head')
    return list(lora_module_names)

modules = find_all_linear_names(model)संचालित द्वारा

पूरे मॉडल का फाइन-ट्यूनिंग करने में काफी समय लगेगा, इसलिए प्रशिक्षण प्रक्रिया को तेज़ करने के लिए हम एडाप्टर लेयर बनाएँगे और जोड़ेंगे, जिससे प्रक्रिया तेज़ और मेमोरी-कुशल हो जाएगी।

एडाप्शन लेयर को target मॉड्यूल्स और task टाइप से बनाया जाता है। अगला चरण है मॉडल और tokenizer के लिए चैट फॉर्मेट सेट करना। अंत में, बेस मॉडल को एडाप्टर से जोड़कर Parameter Efficient Fine-Tuning (PEFT) मॉडल बनाते हैं।

# LoRA config
peft_config = LoraConfig(
    r=16,
    lora_alpha=32,
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
    target_modules=modules
)
model, tokenizer = setup_chat_format(model, tokenizer)
model = get_peft_model(model, peft_config)संचालित द्वारा

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

अब हम Hugging Face hub से lavita/ChatDoctor-HealthCareMagic-100k डेटासेट लोड करेंगे। इस डेटासेट में तीन कॉलम हैं:

instruction: सिस्टम निर्देश।
input: मरीज का विस्तृत प्रश्न।
output: मरीज के प्रश्न पर डॉक्टर का उत्तर।

डेटासेट लोड करने के बाद, हम उसे शफल करेंगे और प्रशिक्षण समय कम करने के लिए 1000 सैंपल्स चुनेंगे। अंत में, डिफॉल्ट चैट टेम्पलेट का उपयोग कर चैट फॉर्मेट बनाएँगे और उससे “text” कॉलम तैयार करेंगे।

#Importing the dataset
dataset = load_dataset(dataset_name, split="all")
dataset = dataset.shuffle(seed=65).select(range(1000)) # Only use 1000 samples for quick demo

def format_chat_template(row):
    row_json = [{"role": "system", "content": row["instruction"]},
               {"role": "user", "content": row["input"]},
               {"role": "assistant", "content": row["output"]}]
    row["text"] = tokenizer.apply_chat_template(row_json, tokenize=False)
    return row

dataset = dataset.map(
    format_chat_template,
    num_proc= 4,
)

datasetसंचालित द्वारा

आउटपुट:

Dataset({
    features: ['instruction', 'input', 'output', 'text'],
    num_rows: 1000
})संचालित द्वारा

आइए, पंक्ति 3 के “text” कॉलम की जाँच करें।

dataset['text'][3]संचालित द्वारा

“text” कॉलम में OpenAI शैली में निर्देश, मरीज का प्रश्न और डॉक्टर का उत्तर मौजूद है।

मॉडल का मूल्यांकन करने के लिए, हम डेटासेट को training और test स्प्लिट में बाँटेंगे।

dataset = dataset.train_test_split(test_size=0.1)संचालित द्वारा

5. मॉडल को कम्पाइल करना और ट्रेन करना

अब हम ट्रेनिंग आर्ग्युमेंट्स और SFT पैरामीटर्स सेट करेंगे और फिर ट्रेनिंग प्रक्रिया शुरू करेंगे।

आप अपने एनवायरनमेंट, compute और मेमोरी के अनुसार विभिन्न हाइपरपैरामीटर्स बदल सकते हैं। नीचे दिए गए हाइपरपैरामीटर्स Kaggle Notebook के लिए अनुकूलित हैं। यदि आप वही चीज़ Google Colab पर चलाना चाहते हैं, तो कृपया ट्रेनिंग एल्गोरिद्म्स के साथ प्रयोग करने पर विचार करें।

# Setting Hyperparamter
training_arguments = TrainingArguments(
    output_dir=new_model,
    per_device_train_batch_size=1,
    per_device_eval_batch_size=1,
    gradient_accumulation_steps=2,
    optim="paged_adamw_32bit",
    num_train_epochs=1,
    eval_strategy="steps",
    eval_steps=0.2,
    logging_steps=1,
    warmup_steps=10,
    logging_strategy="steps",
    learning_rate=2e-4,
    fp16=False,
    bf16=False,
    group_by_length=True,
    report_to="wandb"
)
# Setting sft parameters
trainer = SFTTrainer(
    model=model,
    train_dataset=dataset["train"],
    eval_dataset=dataset["test"],
    peft_config=peft_config,
    max_seq_length= 512,
    dataset_text_field="text",
    tokenizer=tokenizer,
    args=training_arguments,
    packing= False,
)

model.config.use_cache = False
trainer.train()संचालित द्वारा

मॉडल को फाइन-ट्यून करने में लगभग 25 मिनट लगे, और जैसा कि हम देख रहे हैं, ट्रेनिंग और वैलिडेशन लॉस धीरे-धीरे कम हुआ है। बेहतर प्रदर्शन के लिए, पूरे डेटासेट पर कम से कम तीन epochs के लिए फाइन-ट्यून करने का प्रयास करें।

शुरुआती लोगों और गैर-तकनीकी व्यक्तियों के लिए फाइन-ट्यूनिंग थोड़ा तकनीकी हो सकता है। यदि आप आसान समाधान ढूँढ रहे हैं, तो Fine-Tuning OpenAI's GPT-4: A Step-by-Step Guide ट्यूटोरियल देखें। यह OpenAI API का उपयोग करते हुए अत्याधुनिक मॉडल को आसान तरीके से फाइन-ट्यून करना कवर करता है।

6. मॉडल मूल्यांकन

हम Weights and Biases एक्सपेरिमेंट को समाप्त करेंगे, जिससे एक मूल्यांकन रिपोर्ट उत्पन्न होगी।

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

विस्तृत रिपोर्ट देखने के लिए, अपने Weights and Biases अकाउंट में जाएँ और "Fine-tune Gemma-2-9b-it on Healthcare Dataset" के प्रोजेक्ट नाम पर क्लिक करें।

स्क्रीनशॉट: wandb.ai

7. बदलाव सहेजना

अब हम फाइन-ट्यून किए गए एडाप्टर को लोकली सेव करेंगे और उसे Hugging Face hub पर भी पुश करेंगे।

trainer.model.save_pretrained(new_model)
trainer.model.push_to_hub(new_model, use_temp_dir=False)संचालित द्वारा

सेव किए हुए एडाप्टर को किसी दूसरे Kaggle नोटबुक में उपयोग करने के लिए, हमें नोटबुक को सेव करना होगा। शीर्ष दाएँ पर “Save Version” पर क्लिक करें। फिर “Quick Save” और “Always save output when creating a Quick Save” चुनें, और “Save” बटन दबाएँ।

यदि आपको कोड चलाने में समस्या आ रही है, तो Kaggle Notebook क्लोन करें और चलाएँ। आपको Kaggle Secrets का उपयोग कर Hugging Face और Weights & Biases API key सेट करना होगा।

यह तय करने के लिए कि आपके उपयोग-प्रकरण में फाइन-ट्यूनिंग बेहतर है या Retrieval-Augmented Generation (RAG), मैं आपको RAG vs Fine-Tuning ब्लॉग पढ़ने की कड़ी सिफारिश करता/करती हूँ।

बेस मॉडल को एडाप्टर के साथ मर्ज करना

अब हम एडाप्टर को बेस मॉडल के साथ मर्ज करेंगे और पूरे मॉडल को Hugging Face hub पर पुश करेंगे।

CPU को एक्सेलेरेटर के रूप में चुनकर नया Kaggle नोटबुक बनाएँ और आवश्यक Python पैकेज इंस्टॉल करें।

हम CPU को एक्सेलेरेटर के रूप में क्यों उपयोग कर रहे हैं? क्या यह धीमा नहीं होगा? हाँ, लेकिन Kaggle पर GPU मशीन हमें केवल 16 GB GPU मेमोरी देती है, जो 7 बिलियन पैरामीटर मॉडल के लिए पर्याप्त है लेकिन 9 बिलियन के लिए नहीं। वहीं, CPU मशीन 30GB देती है, जो बेस मॉडल और एडाप्टर दोनों को लोड करने के लिए पर्याप्त है।

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

Kaggle Secrets से API key प्राप्त करें और Hugging Face CLI में लॉगिन करें।

from huggingface_hub import login
from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()

hf_token = user_secrets.get_secret("HUGGINGFACE_TOKEN")
login(token = hf_token)संचालित द्वारा

सेव किए गए मॉडल तक पहुँचने के लिए, आपको सेव किए गए Kaggle नोटबुक को इनपुट के रूप में इम्पोर्ट करना होगा। ऐसा करने के लिए, ऊपर दाएँ “Add Input” बटन पर क्लिक करें और “Your Work” टैब चुनें। फिर सेव किए गए नोटबुक के प्लस बटन पर क्लिक करें ताकि उसकी सभी फाइल्स एक्सेस की जा सकें।

बेस मॉडल URL को Hugging Face रिपॉजिटरी नाम प्रदान कर सेट करें। साथ ही, एडाप्टर URL को उस लोकल डायरेक्टरी से कॉन्फ़िगर करें जहाँ एडाप्टर सेव है।

base_model_url = "google/gemma-2-9b-it"
new_model_url = "/kaggle/input/fine-tune-gemma-2-9b-it-on-healthcare-dataset/Gemma-2-9b-it-chat-doctor/"संचालित द्वारा

बेस मॉडल URL का उपयोग कर tokenizer और फुल मॉडल लोड करें। सुनिश्चित करें कि डिवाइस “cpu” और dtype “float16” सेट हो।

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, pipeline
from peft import PeftModel
import torch
from trl import setup_chat_format


# Reload tokenizer and model
tokenizer = AutoTokenizer.from_pretrained(base_model_url)

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

नए लोड किए गए बेस मॉडल के लिए चैट फॉर्मेट सेट करें और उसे एडाप्टर के साथ संयोजित करें। अंत में, एडाप्टर को बेस मॉडल में लोड और मर्ज करेंगे।

merge_and_unload() फ़ंक्शन एडाप्टर वेट्स को बेस मॉडल के साथ मर्ज करने और मॉडल को स्टैंडअलोन रूप में उपयोग करने में मदद करेगा।

base_model_reload, tokenizer = setup_chat_format(base_model_reload, tokenizer)
model = PeftModel.from_pretrained(base_model_reload, new_model_url)

model = model.merge_and_unload()संचालित द्वारा

फुल मॉडल और tokenizer को लोकली सेव करें।

model.save_pretrained("Gemma-2-9b-it-chat-doctor")
tokenizer.save_pretrained("Gemma-2-9b-it-chat-doctor")संचालित द्वारा

साथ ही, सभी मॉडल फाइल्स और tokenizer को Hugging Face hub पर पुश करें।

model.push_to_hub("Gemma-2-9b-it-chat-doctor", use_temp_dir=False)
tokenizer.push_to_hub("Gemma-2-9b-it-chat-doctor", use_temp_dir=False)संचालित द्वारा

आप अपने Hugging Face मॉडल रिपॉजिटरी में जाकर सभी फाइल्स देख सकते हैं।

स्रोत: kingabzpro/Gemma-2-9b-it-chat-doctor · Hugging Face

यदि आप CPU का उपयोग कर मॉडल्स मर्ज करने में समस्या का सामना कर रहे हैं, तो Kaggle Notebook देखें।

Hugging Face Space का उपयोग कर क्वांटाइज़ करना

GGUF My Repo Hugging Face Space के साथ, मॉडल कन्वर्ज़न और क्वांटाइज़ेशन आसान और तेज़ हो गया है। आपको बस लॉगिन करना है और मॉडल ID प्रदान करनी है।

स्रोत: GGUF My Repo - a Hugging Face Space by ggml-org

यह आपके लिए एक नया मॉडल रिपॉजिटरी बना देगा, जिसमें क्वांटाइज़ किया हुआ मॉडल फाइल होगा जिसे आप बाद में डाउनलोड कर लोकली उपयोग कर सकते हैं। बस इतना ही सरल।

क्वांटाइज़ेशन के पीछे के सिद्धांत को समझने के लिए हमारा लेख पढ़ें Quantization for Large Language Models (LLMs): Reduce AI Model Sizes Efficiently।

स्रोत: kingabzpro/Gemma-2-9b-it-chat-doctor-Q4_K_M-GGUF · Hugging Face

लेकिन यदि आप खुद llama.cpp स्क्रिप्ट्स चलाकर प्रयोग करना चाहते हैं, तो Fine-Tuning Llama 3 and Using It Locally ट्यूटोरियल देखें।

फाइन-ट्यून मॉडल को लोकली उपयोग करना

क्वांटाइज़्ड मॉडल को लोकली उपयोग करने के लिए:

सबसे पहले आधिकारिक वेबसाइट से Jan एप्लिकेशन डाउनलोड और इंस्टॉल करें।
एप्लिकेशन लॉन्च करें और “Model Hub” में जाएँ। हम ऊपर बाँए Windows “🪟” बटन पर क्लिक करके मेनू एक्सेस कर सकते हैं।
सर्च बार में फाइन-ट्यून मॉडल रिपॉजिटरी लिंक पेस्ट करें और एंटर दबाएँ: "kingabzpro/Gemma-2-9b-it-chat-doctor-Q4_K_M-GGUF"

हम नए मेनू पर ले जाए जाएँगे, जहाँ मॉडल को सीधे डाउनलोड करने का विकल्प होगा।

“Thread” मेनू में जाएँ और दाएँ ऊपर “Model” टैब से फाइन-ट्यून मॉडल चुनें।

AI असिस्टेंट से सवाल पूछना शुरू करें और कस्टमाइज़्ड उत्तर प्राप्त करें।

जैसा कि हम देख रहे हैं, शुरुआती उत्तर उतने अच्छे नहीं हैं। हमें कुछ मॉडल पैरामीटर्स में बदलाव करने की ज़रूरत है। “Model” टैब में जाएँ और निम्न आर्ग्युमेंट्स समायोजित करना शुरू करें:

Stop: <endofstring>, Best wishes, Chat Doctor.
Frequency Penalty: 0.5
Max Tokens: 680

“Assistant” टैब में जाएँ और Instructions को बदलकर यह लिखें: “If you are a doctor, please answer the medical questions based on the patient's description.”
मॉडल को कई प्रश्नों पर आज़माएँ और उच्च-गुणवत्ता व सटीक परिणामों का अनुभव करें।

निष्कर्ष

Gemma 2 एक शानदार मॉडल है, और यदि आप वितरित फाइन-ट्यूनिंग और मॉडल इन्फ्रेंस के लिए Keras 3 फ्रेमवर्क का उपयोग करें तो यह और भी बेहतर हो सकता है। Transformers फ्रेमवर्क की तुलना में आपको तेज़ ट्रेनिंग और इन्फ्रेंस समय मिलेगा।

आप यह सीख सकते हैं कि Keras 3 का उपयोग करते हुए Gemma मॉडल को कैसे फाइन-ट्यून करें और मॉडल इन्फ्रेंस चलाएँ—इसके लिए Fine-Tune and Run Inference on Google's Gemma Model with TPU ट्यूटोरियल का अनुसरण करें।

इस ट्यूटोरियल में, हमने Gemma 2 मॉडलों के बारे में सीखा और Transformer लाइब्रेरी का उपयोग कर उन्हें एक्सेस करना जाना। हमने मॉडल को मरीज-डॉक्टर की बातचीत पर फाइन-ट्यून करना, एडाप्टर को बेस मॉडल के साथ मर्ज करना, पूरे मॉडल को Hugging Face hub पर पुश करना, Hugging Face Space की मदद से मॉडल को कन्वर्ट और क्वांटाइज़ करना, और Jan एप्लिकेशन की मदद से लैपटॉप पर लोकली डाउनलोड व रन करना भी सीखा।

यह एक मज़ेदार प्रोजेक्ट है जिसे AI उत्साही लोगों को ज़रूर आज़माना चाहिए। इससे बड़े भाषा मॉडलों के फाइन-ट्यूनिंग के दौरान आने वाली समस्याओं को ट्रबलशूट करने की आपकी क्षमता बेहतर होगी। प्रमुख चुनौतियाँ अक्सर मेमोरी और compute सीमाएँ तथा लॉस को कम से कम रखना होती हैं।

आप PyTorch और Hugging Face के साथ अपने स्वयं के LLMs विकसित करना भी सीख सकते हैं—इसके लिए DataCamp पर Developing Large Language Models पाठ्यक्रम देखें।

लेखक

Abid Ali Awan

LinkedIn Twitter

एक प्रमाणित डेटा साइंटिस्ट के रूप में, मैं अत्याधुनिक तकनीक का उपयोग करके नवाचारी मशीन लर्निंग अनुप्रयोग बनाने के लिए उत्साहित रहता/रहती हूँ। स्पीच रिकॉग्निशन, डेटा विश्लेषण और रिपोर्टिंग, MLOps, संवादात्मक AI और NLP में मजबूत पृष्ठभूमि के साथ, मैंने ऐसे बुद्धिमान सिस्टम विकसित करने में अपनी विशेषज्ञता निखारी है जो वास्तविक प्रभाव डाल सकें। तकनीकी दक्षता के अलावा, मैं जटिल अवधारणाओं को स्पष्ट और संक्षिप्त भाषा में प्रस्तुत करने में भी निपुण हूँ। परिणामस्वरूप, मैं डेटा साइंस पर एक मांग में रहने वाला/वाली ब्लॉगर बन गया/गई हूँ, और डेटा प्रोफेशनलों के बढ़ते समुदाय के साथ अपने अनुभव और विचार साझा करता/करती हूँ। वर्तमान में, मैं कंटेंट निर्माण और संपादन पर केंद्रित हूँ, बड़े भाषा मॉडलों के साथ काम करते हुए ऐसा प्रभावशाली और आकर्षक कंटेंट विकसित कर रहा/रही हूँ जो व्यवसायों और व्यक्तियों दोनों को अपने डेटा का अधिकतम लाभ उठाने में मदद कर सके।

विषय

कृत्रिम बुद्धिमत्ता

प्रौद्योगिकियाँ

विषय

Gemma 2 का फाइन-ट्यूनिंग और उसे लोकली इस्तेमाल करना

AI के साथ खोजें

Gemma 2 को समझना

Gemma 2 तक पहुँच

LoRA का उपयोग कर Gemma 2 का फाइन-ट्यूनिंग

1. सेटअप

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

3. लेयर में एडाप्टर जोड़ना

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

5. मॉडल को कम्पाइल करना और ट्रेन करना

6. मॉडल मूल्यांकन

7. बदलाव सहेजना

बेस मॉडल को एडाप्टर के साथ मर्ज करना

Hugging Face Space का उपयोग कर क्वांटाइज़ करना

फाइन-ट्यून मॉडल को लोकली उपयोग करना

निष्कर्ष

विषय

शीर्ष LLM कोर्स

LangChain के साथ LLM एप्लिकेशन विकसित करना

LLMOps Concepts

Llama 3 के साथ काम करना

प्रौद्योगिकियाँ

विषय

शीर्ष LLM कोर्स

LangChain के साथ LLM एप्लिकेशन विकसित करना

LLMOps Concepts

Llama 3 के साथ काम करना