Unsloth गाइड: LLM फाइन-ट्यूनिंग का अनुकूलन और गति बढ़ाएँ

क्या आपने कभी मॉडल्स को फाइन-ट्यून करते समय मेमोरी संबंधी समस्याएँ झेली हैं या पाया है कि प्रक्रिया असहनीय रूप से लंबी चलती है? यदि आप बड़े भाषा मॉडल्स (LLMs) को फाइन-ट्यून करने के लिए Transformers लाइब्रेरी से अधिक कुशल और तेज़ समाधान खोज रहे हैं, तो आप सही जगह पर हैं!

इस ट्यूटोरियल में, हम केवल 9GB VRAM का उपयोग करके Llama 3.1 3B मॉडल को फाइन-ट्यून करना सीखेंगे और पारंपरिक Transformers तरीकों की तुलना में 2x तेज़ स्पीड हासिल करेंगे। हम यह भी कवर करेंगे कि तेज़ इन्फ़रेंस कैसे करें, मॉडल को vLLM-समर्थ और GGUF फ़ाइल फ़ॉर्मैट में कैसे कन्वर्ट करें, और कुछ पंक्तियों के कोड से सेव किए गए मॉडल को Hugging Face Hub पर आसानी से कैसे पुश करें।

यदि आप इन अवधारणाओं में नए हैं, तो फाइन-ट्यूनिंग शुरू करने से पहले मज़बूत नींव बनाने के लिए Master Large Language Models (LLMs) Concepts कोर्स ज़रूर करें।

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

Unsloth क्या है?

Unsloth AI बड़े भाषा मॉडल्स को तेज़ी से फाइन-ट्यून करने और एक्सेस करने के लिए बनाया गया एक Python फ़्रेमवर्क है। यह सरल API और Transformers की तुलना में 2x तेज़ परफॉर्मेंस प्रदान करता है। 

मुख्य विशेषताएँ

• सरल API: Unsloth की एक खासियत इसका सरल API है, जो LLMs के फाइन-ट्यूनिंग की जटिलता को काफी कम कर देता है।
• Transformers इंटीग्रेशन: Unsloth, Transformers लाइब्रेरी के ऊपर बनाया गया है, जो LLMs के साथ काम करने के लिए लोकप्रिय विकल्प है। यह इंटीग्रेशन Hugging Face इकोसिस्टम की सशक्त क्षमताओं का लाभ उठाने देता है और साथ ही फाइन-ट्यूनिंग प्रक्रिया को सरल बनाने के लिए अपने सुधार जोड़ता है।
• सीमित संसाधनों की आवश्यकता: आप मुफ्त Colab GPUs या यहाँ तक कि GPU वाले लैपटॉप पर भी बड़े भाषा मॉडल्स को फाइन-ट्यून कर सकते हैं।
• vLLM और GGUF फ़ॉर्मैट में सेव करना: महज एक पंक्ति के कोड से आप क्वांटाइज़्ड मॉडल को मर्ज, कन्वर्ट और Hugging Face hub पर पुश कर सकते हैं। 
• कुशल मेमोरी उपयोग: आप 4-बिट क्वांटाइज़्ड मॉडल लोड कर सकते हैं, उसे फाइन-ट्यून कर सकते हैं और 12 GB GPU VRAM से अधिक उपयोग किए बिना उसे फुल मॉडल से मर्ज कर सकते हैं।

Unsloth का उपयोग करके LLMs तक पहुँचना

Unsloth का उपयोग करके Llama-3.1 मॉडल तक पहुँचना काफी सरल है। हम 16-बिट मॉडल लोड नहीं करेंगे। इसके बजाय, हम Hugging Face पर उपलब्ध 4-बिट संस्करण लोड करेंगे ताकि GPU मेमोरी बचे और इन्फ़रेंस तेज़ हो।

1. Unsloth Python पैकेज इंस्टॉल करें।

%%capture
%pip install unslothसंचालित द्वारा

2. FastLanguageModel फ़ंक्शन का उपयोग करके मॉडल और टोकनाइज़र लोड करें। 

