केवल गाइड जिसे आपको ल्लामा 3 या किसी अन्य ओपन-सोर्स मॉडल को फाइन-ट्यून करने की आवश्यकता है

बड़े भाषा मॉडल (LLM) जैसे ल्लामा 3 को फाइन-ट्यून करने में एक पूर्व-प्रशिक्षित मॉडल को विशिष्ट कार्यों के लिए डोमेन-विशिष्ट डेटासेट का उपयोग करके अनुकूलित करना शामिल है। यह प्रक्रिया मॉडल के पूर्व-मौजूदा ज्ञान का लाभ उठाती है, जिससे यह प्रशिक्षण से तुलना में कुशल और लागत-प्रभावी होता है। इस गाइड में, हम ल्लामा 3 को QLoRA (क्वांटाइज्ड LoRA) का उपयोग करके फाइन-ट्यून करने के चरणों के माध्यम से चलेंगे, जो एक पैरामीटर-कुशल विधि है जो मेमोरी का उपयोग और गणना लागत को कम करती है।

फाइन-ट्यूनिंग का अवलोकन

फाइन-ट्यूनिंग में कई महत्वपूर्ण चरण शामिल हैं:

1. पूर्व-प्रशिक्षित मॉडल का चयन: अपने वांछित आर्किटेक्चर के साथ संरेखित करने वाले एक बेस मॉडल का चयन करें।
2. एक प्रासंगिक डेटासेट का संग्रह: अपने कार्य के लिए विशिष्ट एक डेटासेट का संग्रह और प्री-प्रोसेसिंग करें।
3. फाइन-ट्यूनिंग: मॉडल को डेटासेट का उपयोग करके विशिष्ट कार्यों पर इसके प्रदर्शन में सुधार करने के लिए अनुकूलित करें।
4. मूल्यांकन: गुणात्मक और मात्रात्मक मेट्रिक्स दोनों का उपयोग करके फाइन-ट्यून किए गए मॉडल का मूल्यांकन करें।

संकल्पनाएं और तकनीकें

बड़े भाषा मॉडल को फाइन-ट्यून करना

पूर्ण फाइन-ट्यूनिंग

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

पैरामीटर-कुशल फाइन-ट्यूनिंग (PEFT)

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

लो-रैंक अनुकूलन (LoRA) और क्वांटाइज्ड LoRA (QLoRA)

LoRA केवल कुछ कम-रैंक मैट्रिक्स को फाइन-ट्यून करता है, जबकि QLoRA इन मैट्रिक्स को मेमोरी फुटप्रिंट को और कम करने के लिए क्वांटाइज़ करता है।

फाइन-ट्यूनिंग विधियां

1. पूर्ण फाइन-ट्यूनिंग: इसमें कार्य-विशिष्ट डेटासेट पर मॉडल के सभी पैरामीटर को प्रशिक्षित करना शामिल है। जबकि यह विधि बहुत प्रभावी हो सकती है, यह गणना रूप से महंगी भी है और महत्वपूर्ण मेमोरी की आवश्यकता होती है।
2. पैरामीटर-कुशल फाइन-ट्यूनिंग (PEFT): PEFT मॉडल के केवल एक उपसेट पैरामीटर को अपडेट करता है, जिससे यह अधिक मेमोरी-कुशल होता है। LoRA और QLoRA जैसी तकनीकें इस श्रेणी में आती हैं।

LoRA क्या है?

फाइन-ट्यूनिंग विधियों की तुलना: QLORA LoRA को 4-बिट सटीकता क्वांटाइजेशन और पेज्ड ऑप्टिमाइज़र के साथ बढ़ाता है

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

LoRA के मुख्य लाभ:

• मेमोरी दक्षता: LoRA मॉडल के पूरे मॉडल के बजाय केवल छोटे मैट्रिक्स को फाइन-ट्यून करके मेमोरी फुटप्रिंट को कम करता है।
• पुन: उपयोगिता: मूल मॉडल अपरिवर्तित रहता है, और इसके साथ कई LoRA एडाप्टर का उपयोग किया जा सकता है, जो कई कार्यों को कम मेमोरी आवश्यकताओं के साथ संभालने की सुविधा प्रदान करता है।

क्वांटाइज्ड LoRA (QLoRA) क्या है?

