Llama 3.2 का फाइन-ट्यूनिंग और लोकल उपयोग: चरण-दर-चरण मार्गदर्शिका

हाल ही में बड़े भाषा मॉडलों (LLMs) का परिदृश्य तेजी से बदल रहा है। नए LLMs को छोटा और स्मार्ट बनाया जा रहा है, जिससे वे बड़े मॉडलों की तुलना में कम महंगे और उपयोग में आसान हो गए हैं। 

Llama 3.2 की रिलीज़ के साथ, अब हमारे पास 1B और 3B जैसे छोटे वेरिएंट उपलब्ध हैं। यद्यपि ये छोटे मॉडल सामान्य कार्यों में बड़े मॉडलों की सटीकता तक नहीं पहुँचते, इन्हें विशेष क्षेत्रों—जैसे ग्राहक सहायता इंटरैक्शंस में भाव-वर्गीकरण—के लिए फाइन-ट्यून कर उत्कृष्ट प्रदर्शन कराया जा सकता है। यह क्षमता इन्हें उन डोमेन में परंपरागत मॉडलों के संभावित विकल्प के रूप में स्थापित करती है।

इस ट्यूटोरियल में, हम Llama 3.2 के vision और lightweight मॉडलों की क्षमताओं को समझेंगे। हम Llama 3.2 3B मॉडल तक पहुँच, उसे एक ग्राहक सहायता डेटासेट पर फाइन-ट्यून करना, और तत्पश्चात उसे Hugging Face hub पर merge व export करना सीखेंगे। अंत में, हम मॉडल को GGUF फ़ॉर्मेट में कन्वर्ट कर Jan एप्लिकेशन की मदद से लोकल रूप से उपयोग करेंगे।

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

छवि: लेखक द्वारा

Llama 3.2 का परिचय

Llama 3.2 के ओपन-सोर्स मॉडलों का परिवार दो प्रकार का है: lightweight और vision मॉडल। Vision मॉडल इमेज़ रीजनिंग और विज़न-लैंग्वेज ब्रिजिंग में माहिर हैं, जबकि lightweight मॉडल बहुभाषी टेक्स्ट जेनरेशन और एज डिवाइसेज़ पर टूल कॉलिंग में अच्छे हैं।

Lightweight मॉडल

Lightweight मॉडल के दो छोटे वेरिएंट हैं: 1B और 3B। ये मॉडल बहुभाषी टेक्स्ट जेनरेशन और टूल कॉलिंग जैसे कार्यों में अच्छे हैं। ये छोटे हैं, यानी इन्हें डिवाइस पर ही चलाया जा सकता है—जिससे डेटा डिवाइस से बाहर नहीं जाता और कम कंप्यूटिंग लागत पर तेज़ टेक्स्ट जेनरेशन संभव होता है।

इन कुशल lightweight मॉडलों को बनाने के लिए Llama 3.2 pruning और knowledge distillation तकनीकों का उपयोग करता है। Pruning से मॉडल का आकार घटाते हुए प्रदर्शन बनाए रखा जाता है, और knowledge distillation में बड़े नेटवर्क छोटे मॉडलों को ज्ञान हस्तांतरित कर उनका प्रदर्शन बेहतर बनाते हैं।

3B मॉडल, Gemma 2 (2.6B) और Phi 3.5-mini जैसे मॉडलों से instruction following, संक्षेपण, प्रॉम्प्ट पुनर्लेखन, और टूल उपयोग जैसे कार्यों में बेहतर प्रदर्शन करता है।

स्रोत: Llama 3.2: ओपन, कस्टमाइज़ेबल मॉडलों के साथ edge AI और vision में क्रांति

Vision मॉडल

Vision मॉडल दो वेरिएंट में आते हैं: 11B और 90B। इन्हें इमेज़ रीजनिंग सपोर्ट के लिए डिज़ाइन किया गया है। 11B और 90B दस्तावेज़, चार्ट और ग्राफ़ समझ सकते हैं तथा image captioning और visual grounding जैसे कार्य कर सकते हैं। इन उन्नत vision क्षमताओं को प्री-ट्रेंड इमेज एन्कोडर्स को भाषा मॉडलों से जोड़कर, और cross-attention लेयर्स वाले adapter weights का उपयोग कर संभव बनाया गया है।