from transformers import TextStreamer
from unsloth import FastLanguageModel

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "unsloth/Meta-Llama-3.1-8B-bnb-4bit"
)संचालित द्वारा

3. Unsloth का तेज़ इन्फ़रेंस सक्षम करें।

FastLanguageModel.for_inference(model)संचालित द्वारा

4. सिस्टम प्रॉम्प्ट, निर्देश, इनपुट और प्रतिक्रिया का उपयोग करके प्रॉम्प्ट शैली लिखें। 
5. प्रॉम्प्ट शैली का उपयोग करके एक नमूना प्रॉम्प्ट बनाएँ। 
6. टेक्स्ट को टोकन्स में और फिर संख्यात्मक रूपांतरण में बदलें।
7. टेक्स्ट स्ट्रीमर सेटअप करें।
8. स्ट्रीमिंग प्रतिक्रिया जनरेट करने के लिए मॉडल का उपयोग करें।

prompt_style = """Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.

### Instruction:
{}

### Input:
{}

### Response:
{}"""


inputs = tokenizer(
    [
        prompt_style.format(
            "You are a professional machine learning engineer",  
            "How would you deal with NaN validation loss?",  
            "", 
        )
    ],
    return_tensors="pt",
).to("cuda")

text_streamer = TextStreamer(tokenizer)
_ = model.generate(**inputs, streamer=text_streamer, max_new_tokens=128)
संचालित द्वारा

हमें NaN वैलिडेशन लॉस को कैसे संभालें, इस पर एक अच्छा उत्तर मिला।

यदि आपको Kaggle में ऊपर दिया गया कोड चलाने में परेशानी हो रही है, तो यहाँ नमूना नोटबुक है: Accessing LLMs using Unsloth.

यदि आप Introduction to LLMs in Python कोर्स करते हैं, तो आप Transformer आर्किटेक्चर की बुनियाद, उसे बनाना, फाइन-ट्यून करना और मूल्यांकन करना सीखेंगे। यह Python का उपयोग करके LLM फाइन-ट्यूनिंग की दुनिया में आपका प्रवेश-द्वार है।

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

इस गाइड में, हम Unsloth का उपयोग करके lighteval/MATH डेटासेट पर Llama 3.1 को फाइन-ट्यून करना सीखेंगे। इस डेटासेट में Markdown फ़ॉर्मैट में समाधानों के साथ बीजगणित की समस्याएँ हैं। पूरा डेटासेट पाँच कठिनाई स्तरों में विभाजित है।

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

1. सेटअप

हम क्लाउड IDE के रूप में Kaggle नोटबुक का उपयोग कर रहे हैं, और मॉडल या डेटा पर काम शुरू करने से पहले हमें नोटबुक सेटअप करना होगा।

1. शुरू करने के लिए, Kaggle secrets का उपयोग करके Hugging Face API और Weights & Biases API के लिए एनवायरनमेंट वेरिएबल सेट करें।

2. एक्सेलरेटर को P100 GPU पर सेट करें।
3. एनवायरनमेंट वेरिएबल लोड करें और API कुंजी का उपयोग करके 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(hf_token)संचालित द्वारा

4. प्रोजेक्ट शुरू करने के लिए API कुंजी का उपयोग करके Weights & Biases में लॉग इन करें। 

import wandb

wb_token = user_secrets.get_secret("wandb")

wandb.login(key=wb_token)
run = wandb.init(
    project='Fine-tune Llama-3.1-8B-bnb-4bit on Math Dataset', 
    job_type="training", 
    anonymous="allow"
)संचालित द्वारा

2. मॉडल और टोकनाइज़र लोड करना

ठीक मॉडल इन्फ़रेंस सेक्शन की तरह, हम Llama 3.1 मॉडल के 4-बिट क्वांटाइज़्ड संस्करण को 2048 अधिकतम सीक्वेंस लंबाई और None डेटा टाइप के साथ लोड करेंगे।

from unsloth import FastLanguageModel
import torch