QLoRA LoRA को एक कदम आगे ले जाता है bằng मॉडल के वजनों को कम सटीकता (उदाहरण के लिए, 4-बिट के बजाय 8-बिट) में क्वांटाइज़ करके। इससे मेमोरी उपयोग और स्टोरेज आवश्यकताओं में और कमी आती है जबकि एक तुलनीय स्तर की प्रभावशीलता बनाए रखता है।

QLoRA के मुख्य लाभ:

• अधिक मेमोरी दक्षता: वजनों को क्वांटाइज़ करके, QLoRA मॉडल के मेमोरी और स्टोरेज आवश्यकताओं को महत्वपूर्ण रूप से कम करता है।
• प्रदर्शन बनाए रखना: कम सटीकता के बावजूद, QLoRA पूर्ण-सटीकता वाले मॉडल के प्रदर्शन स्तर को बनाए रखता है।

कार्य-विशिष्ट अनुकूलन

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

फाइन-ट्यूनिंग का व्यावहारिक अनुप्रयोग

पूर्ण फाइन-ट्यूनिंग बनाम पीईएफटी

• पूर्ण फाइन-ट्यूनिंग: इसमें पूरे मॉडल को प्रशिक्षित करना शामिल है, जो गणना रूप से महंगा हो सकता है और महत्वपूर्ण मेमोरी की आवश्यकता होती है।
• पीईएफटी (LoRA और QLoRA): पीईएफटी मॉडल के केवल एक उपसेट पैरामीटर को अपडेट करता है, जिससे यह अधिक मेमोरी-कुशल होता है और विनाशकारी भूलने से बचाता है, जो एक अधिक कुशल विकल्प है।

कार्यान्वयन चरण

1. परिवेश सेटअप: आवश्यक लाइब्रेरी स्थापित करें और गणना परिवेश सेट करें।
2. डेटासेट लोड और प्री-प्रोसेसिंग: डेटासेट लोड करें और इसे मॉडल के लिए उपयुक्त प्रारूप में प्री-प्रोसेस करें।
3. पूर्व-प्रशिक्षित मॉडल लोड: बेस मॉडल लोड करें, यदि QLoRA का उपयोग कर रहे हैं तो क्वांटाइजेशन कॉन्फ़िगरेशन के साथ।
4. टोकनाइजेशन: डेटासेट को प्रशिक्षण के लिए तैयार करने के लिए टोकनाइज़ करें।
5. प्रशिक्षण: तैयार डेटासेट का उपयोग करके मॉडल को फाइन-ट्यून करें।
6. मूल्यांकन: गुणात्मक और मात्रात्मक मेट्रिक्स का उपयोग करके मॉडल के प्रदर्शन का मूल्यांकन करें।

ल्लामा 3 या किसी अन्य ओपन-सोर्स मॉडल को फाइन-ट्यून करने के लिए चरण-दर-चरण गाइड

परिवेश सेटअप

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

1. आवश्यक लाइब्रेरी स्थापित करें

सुनिश्चित करें कि आपके पास आवश्यक लाइब्रेरी स्थापित हैं:

!pip install -qqq -U bitsandbytes transformers peft accelerate datasets scipy einops evaluate trl rouge_score

2. लाइब्रेरी आयात करें और परिवेश सेट करें

import os
import torch
from datasets import load_dataset
from transformers import (
AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, TrainingArguments,
pipeline, HfArgumentParser
)
from trl import ORPOConfig, ORPOTrainer, setup_chat_format, SFTTrainer
from tqdm import tqdm
import gc
import pandas as pd
import numpy as np
from huggingface_hub import interpreter_login

# Weights and Biases लॉगिंग को अक्षम करें
os.environ['WANDB_DISABLED'] = "true"
interpreter_login()

3. डेटासेट लोड करें

हम इस ट्यूटोरियल के लिए DialogSum डेटासेट का उपयोग करेंगे:

डेटासेट को मॉडल की आवश्यकताओं के अनुसार प्री-प्रोसेस करें, जिसमें उपयुक्त टेम्पलेट्स लागू करना और डेटा प्रारूप को फाइन-ट्यूनिंग के लिए उपयुक्त सुनिश्चित करना शामिल है (Hugging Face)​​ (DataCamp)​.

dataset_name = "neil-code/dialogsum-test"
dataset = load_dataset(dataset_name)

डेटासेट संरचना का निरीक्षण करें:

print(dataset['test'][0])

4. BitsAndBytes कॉन्फ़िगरेशन बनाएं