Claude 3 Haiku और GPT-4o mini की तुलना में, Llama 3.2 vision मॉडल्स ने image recognition और विभिन्न visual understanding कार्यों में उत्कृष्ट प्रदर्शन किया है, जिससे वे मल्टीमोडल AI ऐप्लिकेशनों के लिए मज़बूत टूल बनते हैं।

स्रोत: Llama 3.2: ओपन, कस्टमाइज़ेबल मॉडलों के साथ edge AI और vision में क्रांति

Llama 3.2 के उपयोग-मामलों, बेंचमार्क्स, Llama Guard 3, और मॉडल आर्किटेक्चर के बारे में अधिक जानने के लिए हमारा नवीनतम ब्लॉग पढ़ें, Llama 3.2 गाइड: काम करने का तरीका, उपयोग-मामले और अधिक।

Kaggle में Llama 3.2 Lightweight मॉडल्स तक पहुँच

यद्यपि Llama 3.2 मॉडल निःशुल्क और ओपन सोर्स है, फिर भी आपको वेबसाइट पर नियम व शर्तें स्वीकार कर फ़ॉर्म भरना होगा। 

Kaggle प्लेटफ़ॉर्म पर नवीनतम Llama 3.2 मॉडल तक पहुँचने के लिए:

1. llama.com वेबसाइट पर जाएँ और अपनी जानकारी के साथ फ़ॉर्म भरें। Lightweight और vision—दोनों मॉडल चुनें। 

स्रोत: Download Llama

2. Meta | Llama 3.2 मॉडल पेज पर जाएँ और “Submit Form” बटन पर क्लिक करें। 

स्रोत: Meta | Llama 3.2 | Kaggle

3. सभी नियम व शर्तें स्वीकार करें और “Submit” बटन दबाएँ। 

स्रोत: Meta | Llama 3.2 | Kaggle

4. कुछ मिनट प्रतीक्षा करें, जब तक डाउनलोड या नया नोटबुक बनाने का विकल्प न दिखे। Transformers टैब और मॉडल वेरिएंट चुनें, फिर “+ New Notebook” बटन पर क्लिक करें।

5. Kaggle नोटबुक नवीनतम Llama मॉडल के साथ लॉन्च होगा। इसे चलाने के लिए, एक्सेलरेटर को “GPU T4 x2” पर बदलना पर्याप्त है।

6. Transformers और Accelerate Python पैकेज अपडेट करें। 

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

7. Transformers पैकेज की मदद से tokenizer और मॉडल लोड करें। Hugging Face मॉडल रिपॉज़िटरी लिंक देने के बजाय हम लोकल डायरेक्टरी बता रहे हैं जहाँ हमारा मॉडल मौजूद है।

from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline, TextStreamer
import torch


base_model = "/kaggle/input/llama-3.2/transformers/3b-instruct/1"

tokenizer = AutoTokenizer.from_pretrained(base_model)

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

8. pad_token_id सेट करें ताकि चेतावनी संदेश न मिलें।

if tokenizer.pad_token_id is None:
    tokenizer.pad_token_id = tokenizer.eos_token_id
if model.config.pad_token_id is None:
    model.config.pad_token_id = model.config.eos_token_idसंचालित द्वारा

9. मॉडल और tokenizer के साथ text generation पाइपलाइन बनाएं। 

pipe = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
    torch_dtype=torch.float16,
    device_map="auto",
)संचालित द्वारा

10. कस्टम प्रॉम्प्ट के साथ पाइपलाइन चलाएँ। हमारे केस में हम Vincent van Gogh के बारे में पूछ रहे हैं।

messages = [{"role": "user", "content": "Who is Vincent van Gogh?"}]

prompt = tokenizer.apply_chat_template(
    messages, tokenize=False, add_generation_prompt=True
)

outputs = pipe(prompt, max_new_tokens=120, do_sample=True)

print(outputs[0]["generated_text"])संचालित द्वारा

उत्तर काफ़ी सटीक है। 

