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

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

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

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

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

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

लार्ज लैंग्वेज मॉडल्स को फाइन-ट्यून करना

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

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

पैरामीटर-दक्ष फाइन-ट्यूनिंग (पीईएफटी)

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

लो-रैंक अनुकूलन (लोरा) और क्वांटाइज्ड लोरा (क्यूएलओआरए)

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

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

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

लोरा क्या है?

फाइन-ट्यूनिंग विधियों की तुलना

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

लोरा के मुख्य लाभ:

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

क्यूएलओआरए क्या है?

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

क्यूएलओआरए के मुख्य लाभ:

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

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

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

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

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

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

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

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

एलएलएम को फाइन-ट्यून करने के लिए चरण-दर-चरण गाइड

पर्यावरण सेटअप

हम जupyter नोटबुक का उपयोग इस ट्यूटोरियल के लिए करेंगे। 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 डेटासेट का उपयोग करेंगे:
प्री-प्रोसेसिंग डेटासेट को मॉडल की आवश्यकताओं के अनुसार, सही प्रारूप में लाने के लिए, जिसमें उपयुक्त टेम्पलेट्स लगाना और सुनिश्चित करना शामिल है कि डेटा फाइन-ट्यूनिंग के लिए उपयुक्त है (हगिंग फ़ेस) ​​ (डेटाकैंप) ​.

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

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

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

4. बिट्सएंडबाइट्स कॉन्फ़िगरेशन बनाएं

मॉडल को 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. प्री-ट्रेन्ड मॉडल लोड करें

इस ट्यूटोरियल के लिए माइक्रोसॉफ्ट के फाई-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 के लिए आवश्यक होने पर हगिंग फ़ेस अकाउंट में लॉग इन करने और अनुमति मांगने के लिए सुनिश्चित करें (हगिंग फ़ेस) ​​

टोकनाइजेशन:

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

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

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

उदाहरण:

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 बेहतर प्रदर्शन के लिए अनुशंसित है (हगिंग फ़ेस) ​​ (गिटहब) ​

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

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

<p># आउटपुट उत्पन्न करें
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)</p>

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

<p>print(f'इनपुट प्रॉम्प्ट:\n{formatted_prompt}')
print(f'मॉडल जनरेशन - ज़ीरो शॉट:\n{output}')

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

डायलॉग-सम्मरी जोड़ियों को प्रॉम्प्ट्स में बदलें:

<p>def create_prompt_formats(sample):
blurb = "नीचे एक निर्देश है जो एक कार्य का वर्णन करता है। अनुरोध को पूरा करने के लिए एक प्रतिक्रिया लिखें।"
instruction = "### Instruct: निम्नलिखित बातचीत का सारांश बनाएं."
input_context = sample['dialogue']
response = f"### आउटपुट:\n{sample['summary']}"
end = "### अंत"</p>

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

<p>dataset = dataset.map(create_prompt_formats)</p>

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

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

<p>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)</p>

मॉडल को पैरामीटर-दक्ष फाइन-ट्यूनिंग के लिए तैयार करें:

<p>original_model = prepare_model_for_kbit_training(original_model)</p>

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

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

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

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

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. मात्रात्मक मूल्यांकन

रोग नामक मापदंडों का उपयोग करके प्रदर्शन का मूल्यांकन करें:

from rouge_score import rouge_scorer

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

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

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

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

2. ओवरफिटिंग

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

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

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

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

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

निष्कर्ष

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