मॉडल को 4-बिट प्रारूप में लोड करने के लिए:

compute_dtype = getattr(torch, "float16")
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type='nf4',
bnb_4bit_compute_dtype=compute_dtype,
bnb_4bit_use_double_quant=False,
)

5. पूर्व-प्रशिक्षित मॉडल लोड करें

इस ट्यूटोरियल के लिए Microsoft के Phi-2 मॉडल का उपयोग करें:

model_name = 'microsoft/phi-2'
device_map = {"": 0}
original_model = AutoModelForCausalLM.from_pretrained(
model_name,
device_map=device_map,
quantization_config=bnb_config,
trust_remote_code=True,
use_auth_token=True
)

6. टोकनाइजेशन

टोकनाइज़र को कॉन्फ़िगर करें:

tokenizer = AutoTokenizer.from_pretrained(
model_name,
trust_remote_code=True,
padding_side="left",
add_eos_token=True,
add_bos_token=True,
use_fast=False
)
tokenizer.pad_token = tokenizer.eos_token

ल्लामा 3 या अन्य मॉडल को फाइन-ट्यून करना

जब ल्लामा 3 या किसी अन्य राज्य-ऑफ-द-आर्ट ओपन-सोर्स एलएलएम को फाइन-ट्यून किया जाता है, तो विशिष्ट विचार और समायोजन आवश्यक होते हैं ताकि यह सुनिश्चित किया जा सके कि विशिष्ट कार्यों पर ऑप्टिमल प्रदर्शन प्राप्त किया जा सके। यहाँ विभिन्न मॉडल, जिनमें ल्लामा 3, जीपीटी-3 और मिस्ट्रल शामिल हैं, के लिए विस्तृत चरण और अंतर्दृष्टि दी गई हैं।

5.1 ल्लामा 3 का उपयोग करना

मॉडल चयन:

• सुनिश्चित करें कि आपके पास हगिंग फ़ेस मॉडल हब से सही मॉडल पहचानकर्ता है। उदाहरण के लिए, ल्लामा 3 मॉडल को हगिंग फ़ेस पर meta-llama/Meta-Llama-3-8B के रूप में पहचाना जा सकता है।
• मॉडल जैसे ल्लामा 3 के लिए आवश्यक होने पर हगिंग फ़ेस खाते में लॉग इन करें और पहुंच का अनुरोध करें (Hugging Face)​​

टोकनाइजेशन:

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

मेमोरी और गणना:

• ल्लामा 3 जैसे बड़े मॉडल को फाइन-ट्यून करने के लिए महत्वपूर्ण गणना संसाधनों की आवश्यकता होती है। सुनिश्चित करें कि आपका परिवेश, जैसे एक शक्तिशाली जीपीयू सेटअप, मेमोरी और प्रोसेसिंग आवश्यकताओं को संभाल सकता है। सुनिश्चित करें कि परिवेश मेमोरी आवश्यकताओं को संभाल सकता है, जिसे QLoRA जैसी तकनीकों का उपयोग करके मेमोरी फुटप्रिंट को कम करने से कम किया जा सकता है (Hugging Face Forums)

उदाहरण:

model_name = 'meta-llama/Meta-Llama-3-8B'
device_map = {"": 0}
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.float16,
bnb_4bit_use_double_quant=True,
)
original_model = AutoModelForCausalLM.from_pretrained(
model_name,
device_map=device_map,
quantization_config=bnb_config,
trust_remote_code=True,
use_auth_token=True
)

टोकनाइजेशन:

विशिष्ट उपयोग के मामले और मॉडल आवश्यकताओं के आधार पर, सुनिश्चित करें कि टोकनाइज़र सही ढंग से कॉन्फ़िगर किया गया है। उदाहरण के लिए, use_fast=True बेहतर प्रदर्शन के लिए अनुशंसित है (Hugging Face)​​ (Weights & Biases)​।

tokenizer = AutoTokenizer.from_pretrained(
model_name,
trust_remote_code=True,
padding_side="left",
add_eos_token=True,
add_bos_token=True,
use_fast=False
)
tokenizer.pad_token = tokenizer.eos_token

5.2 अन्य लोकप्रिय मॉडल (जैसे जीपीटी-3, मिस्ट्रल)

मॉडल चयन:

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

टोकनाइजेशन:

• ल्लामा 3 के समान, सुनिश्चित करें कि टोकनाइज़र मॉडल के साथ संगत है और आवश्यक सुविधाओं का समर्थन करता है।