max_seq_length = 2048 
dtype = None 

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "unsloth/Meta-Llama-3.1-8B-bnb-4bit",
    max_seq_length = max_seq_length,
    dtype = dtype
)संचालित द्वारा

3. डेटासेट लोड करना और प्रोसेस करना

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

प्रॉम्प्ट शैली में सिस्टम प्रॉम्प्ट, निर्देश, और इनपुट व प्रतिक्रिया के लिए प्लेसहोल्डर शामिल हैं। 

prompt_style = """Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.

### Instruction:
You are a math genius who can solve any level of algebraic problems. Please answer the following math question.

### Input:
{}

### Response:
{}"""संचालित द्वारा

इसके बाद, एक फ़ंक्शन बनाएँ जो प्रॉम्प्ट शैली का उपयोग करके गणित के प्रश्नों और समाधानों को इनपुट ले और उन्हें उपयुक्त टेक्स्ट में बदल दे। किसी भी पुनरावृत्ति से बचने के लिए EOS_TOKEN अवश्य जोड़ें।

EOS_TOKEN = tokenizer.eos_token # Must add EOS_TOKEN
def formatting_prompts_func(examples):
    inputs       = examples["problem"]
    outputs      = examples["solution"]
    texts = []
    for input, output in zip(inputs, outputs):
        text = prompt_style.format(input, output) + EOS_TOKEN
        texts.append(text)
    return { "text" : texts, }संचालित द्वारा

डेटासेट से 500 सैंपल लोड करें, डेटासेट पर formatting_prompts_func फ़ंक्शन लागू करें, और टेक्स्ट कॉलम से पहला सैंपल देखें।

from datasets import load_dataset

dataset = load_dataset("lighteval/MATH", split="train[0:500]", trust_remote_code=True)
dataset = dataset.map(
    formatting_prompts_func,
    batched=True,
)
dataset["text"][0]संचालित द्वारा

टेक्स्ट में सिस्टम प्रॉम्प्ट, निर्देश, बीजगणित का प्रश्न और उसका समाधान शामिल है। 

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

हम बेस मॉडल के लिनियर मॉड्यूल्स का उपयोग करके मॉडल में LoRA (Low-Rank Adapter) जोड़ते हैं। 

model = FastLanguageModel.get_peft_model(
    model,
    r=16, 
    target_modules=[
        "q_proj",
        "k_proj",
        "v_proj",
        "o_proj",
        "gate_proj",
        "up_proj",
        "down_proj",
    ],
    lora_alpha=16,
    lora_dropout=0, 
    bias="none", 
   
    use_gradient_checkpointing="unsloth", 
    random_state=3407,
    use_rslora=False, 
    loftq_config=None,
)संचालित द्वारा

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

from trl import SFTTrainer
from transformers import TrainingArguments
from unsloth import is_bfloat16_supported

trainer = SFTTrainer(
    model = model,
    tokenizer = tokenizer,
    train_dataset = dataset,
    dataset_text_field = "text",
    max_seq_length = max_seq_length,
    dataset_num_proc = 2,
    args = TrainingArguments(
        per_device_train_batch_size = 2,
        gradient_accumulation_steps = 4,
        warmup_steps = 5,
        max_steps = 60,
        learning_rate = 2e-4,
        fp16 = not is_bfloat16_supported(),
        bf16 = is_bfloat16_supported(),
        logging_steps = 1,
        optim = "adamw_8bit",
        weight_decay = 0.01,
        lr_scheduler_type = "linear",
        seed = 3407,
        output_dir = "outputs",
    ),
)संचालित द्वारा

5. मॉडल प्रशिक्षण

मॉडल प्रशिक्षण में लगभग 19 मिनट लगे, जो काफ़ी प्रभावशाली है। प्रत्येक चरण के साथ प्रशिक्षण लॉस में उल्लेखनीय कमी आई। 

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

आप Weights & Biases डैशबोर्ड पर जाकर विस्तृत मॉडल परफॉर्मेंस और हार्डवेयर मेट्रिक्स देख सकते हैं।

आप torch और trainer_stats का उपयोग करके अपनी रिपोर्ट भी बना सकते हैं।  