11. आइए सिस्टम निर्देश दें और देखें कि क्या मॉडल जटिल प्रॉम्प्ट्स को समझकर पालन कर सकता है। हम Markdown को HTML में बदलकर परिणाम दिखाएँगे। 

from IPython.display import Markdown, display

messages = [
    {
        "role": "system",
        "content": "You are a skilled Python developer specializing in database management and optimization.",
    },
    {
        "role": "user",
        "content": "I'm experiencing a sorting issue in my database. Could you please provide Python code to help resolve this problem?",
    },
]

prompt = tokenizer.apply_chat_template(
    messages, tokenize=False, add_generation_prompt=True
)

outputs = pipe(prompt, max_new_tokens=512, do_sample=True)

display(
    Markdown(
            outputs[0]["generated_text"].split(
                "<|start_header_id|>assistant<|end_header_id|>"
            )[1]
        )
    )संचालित द्वारा

परिणाम अत्यंत सटीक है। केवल 3 बिलियन पैरामीटर्स होने के बावजूद मॉडल अच्छा प्रदर्शन करता है।

यदि आपको Llama 3.2 lightweight मॉडल्स तक पहुँचने में दिक्कत आ रही है, कृपया यह नोटबुक देखें, Accessing the Llama 3.2 Lightweight Models।

Kaggle में Llama 3.2 Vision मॉडल्स तक पहुँच

Vision मॉडल तक पहुँचना सरल है, और GPU मेमोरी की चिंता नहीं करनी है, क्योंकि इस गाइड में हम मल्टीपल GPUs का उपयोग करेंगे। 

1. Meta | Llama 3.2 Vision मॉडल पेज पर फ़ॉर्म सबमिट करें। सभी शर्तें स्वीकार करें और “Submit” बटन पर क्लिक करें। 

स्रोत: Meta | Llama 3.2 Vision | Kaggle

2. नीचे स्क्रॉल करें, Transformers टैब और vision मॉडल वेरिएंट चुनें, फिर “+ New Notebook” पर क्लिक करें।

स्रोत: Meta | Llama 3.2 Vision | Kaggle

3. सुनिश्चित करें कि आप “GPU T4 x2” एक्सेलरेटर का उपयोग कर रहे हैं। 
4. Transformers और Accelerate Python पैकेज अपडेट करें।

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

5. इमेज प्रोसेसर और Llama 3.2 vision मॉडल लोड करें। 

import torch
from transformers import MllamaForConditionalGeneration, AutoProcessor

base_model = "/kaggle/input/llama-3.2-vision/transformers/11b-vision-instruct/1"

processor = AutoProcessor.from_pretrained(base_model)

model = MllamaForConditionalGeneration.from_pretrained(
    base_model,
    low_cpu_mem_usage=True,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)संचालित द्वारा

जैसा कि दिख रहा है, यह लगभग 25 GB GPU मेमोरी उपयोग करता है। इसे लैपटॉप या Google Colab के मुफ्त वर्शन पर चलाना संभव नहीं होगा।

6. इमेज लोड करें। हमने ट्यूटोरियल की फ़ीचर्ड इमेज दी है: OpenAI o1-preview ट्यूटोरियल: एक मशीन लर्निंग प्रोजेक्ट बनाना।
7. संदेश लिखें और चैट टेम्पलेट से उसे प्रॉम्प्ट में बदलें। संदेश लिखें और चैट टेम्पलेट से उसे प्रॉम्प्ट में बदलें। 
8. इमेज और टेक्स्ट दोनों को प्रोसेस कर मॉडल को दें ताकि वह प्रतिक्रिया जेनरेट करे। 

import requests
from PIL import Image

url = "https://media.datacamp.com/cms/google/ad_4nxcz-j3ir2begccslzay07rqfj5ttakp2emttn0x6nkygls5ywl0unospj2s0-mrwpdtmqjl1fagh6pvkkjekqey_kwzl6qnodf143yt66znq0epflvx6clfoqw41oeoymhpz6qrlb5ajer4aeniogbmtwtd.png"
image = Image.open(requests.get(url, stream=True).raw)