मेमोरी और गणना:

• प्रत्येक मॉडल की अलग-अलग मेमोरी आवश्यकताएं हो सकती हैं। अपने परिवेश सेटअप को उसी के अनुसार समायोजित करें।

जीपीटी-3 के लिए उदाहरण:

model_name = 'openai/gpt-3'
device_map = {"": 0}
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.float16,
bnb_4bit_use_double_quant=True,
)
original_model = AutoModelForCausalLM.from_pretrained(
model_name,
device_map=device_map,
quantization_config=bnb_config,
trust_remote_code=True,
use_auth_token=True
)

मिस्ट्रल के लिए उदाहरण:

model_name = 'mistral-7B'
device_map = {"": 0}
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.float16,
bnb_4bit_use_double_quant=True,
)
original_model = AutoModelForCausalLM.from_pretrained(
model_name,
device_map=device_map,
quantization_config=bnb_config,
trust_remote_code=True,
use_auth_token=True
)

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

ल्लामा 3 टोकनाइज़र उदाहरण:

tokenizer = AutoTokenizer.from_pretrained(
model_name,
trust_remote_code=True,
padding_side="left",
add_eos_token=True,
add_bos_token=True,
use_fast=False
)
tokenizer.pad_token = tokenizer.eos_token

जीपीटी-3 और मिस्ट्रल टोकनाइज़र उदाहरण:

tokenizer = AutoTokenizer.from_pretrained(
model_name,
use_fast=True
)

7. मॉडल का शून्य-शॉट अनुमान के साथ परीक्षण करें

बेस मॉडल का एक नमूना इनपुट के साथ मूल्यांकन करें:

from transformers import set_seed

set_seed(42)
index = 10
prompt = dataset['test'][index]['dialogue']
formatted_prompt = f"Instruct: Summarize the following conversation.\n{prompt}\nOutput:\n"

# आउटपुट उत्पन्न करें
def gen(model, prompt, max_length):
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_length=max_length)
return tokenizer.batch_decode(outputs, skip_special_tokens=True)

res = gen(original_model, formatted_prompt, 100)
output = res[0].split('Output:\n')[1]

print(f'INPUT PROMPT:\n{formatted_prompt}')
print(f'MODEL GENERATION - ZERO SHOT:\n{output}')

8. डेटासेट को प्री-प्रोसेस करें

संवाद-सारांश जोड़े को प्रॉम्प्ट में बदलें:

def create_prompt_formats(sample):
blurb = "Below is an instruction that describes a task. Write a response that appropriately completes the request."
instruction = "### Instruct: Summarize the below conversation."
input_context = sample['dialogue']
response = f"### Output:\n{sample['summary']}"
end = "### End"

parts = [blurb, instruction, input_context, response, end]
formatted_prompt = "\n\n".join(parts)
sample["text"] = formatted_prompt
return sample

dataset = dataset.map(create_prompt_formats)

स्वरूपित डेटासेट को टोकनाइज़ करें:

def preprocess_batch(batch, tokenizer, max_length):
return tokenizer(batch["text"], max_length=max_length, truncation=True)

max_length = 1024
train_dataset = dataset["train"].map(lambda batch: preprocess_batch(batch, tokenizer, max_length), batched=True)
eval_dataset = dataset["validation"].map(lambda batch: preprocess_batch(batch, tokenizer, max_length), batched=True)

मॉडल को पैरामीटर-कुशल प्रशिक्षण के लिए तैयार करें:

original_model = prepare_model_for_kbit_training(original_model)

हाइपरपैरामीटर मॉडल के प्रदर्शन को अनुकूलित करने में एक महत्वपूर्ण भूमिका निभाते हैं। यहाँ कुछ प्रमुख हाइपरपैरामीटर दिए गए हैं जिन पर विचार किया जाना चाहिए:

1. लर्निंग रेट: मॉडल के पैरामीटर को अपडेट करने की गति को नियंत्रित करता है। एक उच्च लर्निंग रेट तेजी से अभिसरण का कारण बन सकता है लेकिन ऑप्टिमल समाधान से चूक सकता है। एक कम लर्निंग रेट सुनिश्चित अभिसरण सुनिश्चित करता है लेकिन अधिक युगों की आवश्यकता हो सकती है।
2. बैच आकार: एक बार में प्रोसेस किए जाने वाले नमूनों की संख्या। बड़े बैच आकार स्थिरता में सुधार कर सकते हैं लेकिन अधिक मेमोरी की आवश्यकता होती है। छोटे बैच आकार प्रशिक्षण प्रक्रिया में अधिक शोर पैदा कर सकते हैं।
3. ग्रेडिएंट एकत्रीकरण चरण: यह पैरामीटर बड़े बैच आकार की नकल करने में मदद करता है कई चरणों में ग्रेडिएंट एकत्र करके trước पैरामीटर अपडेट करने से।
4. युगों की संख्या: पूरे डेटासेट को मॉडल के माध्यम से पारित करने की संख्या। अधिक युग बेहतर प्रदर्शन में परिणाम कर सकते हैं लेकिन ओवरफिटिंग का कारण बन सकते हैं यदि ठीक से प्रबंधित नहीं किया जाता है।
5. वजन क्षय: ओवरफिटिंग को रोकने के लिए एक नियमितीकरण तकनीक जो बड़े वजनों पर दंड लगाती है।
6. लर्निंग रेट शेड्यूलर: प्रशिक्षण के दौरान लर्निंग रेट को समायोजित करने के लिए उपयोग किया जाता है ताकि प्रदर्शन में सुधार हो और अभिसरण हो।

प्रशिक्षण कॉन्फ़िगरेशन को हाइपरपैरामीटर जैसे लर्निंग रेट, बैच आकार और ग्रेडिएंट एकत्रीकरण चरण को समायोजित करके अनुकूलित करें जो विशिष्ट मॉडल और कार्य आवश्यकताओं पर निर्भर करते हैं। उदाहरण के लिए, ल्लामा 3 मॉडल को छोटे मॉडल की तुलना में अलग लर्निंग रेट की आवश्यकता हो सकती है (Weights & Biases)​​ (GitHub)​

उदाहरण प्रशिक्षण कॉन्फ़िगरेशन

orpo_args = ORPOConfig(
learning_rate=8e-6,
lr_scheduler_type="linear",max_length=1024,max_prompt_length=512,
beta=0.1,per_device_train_batch_size=2,per_device_eval_batch_size=2,
gradient_accumulation_steps=4,optim="paged_adamw_8bit",num_train_epochs=1,
evaluation_strategy="steps",eval_steps=0.2,logging_steps=1,warmup_steps=10,
report_to="wandb",output_dir="./results/",)

10. मॉडल को प्रशिक्षित करें

प्रशिक्षक सेट करें और प्रशिक्षण शुरू करें:

trainer = ORPOTrainer(
model=original_model,
args=orpo_args,
train_dataset=train_dataset,
eval_dataset=eval_dataset,
tokenizer=tokenizer,)
trainer.train()
trainer.save_model("fine-tuned-llama-3")

फाइन-ट्यून किए गए मॉडल का मूल्यांकन

प्रशिक्षण के बाद, गुणात्मक और मात्रात्मक दोनों तरीकों से मॉडल के प्रदर्शन का मूल्यांकन करें।

1. मानव मूल्यांकन

मॉडल द्वारा उत्पन्न सारांशों की तुलना मानव-लिखित सारांशों से करें ताकि गुणवत्ता का आकलन किया जा सके।

2. मात्रात्मक मूल्यांकन

ROUGE जैसे मेट्रिक्स का उपयोग प्रदर्शन का आकलन करने के लिए करें:

from rouge_score import rouge_scorer

scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)
scores = scorer.score(reference_summary, generated_summary)
print(scores)

सामान्य चुनौतियाँ और समाधान

1. मेमोरी सीमाएं

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

2. ओवरफिटिंग

ओवरफिटिंग को रोकने के लिए सत्यापन मेट्रिक्स की निगरानी करें। अर्ली स्टॉपिंग और वजन क्षय जैसी तकनीकों का उपयोग करें।

3. धीमी प्रशिक्षण

प्रशिक्षण गति को अनुकूलित करने के लिए बैच आकार, लर्निंग रेट और ग्रेडिएंट एकत्रीकरण को समायोजित करें।

4. डेटा गुणवत्ता

सुनिश्चित करें कि आपका डेटासेट साफ और अच्छी तरह से प्री-प्रोसेस किया गया है। खराब डेटा गुणवत्ता मॉडल के प्रदर्शन पर महत्वपूर्ण प्रभाव डाल सकती है।

निष्कर्ष

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