used_memory = round(torch.cuda.max_memory_reserved() / 1024 / 1024 / 1024, 3)
used_memory_for_lora = round(used_memory - start_gpu_memory, 3)
used_percentage = round(used_memory         /max_memory*100, 3)
lora_percentage = round(used_memory_for_lora/max_memory*100, 3)
print(f"{trainer_stats.metrics['train_runtime']} seconds used for training.")
print(f"{round(trainer_stats.metrics['train_runtime']/60, 2)} minutes used for training.")
print(f"Peak reserved memory = {used_memory} GB.")
print(f"Peak reserved memory for training = {used_memory_for_lora} GB.")
print(f"Peak reserved memory % of max memory = {used_percentage} %.")
print(f"Peak reserved memory for training % of max memory = {lora_percentage} %.")संचालित द्वारा

मॉडल 20 मिनट में ट्रेन हुआ, और प्रशिक्षण के दौरान पीक आरक्षित मेमोरी लगभग 3.7 GB थी। यह पारंपरिक तरीके की तुलना में काफ़ी कम है, जिसमें फुल मॉडल लोड करना, उसे क्वांटाइज़ करना और अंत में फाइन-ट्यून करना शामिल होता है। उस स्थिति में कम से कम 15 GB GPU मेमोरी की आवश्यकता होती है।

1207.5478 seconds used for training.
20.13 minutes used for training.
Peak reserved memory = 9.73 GB.
Peak reserved memory for training = 3.746 GB.
Peak reserved memory % of max memory = 61.241 %.
Peak reserved memory for training % of max memory = 23.578 %.संचालित द्वारा

6. फाइन-ट्यूनिंग के बाद मॉडल का परीक्षण

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

जनरेट किया गया टेक्स्ट Markdown फ़ॉर्मैट में था, लेकिन हमने उसे सही गणितीय समीकरणों सहित प्रदर्शित करने के लिए कन्वर्ट कर लिया है।

from IPython.display import display, Markdown

FastLanguageModel.for_inference(model)
inputs = tokenizer(
    [
        prompt_style.format(
            "If the system of equations \begin{align*} 3x+y&=a,\\ 2x+5y&=2a, \end{align*} has a solution $(x,y)$ when $x=2$, compute $a$.", 
            "", 
        )
    ],
    return_tensors="pt",
).to("cuda")

outputs = model.generate(
    input_ids=inputs.input_ids,
    attention_mask=inputs.attention_mask,
    max_new_tokens=250,
    use_cache=True,
)
response = tokenizer.batch_decode(outputs)
Markdown(response[0].split("\n\n### Response:")[1])संचालित द्वारा

जैसा कि हम देख सकते हैं, जनरेट की गई प्रतिक्रिया डेटासेट के अनुरूप है और हमें बीजगणितीय समस्याओं के समाधान प्रदान करती है।

7. मॉडल और टोकनाइज़र सेव करना

आइए अपने फाइन-ट्यून किए गए मॉडल को सेव करें और उसे Hugging Face Hub पर पुश करें, ताकि आप उसे आसानी से साझा या डिप्लॉय कर सकें।

new_model_online = "kingabzpro/Llama-3.1-8B-MATH"
new_model_local = "Llama-3.1-8B-MATH"
model.save_pretrained(new_model_local) # Local saving
tokenizer.save_pretrained(new_model_local) # Local savingसंचालित द्वारा

निम्न कोड Hugging Face पर नया रिपॉज़िटरी बनाएगा और फिर LoRA व टोकनाइज़र को मेटाडेटा सहित पुश करेगा।

model.push_to_hub(new_model_online) # Online saving
tokenizer.push_to_hub(new_model_online) # Online savingसंचालित द्वारा

स्रोत: kingabzpro/Llama-3.1-8B-MATH

यदि आप Unsloth का उपयोग करके LLM को फाइन-ट्यून करते समय समस्याओं का सामना कर रहे हैं, तो Fine-tuning LLMs using Unsloth Kaggle नोटबुक देखें। इसमें स्थिर कोड है जिसे आप स्वयं चलाकर परिणामों को पुन: उत्पन्न कर सकते हैं।