messages = [
    {"role": "user", "content": [
        {"type": "image"},
        {"type": "text", "text": "Describe the tutorial feature image."}
    ]}
]
input_text = processor.apply_chat_template(messages, add_generation_prompt=True)
inputs = processor(image, input_text, return_tensors="pt").to(model.device)

output = model.generate(**inputs, max_new_tokens=120)
print(processor.decode(output[0]))संचालित द्वारा

परिणामस्वरूप, हमें इमेज का विस्तृत वर्णन मिलता है। यह काफ़ी सटीक है। 

यदि ऊपर दिया कोड चलाने में समस्या आए, तो Accessing the Llama 3.2 Vision Models Kaggle नोटबुक देखें।

Llama 3.2 3B Instruct का फाइन-ट्यूनिंग

इस सेक्शन में हम Transformers लाइब्रेरी का उपयोग कर ग्राहक सहायता डेटासेट पर Llama 3.2 3B Instruct मॉडल को फाइन-ट्यून करना सीखेंगे। हम Kaggle का उपयोग करेंगे ताकि फ्री GPUs मिलें और Colab से अधिक RAM भी। 

1. सेटअप

Kaggle पर नया नोटबुक लॉन्च करें और environment variables सेट करें। हम मॉडल को सेव करने हेतु Hugging Face API और प्रदर्शन ट्रैकिंग के लिए Weights & Biases का उपयोग करेंगे।

सभी आवश्यक 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संचालित द्वारा

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

Weights & Biases में API key से लॉगिन करें और नया प्रोजेक्ट बनाएँ। 

wb_token = user_secrets.get_secret("wandb")

wandb.login(key=wb_token)
run = wandb.init(
    project='Fine-tune Llama 3.2 on Customer Support Dataset', 
    job_type="training", 
    anonymous="allow"
)संचालित द्वारा

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

base_model = "/kaggle/input/llama-3.2/transformers/3b-instruct/1"
new_model = "llama-3.2-3b-it-Ecommerce-ChatBot"
dataset_name = "bitext/Bitext-customer-support-llm-chatbot-training-dataset"संचालित द्वारा

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

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

# Set torch dtype and 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"संचालित द्वारा

लोकल मॉडल डायरेक्टरी देकर मॉडल और tokenizer लोड करें। हमारा मॉडल छोटा है, फिर भी पूरे मॉडल को लोड कर फाइन-ट्यून करना समय लेगा। इसके बजाय, हम मॉडल को 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,
)
# 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. डेटासेट लोड और प्रोसेस करना

हम Hugging Face hub से Bitext-customer-support-llm-chatbot डेटासेट लोड करेंगे। यह एक हाइब्रिड सिंथेटिक डेटासेट है, जिसका उपयोग हम अपना कस्टमाइज़्ड ग्राहक सहायता चैटबॉट बनाने के लिए करेंगे।

हम डेटासेट को लोड करेंगे, शफ़ल करेंगे और केवल 1000 सैम्पल चुनेंगे। हम ट्रेनिंग समय कम करने के लिए छोटे सबसेट पर फाइन-ट्यून कर रहे हैं, लेकिन आप हमेशा पूरा डेटासेट चुन सकते हैं।

अगला, हम सिस्टम निर्देश, उपयोगकर्ता क्वेरी और असिस्टेंट प्रतिक्रिया को मिलाकर "text" कॉलम बनाएँगे। फिर JSON प्रतिक्रिया को चैट फ़ॉर्मैट में बदलेंगे।

#Importing the dataset
dataset = load_dataset(dataset_name, split="train")
dataset = dataset.shuffle(seed=65).select(range(1000)) # Only use 1000 samples for quick demo
instruction = """You are a top-rated customer service agent named John. 
    Be polite to customers and answer all their questions.
    """
def format_chat_template(row):
    
    row_json = [{"role": "system", "content": instruction },
               {"role": "user", "content": row["instruction"]},
               {"role": "assistant", "content": row["response"]}]
    
    row["text"] = tokenizer.apply_chat_template(row_json, tokenize=False)
    return row

dataset = dataset.map(
    format_chat_template,
    num_proc= 4,
)
संचालित द्वारा

जैसा कि दिख रहा है, हमने ग्राहक क्वेरी और असिस्टेंट की प्रतिक्रिया को चैट फ़ॉर्मैट में संयोजित कर दिया है। 

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

4. मॉडल सेट करना

मॉडल से 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)संचालित द्वारा

linear मॉड्यूल नाम का उपयोग कर LoRA एडॉप्टर बनाएँ। हम केवल LoRA एडॉप्टर को फाइन-ट्यून करेंगे और बाकी मॉडल को यथावत छोड़ेंगे—मेमोरी बचाने और तेज़ ट्रेनिंग के लिए। 

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

हम Kaggle वातावरण में चलाने हेतु मॉडल के हाइपरपैरामीटर्स कॉन्फ़िगर कर रहे हैं। हर हाइपरपैरामीटर को समझने के लिए Fine-Tuning Llama 2 ट्यूटोरियल देखें और अपने सिस्टम के अनुरूप बदलाव करें।

#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"
)संचालित द्वारा

अब हम supervised fine-tuning (SFT) ट्रेनर सेट करेंगे और ट्रेन व इवैल्यूएशन डेटासेट, LoRA कॉन्फ़िगरेशन, ट्रेनिंग आर्ग्युमेंट्स, tokenizer और मॉडल प्रदान करेंगे। 

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

5. मॉडल ट्रेनिंग

ट्रेनिंग शुरू करें और ट्रेनिंग व वैलिडेशन लॉस मैट्रिक्स मॉनिटर करें। 

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

ट्रेनिंग लॉस धीरे-धीरे कम हुआ—यह अच्छा संकेत है। 

Weights & Biases रन समाप्त करने पर विस्तृत रन इतिहास जनरेट होता है। 

wandb.finish()संचालित द्वारा

आप हमेशा Weights & Biases डैशबोर्ड पर जाकर मॉडल मैट्रिक्स का विस्तार से अवलोकन कर सकते हैं।

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

फाइन-ट्यून मॉडल का परीक्षण करने के लिए, हम डेटासेट से एक सैंपल प्रॉम्प्ट देंगे। 

messages = [{"role": "system", "content": instruction},
    {"role": "user", "content": "I bought the same item twice, cancel order {{Order Number}}"}]

prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
    
inputs = tokenizer(prompt, return_tensors='pt', padding=True, truncation=True).to("cuda")

outputs = model.generate(**inputs, max_new_tokens=150, num_return_sequences=1)

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

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

फाइन-ट्यून मॉडल ने शैली अपना ली है और सटीक उत्तर दिया है।

7. tokenizer और मॉडल सेव करना

फाइन-ट्यून मॉडल को लोकल रूप से सेव करें और Hugging Face hub पर पुश करें। push_to_hub फ़ंक्शन नया मॉडल रिपॉज़िटरी बनाकर फ़ाइलें वहाँ अपलोड कर देगा। 

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

स्रोत: kingabzpro/llama-3.2-3b-it-Ecommerce-ChatBot

बड़े Llama 3 मॉडलों को फाइन-ट्यून करने के लिए, यह ट्यूटोरियल देखें Text Classification के लिए Llama 3.1 का फाइन-ट्यूनिंग। यह ट्यूटोरियल काफ़ी लोकप्रिय है और आपको पूर्ण कार्य पर LLMs इस्तेमाल करने में मदद करेगा। 

8. नोटबुक सेव करना

ऊपर दाएँ “Save Version” बटन पर क्लिक करें, quick save विकल्प चुनें, और save output विकल्प बदलकर मॉडल फ़ाइल तथा सारा कोड सेव करें।

यह भी देखें: Fine-tune Llama 3.2 on Customer Support Kaggle नोटबुक—कोड सोर्स, परिणाम, और आउटपुट के लिए। 

यह एक भारी कोड-आधारित गाइड है। यदि आप LLMs को फाइन-ट्यून करने के लिए no-code या low-code गाइड ढूँढ रहे हैं, तो देखें LlaMA-Factory WebUI Beginner's Guide: Fine-Tuning LLMs। 

फाइन-ट्यून Llama 3.2 को Merge और Export करना 