आपकी AI यात्रा का अगला कदम है LLMs का उपयोग करके प्रभावी AI एप्लिकेशन बनाना। अधिक जानकारी के लिए How to Build LLM Applications with LangChain ट्यूटोरियल देखें।

मॉडल मर्ज करना और एक्सपोर्ट करना

LoRa को बेस मॉडल के साथ मर्ज करने के लिए अतिरिक्त VRAM और लोकल स्टोरेज की आवश्यकता होती है। किसी भी सीमा से अधिक जाने से बचने के लिए, हम P100 GPU एक्सेलरेटर के साथ नया Kaggle नोटबुक बनाएँगे। हम API कुंजी तक पहुँच के लिए Hugging Face API भी सक्रिय करेंगे।

1. Unsloth Python पैकेज इंस्टॉल करें।

%%capture
%pip install unslothसंचालित द्वारा

2. Kaggle secrets से API कुंजी लोड करें और 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(hf_token)संचालित द्वारा

3. Hugging Face मॉडल रिपॉज़िटरी लिंक प्रदान करके LoRA और टोकनाइज़र लोड करें। 
4. फास्ट मॉडल इन्फ़रेंस सक्षम करें। 

from unsloth import FastLanguageModel

new_model_name = "kingabzpro/Llama-3.1-8B-MATH"
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = new_model_name, # YOUR MODEL YOU USED FOR TRAINING
    max_seq_length = 2048,
    dtype = None,
    load_in_4bit = True,
)
FastLanguageModel.for_inference(model); संचालित द्वारा

5. पिछले सेक्शन से प्रॉम्प्ट शैली कॉपी-पेस्ट करें। 

prompt_style = """Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.

### Instruction:
You are a math genius who can solve any level of algebraic problem. Please answer the following math question.

### Input:
{}

### Response:
{}"""संचालित द्वारा

6. डेटासेट से दिए गए नमूना गणित प्रश्न के साथ मॉडल का परीक्षण करें ताकि यह जांचा जा सके कि यह अब भी सही तरीके से काम कर रहा है या नहीं।

from IPython.display import display, Markdown

inputs = tokenizer(
    [
        prompt_style.format(
            "Solve the equation $|y-6| + 2y = 9$ for $y$.",  # input
            "",  # output - leave this blank for generation!
        )
    ],
    return_tensors="pt",
).to("cuda")

outputs = model.generate(
    input_ids=inputs.input_ids,
    attention_mask=inputs.attention_mask,
    max_new_tokens=250,
    pad_token_id=tokenizer.eos_token_id,
)
response = tokenizer.batch_decode(outputs)
Markdown(response[0].split("\n\n### Response:")[1])
संचालित द्वारा

मॉडल पूरी तरह से काम कर रहा है और इसे बेस मॉडल के साथ मर्ज करने के लिए तैयार है।

7. अस्थायी डायरेक्टरी बनाएँ और फिर डायरेक्टरी पॉइंटर बदलें। हम यह क्यों कर रहे हैं? Kaggle की working डायरेक्टरी हमें केवल 20 GB देती है, जो पूर्ण मॉडल को मर्ज और पुश करने के लिए पर्याप्त नहीं है। रूट डायरेक्टरी में एक और फ़ोल्डर बनाना हमें 60 GB अस्थायी स्टोरेज तक पहुंचने देगा।

%mkdir ../temp
%cd /kaggle/tempसंचालित द्वारा

8. निम्न कमांड टाइप करके, हम LoRA को बेस मॉडल के साथ मर्ज करेंगे और उसे Hugging Face Hub पर पुश करेंगे। यह तब उपयोगी है जब आप vLLM Python पैकेज का उपयोग करके क्लाउड में अपना मॉडल डिप्लॉय और सर्व करना चाहते हैं।

model.push_to_hub_merged(new_model_name, tokenizer, save_method = "merged_16bit")संचालित द्वारा