हम एक नया नोटबुक बनाएँगे और पहले सेव किए गए नोटबुक को जोड़ेंगे ताकि फाइन-ट्यून LoRA एडॉप्टर तक पहुँच मिल सके—मेमोरी समस्याओं से बचने के लिए। 

सुनिश्चित करें कि आपने बेस मॉडल “Llama 3.2 3B Instruct” भी जोड़ा है।

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

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

मर्ज किए मॉडल को Hugging Face hub पर पुश करने के लिए 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)संचालित द्वारा

बेस मॉडल और फाइन-ट्यून LoRA के लोकेशन दें। हम बेस मॉडल लोड कर उसे एडॉप्टर के साथ merge करेंगे।

# Model
base_model_url = "/kaggle/input/llama-3.2/transformers/3b-instruct/1"
new_model_url = "/kaggle/input/fine-tune-llama-3-2-on-customer-support/llama-3.2-3b-it-Ecommerce-ChatBot/"संचालित द्वारा

tokenizer और पूरा मॉडल लोड करें। 

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

मॉडल और tokenizer पर चैट फ़ॉर्मेट अप्लाई करें। फिर बेस मॉडल को LoRA एडॉप्टर के साथ merge करें।

# Merge adapter with base model
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()संचालित द्वारा

जाँचना हो कि मॉडल सफलतापूर्वक merge हुआ है, तो एक सैंपल प्रॉम्प्ट दें और प्रतिक्रिया जेनरेट करें। 

instruction = """You are a top-rated customer service agent named John. 
    Be polite to customers and answer all their questions.
    """

messages = [{"role": "system", "content": instruction},
    {"role": "user", "content": "I have to see what payment payment modalities are accepted"}]

prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
    
inputs = tokenizer(prompt, return_tensors='pt', padding=True, truncation=True).to("cuda")

outputs = model.generate(**inputs, max_new_tokens=150, num_return_sequences=1)

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

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

जैसा कि दिख रहा है, हमारा फाइन-ट्यून मॉडल पूरी तरह काम कर रहा है। 

tokenizer और मॉडल लोकल रूप से सेव करें। 

new_model = "llama-3.2-3b-it-Ecommerce-ChatBot"

model.save_pretrained(new_model)
tokenizer.save_pretrained(new_model)संचालित द्वारा

मर्ज किए मॉडल और tokenizer को Hugging Face मॉडल रिपॉज़िटरी पर पुश करें।

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

कुछ मिनट बाद, आप अपने Hugging Face रिपॉज़िटरी में सभी मॉडल फ़ाइलें और मेटाडेटा फ़ाइलें देख सकेंगे।

स्रोत: kingabzpro/llama-3.2-3b-it-Ecommerce-ChatBot

आप Merging and Exporting Fine-tuned Llama 3.2 Kaggle नोटबुक में सोर्स कोड भी देख सकते हैं—मर्जिंग और Hugging Face hub पर अपलोडिंग के बारे में अधिक जानने हेतु।

इस प्रोजेक्ट का अगला कदम है पूरे मॉडल को GGUF फ़ॉर्मेट में कन्वर्ट करना और फिर क्वांटाइज़ करना। इसके बाद आप इसे Jan, Msty, या GPT4ALL जैसी अपनी मनपसंद चैट ऐप से लोकल रूप से उपयोग कर सकते हैं। यह सीखने के लिए Fine-Tuning Llama 3 and Using It Locally गाइड देखें—कैसे सभी LLMs को GGUF फ़ॉर्मेट में बदलकर अपने लैपटॉप पर लोकल रूप से चलाएँ।

Merged मॉडल को GGUF फ़ॉर्मेट में कन्वर्ट करना

फाइन-ट्यून मॉडल को लोकल रूप से उपयोग करने के लिए पहले उसे GGUF फ़ॉर्मेट में कन्वर्ट करना होगा। क्यों? क्योंकि यह llama.cpp फ़ॉर्मेट है और सभी डेस्कटॉप चैटबॉट ऐप्लिकेशंस इसे स्वीकार करते हैं। 

Merged मॉडल को llama.ccp फ़ॉर्मेट में कन्वर्ट करना काफ़ी आसान है। हमें बस GGUF My Repo Hugging Face Hub पर जाना है। Hugging Face अकाउंट से साइन इन करें। फाइन-ट्यून मॉडल रिपॉज़िटरी लिंक “kingabzpro/llama-3.2-3b-it-Ecommerce-ChatBot” टाइप करें और “Submit” बटन दबाएँ। 

स्रोत: GGUF My Repo

कुछ ही सेकंड में, मॉडल का क्वांटाइज़्ड वर्शन नए Hugging Face रिपॉज़िटरी में बन जाएगा। 

स्रोत: kingabzpro/llama-3.2-3b-it-Ecommerce-ChatBot-Q4_K_M-GGUF

“Files” टैब पर क्लिक करें और सिर्फ़ GGUF फ़ाइल डाउनलोड करें। 

स्रोत: llama-3.2-3b-it-ecommerce-chatbot-q4_k_m.gguf

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

हम Jan चैटबॉट एप्लिकेशन का उपयोग कर अपना फाइन-ट्यून मॉडल लोकल रूप से चलाएँगे। आधिकारिक वेबसाइट jan.ai पर जाकर ऐप डाउनलोड और इंस्टॉल करें। 

स्रोत: Jan

Settings पर क्लिक करें, “My Models” मेन्यू चुनें, और “Import Model” बटन दबाएँ। फिर मॉडल की लोकल डायरेक्टरी प्रदान करें। 

Chat मेन्यू पर जाएँ और नीचे दिखाए अनुसार फाइन-ट्यून मॉडल चुनें।

दाएँ पैनल में “Assistant” टैब पर क्लिक करें और सिस्टम प्रॉम्प्ट टाइप करें।

System prompt: “You are a top-rated customer service agent named John. Be polite to customers and answer all their questions.”

“Assistant” टैब के बिल्कुल पास “Model” टैब पर क्लिक करें और stop token को “<|eot_id|>” में बदलें।

बस इतना ही। अब आप ग्राहक सहायता AI से अपनी समस्या के बारे में पूछ सकते हैं। 

Prompt: “How do I order multiple items from the same vendor?”

प्रतिक्रिया सटीक और बेहद तेज़ थी—लगभग 102 टोकन प्रति सेकंड।

निष्कर्ष

छोटे LLMs का फाइन-ट्यूनिंग हमें लागत बचाने और इन्फ़रेंस समय बेहतर करने देता है। पर्याप्त डेटा के साथ, आप कुछ कार्यों पर मॉडल प्रदर्शन को GPT-4-mini के क़रीब तक सुधार सकते हैं। संक्षेप में, AI का भविष्य एक ग्रिड में कई छोटे LLMs के साथ master-slave संबंध के उपयोग पर आधारित होगा। 

मास्टर मॉडल प्रारंभिक प्रॉम्प्ट प्राप्त करेगा और यह तय करेगा कि उत्तर जनरेट करने के लिए किस विशेषज्ञ मॉडल का उपयोग करना है। इससे कंप्यूट समय घटेगा, परिणाम बेहतर होंगे, और रनिंग कॉस्ट कम होगी।

इस ट्यूटोरियल में हमने Llama 3.2 और Kaggle में उसकी एक्सेस के बारे में सीखा। हमने lightweight Llama 3.2 मॉडल को ग्राहक सहायता डेटासेट पर फाइन-ट्यून करना भी सीखा, ताकि वह एक विशेष शैली में उत्तर दे और डोमेन-विशिष्ट सटीक जानकारी प्रदान करे। फिर हमने LoRA एडॉप्टर को बेस मॉडल के साथ मर्ज कर पूरा मॉडल Hugging Face Hub पर पुश किया। अंत में, merged मॉडल को GGUF फ़ॉर्मेट में कन्वर्ट कर Jan चैटबॉट एप्लिकेशन के साथ लैपटॉप पर लोकल रूप से उपयोग किया।

हमारा Working with Hugging Face इंटरएक्टिव कोर्स करें—टूल का उपयोग और मॉडलों का फाइन-ट्यूनिंग सीखने के लिए।