9. यदि आप फाइन-ट्यून किया हुआ मॉडल लोकली उपयोग करना चाहते हैं, तो आप इसे आसानी से llama.cpp फ़ॉर्मेट में कन्वर्ट कर सकते हैं, फिर इसे क्वांटाइज़ करें और Hugging Face hub पर पुश करें। 

model.push_to_hub_gguf(new_model_name, tokenizer, quantization_method = "q4_k_m")संचालित द्वारा

पूर्ण 16-बिट मॉडल, एडेप्टर, और क्वांटाइज़्ड GGUF फ़ाइलें आपके मॉडल रिपॉज़िटरी पर उपलब्ध हैं। फाइन-ट्यून किए हुए मॉडल को लोकली उपयोग करने के लिए, बस क्वांटाइज़्ड GGUF फ़ाइल डाउनलोड करें और इसे Jan, Misty, GPT4ALL, या Ollama के साथ उपयोग करना शुरू करें।

इस Fine-tuning Llama 3.2 and Using It Locally: A Step-by-Step Guide ट्यूटोरियल का अनुसरण करें ताकि आप कस्टमर सपोर्ट डेटासेट पर Llama 3.2 मॉडल को फाइन-ट्यून करना, मॉडल को Hugging Face Hub पर मर्ज और एक्सपोर्ट करना, और फाइन-ट्यून मॉडल को GGUF फ़ॉर्मेट में कन्वर्ट करना सीख सकें, जिससे इसे Jan एप्लिकेशन के साथ लोकली उपयोग किया जा सके।

स्रोत: kingabzpro/Llama-3.1-8B-MATH

यदि आप LoRA को बेस मॉडल के साथ लोड और मर्ज करते समय समस्याओं का सामना कर रहे हैं, तो कृपया अतिरिक्त सहायता के लिए यह Merging LoRA Adopter with Unsloth Kaggle नोटबुक देखें। 

मैं आपको यह ब्लॉग भी पढ़ने की सलाह देता/देती हूँ: 12 LLM Projects For All Levels। इसमें शुरुआती, मध्यम स्तर के शिक्षार्थियों, अंतिम-वर्ष के शोधार्थियों और विशेषज्ञों के लिए LLM प्रोजेक्ट्स की सूची शामिल है।

निष्कर्ष

इस ट्यूटोरियल में, हमने कम कंप्यूटिंग संसाधनों का उपयोग करके Llama 3.1 3B मॉडल को प्रभावी ढंग से फाइन-ट्यून करना सीखा और पारंपरिक तरीकों की तुलना में 2x तेज़ गति प्राप्त की।

हमने तेज़ मॉडल इन्फरेंस चलाने, LoRA को बेस मॉडल के साथ मर्ज करने, और उसे Hugging Face hub पर पुश करने का तरीका भी सीखा। 

इसके अतिरिक्त, हमने मॉडल को llama.cpp फ़ॉर्मेट में कन्वर्ट किया और उसे क्वांटाइज़ किया ताकि फाइन-ट्यून मॉडल को Jan या GPT4ALL एप्लिकेशन का उपयोग करके लैपटॉप पर लोकली आसानी से चलाया जा सके।

मॉडल के प्रदर्शन को बेहतर बनाने के लिए, हम अत्यधिक अनुशंसा करते हैं कि आप मॉडल को पूर्ण डेटासेट पर फाइन-ट्यून करें, हाइपरपैरामीटर्स का अनुकूलन करें, और प्रॉम्प्ट स्टाइल पर कार्य करें। फाइन-ट्यूनिंग के बाद भी, आप फ़ंक्शन कॉलिंग और RAG पाइपलाइनों का उपयोग करके एआई एप्लिकेशनों के प्रदर्शन में कई तरीकों से सुधार कर सकते हैं।

यह जानें कि आपकी विशेष आवश्यकताओं के लिए कौन सा समाधान बेहतर है, इस RAG vs Fine-Tuning: A Comprehensive Tutorial with Practical Example गाइड का अनुसरण करके। इसमें आपके लिए एक सैंपल कोड शामिल है जिसे आप अपने डेटासेट पर आज़मा सकते हैं और परिणामों की तुलना कर सकते हैं।