टेक्स्ट वर्गीकरण के लिए Llama 3.1 का फाइन-ट्यूनिंग

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

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

हम Llama 3.1 मॉडलों के बारे में जानेंगे, Kaggle पर उन्हें कैसे एक्सेस करें, और Transformer लाइब्रेरी का उपयोग कर इन्फरेंस कैसे चलाएं। हम मानसिक स्वास्थ्य वर्गीकरण डेटासेट पर Llama-3.1-8b-It मॉडल को फाइन-ट्यून भी करेंगे। अंत में, हम सहेजे गए एडेप्टर को बेस मॉडल के साथ मर्ज करेंगे और पूर्ण मॉडल को Hugging Face Hub पर पुश करेंगे।

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

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

Llama 3.1 का परिचय

Llama 3.1, Meta AI द्वारा विकसित नवीनतम बहुभाषी बड़े भाषा मॉडलों (LLMs) की श्रृंखला है, जो भाषा समझ और जनरेशन की सीमाओं को आगे बढ़ा रही है। यह तीन आकारों में आती है: 8B, 70B, और 405B पैरामीटर्स।

Llama 3.1 मॉडल्स एक ऑटो-रेग्रेसिव भाषा मॉडल आर्किटेक्चर पर आधारित हैं, जिनमें ऑप्टिमाइज़्ड ट्रांसफॉर्मर्स हैं, और इन्हें विभिन्न प्राकृतिक भाषा प्रसंस्करण कार्यों व डेटासेट्स के लिए फाइन-ट्यून किया जा सकता है। इन्हें सार्वजनिक रूप से उपलब्ध विविध ऑनलाइन डेटा पर प्रशिक्षित किया गया है, ये आठ भाषाओं (अंग्रेजी, जर्मन, फ्रेंच, इतालवी, पुर्तगाली, हिंदी, स्पेनिश और थाई) का समर्थन करते हैं, और 128k के कॉन्टेक्स्ट लंबाई के साथ आते हैं। 

Llama 3.1 मॉडल्स कस्टम कमर्शियल लाइसेंस के तहत सभी के लिए उपलब्ध हैं और मॉडल वेट्स डाउनलोड करने के लिए न्यूनतम व्यक्तिगत जानकारी की आवश्यकता होती है।

Llama 3.1 बहुभाषी संवाद के लिए अनुकूलित है और इसने सामान्य चैट, कोडिंग, गणित, तर्क-वितर्क आदि सहित विभिन्न बेंचमार्क्स पर Gemma 2, GPT 3.5 turbo, और GPT-4o को पीछे छोड़ा है। यह अब तक उपलब्ध सबसे तेज़ और सबसे सटीक ओपन-सोर्स मॉडल है।

स्रोत: Llama 3.1 (meta.com)

आप Llama 3.1 मॉडल के बारे में अधिक जानने के लिए What Is Meta's Llama 3.1 405B? How It Works, Use Cases & More पढ़ सकते हैं।

Llama 3.1 के साथ शुरुआत

इस ट्यूटोरियल के लिए, हम डेवलपर वातावरण के रूप में Kaggle Notebook का उपयोग करेंगे क्योंकि यह मुफ्त GPUs और TPUs प्रदान करता है। Kaggle नोटबुक पर Llama 3.1 मॉडल का उपयोग करने के लिए, निम्न चरणों का पालन करें:

1. meta.com पर फॉर्म उसी ईमेल पते से भरें जो आपके Kaggle खाते में है।

2. Kaggle पर Meta | Llama 3.1 मॉडल रिपॉज़िटरी पर जाएं और "access the model" बटन पर क्लिक करें। सभी शर्तें स्वीकार करें, और कुछ सेकंड बाद आपको मॉडल तक पहुंच मिल जाएगी।

3. मॉडल पेज के दाईं ओर ऊपर उपलब्ध "Code" बटन पर क्लिक करके Llama 3.1 मॉडलों के साथ Kaggle नोटबुक शुरू करें।

4. फ्रेमवर्क, वेरिएशन और वर्ज़न चुनें, और "Add Model" बटन दबाएं।

5. Kaggle नोटबुक में निम्न आदेश का उपयोग कर आवश्यक Python पैकेज इंस्टॉल करें:

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

6. Transformers लाइब्रेरी का उपयोग कर लोकल डायरेक्टरी से मॉडल और टोकनाइज़र लोड करें।

7. मॉडल, टोकनाइज़र, torch टाइप और डिवाइस मैप के साथ टेक्स्ट जेनरेशन पाइपलाइन बनाएं।

from transformers import AutoTokenizer,AutoModelForCausalLM,pipeline
import torch

base_model = "/kaggle/input/llama-3.1/transformers/8b-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,
)
pipe = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
    torch_dtype=torch.float16,
    device_map="auto",
)संचालित द्वारा

8. संदेश लिखें और चैट टेम्पलेट का उपयोग करके उसे सही प्रॉम्प्ट में बदलें।

9. प्रॉम्प्ट का उपयोग कर पाइपलाइन चलाएं और जेनरेट हुआ आउटपुट प्रिंट करें।

messages = [{"role": "user", "content": "What is the tallest building in the world?"}]

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

उत्तर सटीक और विस्तृत है। 

यदि आपको मॉडल इन्फरेंस चलाने में कठिनाई हो, तो कृपया Kaggle Notebook देखें: Llama 3.1 Simple Model Inference. 

मानसिक स्वास्थ्य विकार वर्गीकरण पर Llama 3.1 का फाइन-ट्यूनिंग 

अब हमें डेटासेट लोड करना, उसे प्रोसेस करना और Llama 3.1 मॉडल को फाइन-ट्यून करना होगा। हम फाइन-ट्यूनिंग से पहले और बाद में मॉडल के प्रदर्शन की तुलना भी करेंगे।

यदि आप LLMs में नए हैं, तो ट्यूटोरियल के फाइन-ट्यूनिंग भाग में जाने से पहले Master Large Language Models (LLMs) Concepts कोर्स लेने की सलाह देता/देती हूं।

1. सेटअप

सबसे पहले, हम नई Kaggle नोटबुक और Llama 3.1 मॉडल को उसी तरह शुरू करेंगे जैसे हमने पिछले सेक्शन में किया था।

फिर हम नीचे दिए अनुसार आवश्यक Python पैकेज इंस्टॉल करेंगे:

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

इसके बाद, हम Kaggle नोटबुक में Sentiment Analysis for Mental Health डेटा जोड़ेंगे। ऐसा करने के लिए, ऊपर दाईं ओर स्थित “Add Input” बटन पर क्लिक करें और सर्च बार में मॉडल लिंक पेस्ट करें। फिर, प्लस (+) बटन पर क्लिक करके मॉडल जोड़ दें।

हम Weights and Biases API का उपयोग कर मॉडल के प्रदर्शन को ट्रैक करेंगे। API तक पहुंचने के लिए हमें API कुंजी चाहिए। Kaggle में Secrets का उपयोग कर API कुंजी सेट करें और उसे सक्रिय करें, जैसा नीचे दिखाया गया है।  

इसके बाद, हम API कुंजी का उपयोग कर Weights and Biases प्रोजेक्ट प्रारंभ करेंगे।

import wandb

from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()

wb_token = user_secrets.get_secret("wandb")

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

अब हमें सभी आवश्यक Python पैकेज और फंक्शंस इंपोर्ट करने हैं।

import numpy as np
import pandas as pd
import os
from tqdm import tqdm
import bitsandbytes as bnb
import torch
import torch.nn as nn
import transformers
from datasets import Dataset
from peft import LoraConfig, PeftConfig
from trl import SFTTrainer
from trl import setup_chat_format
from transformers import (AutoModelForCausalLM, 
                          AutoTokenizer, 
                          BitsAndBytesConfig, 
                          TrainingArguments, 
                          pipeline, 
                          logging)
from sklearn.metrics import (accuracy_score, 
                             classification_report, 
                             confusion_matrix)
from sklearn.model_selection import train_test_splitसंचालित द्वारा

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

अब हमारी बारी है डेटासेट लोड करने, डेटा की सफाई करने और तीन संदिग्ध श्रेणियों को हटाने की। 

सरलता के लिए, हम "Suicidal" श्रेणी को हटा देंगे क्योंकि Llama 3.1 में कुछ ट्रिगरिंग शब्दों को रोकने के लिए सेफ्टी मैकेनिज़्म हैं। "Stress" को मानसिक विकार नहीं माना जाता, और "Personality Disorder" का "Bipolar Disorder" के साथ काफी ओवरलैप है। 

परिणामस्वरूप, हमारे पास केवल चार श्रेणियां रहेंगी: "Normal," "Depression," "Anxiety," और "Bipolar"।

df = pd.read_csv("/kaggle/input/sentiment-analysis-for-mental-health/Combined Data.csv",index_col = "Unnamed: 0")
df.loc[:,'status'] = df.loc[:,'status'].str.replace('Bi-Polar','Bipolar')
df = df[(df.status != "Personality disorder") & (df.status != "Stress") & (df.status != "Suicidal")]
df.head()संचालित द्वारा

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

इसके बाद, हम मॉडल के प्रशिक्षण और परीक्षण के लिए डेटासेट को train, eval, और test सेट में विभाजित करेंगे। 

हम train और eval सेट में generate_prompt फंक्शन का उपयोग कर "text" कॉलम बनाना भी चाहते हैं, जो "statement" और "status" कॉलम के डेटा को जोड़ता है। 

अंत में, हम टेस्ट सेट में generate_test_prompt फंक्शन का उपयोग करके "text" कॉलम बनाएंगे और "status" कॉलम से y_true निकालेंगे। इसका उपयोग नीचे दिखाए अनुसार मॉडल मूल्यांकन रिपोर्ट बनाने के लिए किया जाएगा।

# Shuffle the DataFrame and select only 3000 rows
df = df.sample(frac=1, random_state=85).reset_index(drop=True).head(3000)

# Split the DataFrame
train_size = 0.8
eval_size = 0.1

# Calculate sizes
train_end = int(train_size * len(df))
eval_end = train_end + int(eval_size * len(df))

# Split the data
X_train = df[:train_end]
X_eval = df[train_end:eval_end]
X_test = df[eval_end:]

# Define the prompt generation functions
def generate_prompt(data_point):
    return f"""
            Classify the text into Normal, Depression, Anxiety, Bipolar, and return the answer as the corresponding mental health disorder label.
text: {data_point["statement"]}
label: {data_point["status"]}""".strip()

def generate_test_prompt(data_point):
    return f"""
            Classify the text into Normal, Depression, Anxiety, Bipolar, and return the answer as the corresponding mental health disorder label.
text: {data_point["statement"]}
label: """.strip()

# Generate prompts for training and evaluation data
X_train.loc[:,'text'] = X_train.apply(generate_prompt, axis=1)
X_eval.loc[:,'text'] = X_eval.apply(generate_prompt, axis=1)

# Generate test prompts and extract true labels
y_true = X_test.loc[:,'status']
X_test = pd.DataFrame(X_test.apply(generate_test_prompt, axis=1), columns=["text"])संचालित द्वारा

इस बिंदु पर, हम train सेट में श्रेणियों के वितरण की जांच करना चाहते हैं।

X_train.status.value_counts()संचालित द्वारा

आप नीचे देख सकते हैं कि "Normal" और "Depression" श्रेणियों का वितरण लगभग समान है। बाकी लेबल्स अल्पसंख्यक में हैं। इसका मतलब है कि हमारा डेटासेट असंतुलित है, और मॉडल अल्पसंख्यक लेबल्स की तुलना में बहुसंख्यक लेबल्स की भविष्यवाणी में बेहतर होगा। 

हम डेटासेट को संतुलित कर सकते हैं, लेकिन यह इस ट्यूटोरियल का उद्देश्य नहीं है।

status
Normal        1028
Depression     938
Anxiety        258
Bipolar        176
Name: count, dtype: int64संचालित द्वारा

तो, अगला कदम है train और eval सेट को Hugging Face डेटासेट्स में बदलना।

# Convert to datasets
train_data = Dataset.from_pandas(X_train[["text"]])
eval_data = Dataset.from_pandas(X_eval[["text"]])संचालित द्वारा

फिर, हम "text" कॉलम से चौथा सैंपल प्रदर्शित करेंगे।

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

दिख रहा है कि "text" कॉलम में सिस्टम प्रॉम्प्ट, स्टेटमेंट और लेबल के रूप में स्टेटस मौजूद है। 

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

अब, हम GPU मेमोरी बचाने के लिए Llama-3.1-8b-instruct मॉडल को 4-बिट क्वांटाइज़ेशन में लोड करना चाहते हैं। 

इसके बाद हम टोकनाइज़र लोड करेंगे और pad token id सेट करेंगे। 

base_model_name = "/kaggle/input/llama-3.1/transformers/8b-instruct/1"

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_use_double_quant=False,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype="float16",
)

model = AutoModelForCausalLM.from_pretrained(
    base_model_name,
    device_map="auto",
    torch_dtype="float16",
    quantization_config=bnb_config, 
)

model.config.use_cache = False
model.config.pretraining_tp = 1

tokenizer = AutoTokenizer.from_pretrained(base_model_name)

tokenizer.pad_token_id = tokenizer.eos_token_idसंचालित द्वारा

4. फाइन-ट्यूनिंग से पहले मॉडल का मूल्यांकन

यहां, हम predict फंक्शन बनाएंगे, जो टेक्स्ट जेनरेशन पाइपलाइन का उपयोग करके "text" कॉलम से लेबल्स की भविष्यवाणी करेगा। इस फंक्शन को चलाने पर टेस्टिंग सेट में विभिन्न सैंपल्स के आधार पर मानसिक विकार श्रेणियों की सूची प्राप्त होगी। 

def predict(test, model, tokenizer):
    y_pred = []
    categories = ["Normal", "Depression", "Anxiety", "Bipolar"]
    
    for i in tqdm(range(len(test))):
        prompt = test.iloc[i]["text"]
        pipe = pipeline(task="text-generation", 
                        model=model, 
                        tokenizer=tokenizer, 
                        max_new_tokens=2, 
                        temperature=0.1)
        
        result = pipe(prompt)
        answer = result[0]['generated_text'].split("label:")[-1].strip()
        
        # Determine the predicted category
        for category in categories:
            if category.lower() in answer.lower():
                y_pred.append(category)
                break
        else:
            y_pred.append("none")
    
    return y_pred

y_pred = predict(X_test, model, tokenizer)संचालित द्वारा

100%|██████████| 300/300 [02:54<00:00,  1.72it/s]संचालित द्वारा

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

def evaluate(y_true, y_pred):
    labels = ["Normal", "Depression", "Anxiety", "Bipolar"]
    mapping = {label: idx for idx, label in enumerate(labels)}
    
    def map_func(x):
        return mapping.get(x, -1)  # Map to -1 if not found, but should not occur with correct data
    
    y_true_mapped = np.vectorize(map_func)(y_true)
    y_pred_mapped = np.vectorize(map_func)(y_pred)
    
    # Calculate accuracy
    accuracy = accuracy_score(y_true=y_true_mapped, y_pred=y_pred_mapped)
    print(f'Accuracy: {accuracy:.3f}')
    
    # Generate accuracy report
    unique_labels = set(y_true_mapped)  # Get unique labels
    
    for label in unique_labels:
        label_indices = [i for i in range(len(y_true_mapped)) if y_true_mapped[i] == label]
        label_y_true = [y_true_mapped[i] for i in label_indices]
        label_y_pred = [y_pred_mapped[i] for i in label_indices]
        label_accuracy = accuracy_score(label_y_true, label_y_pred)
        print(f'Accuracy for label {labels[label]}: {label_accuracy:.3f}')
        
    # Generate classification report
    class_report = classification_report(y_true=y_true_mapped, y_pred=y_pred_mapped, target_names=labels, labels=list(range(len(labels))))
    print('\nClassification Report:')
    print(class_report)
    
    # Generate confusion matrix
    conf_matrix = confusion_matrix(y_true=y_true_mapped, y_pred=y_pred_mapped, labels=list(range(len(labels))))
    print('\nConfusion Matrix:')
    print(conf_matrix)

evaluate(y_true, y_pred)संचालित द्वारा

Llama 3.1 ने बिना फाइन-ट्यूनिंग के भी शानदार प्रदर्शन किया है। 79% सटीकता काफ़ी अच्छी है। आइए देखें, जब हम मॉडल को डेटासेट पर फाइन-ट्यून करते हैं तो यह कैसे सुधारता है।

Accuracy: 0.790
Accuracy for label Normal: 0.741
Accuracy for label Depression: 0.939
Accuracy for label Anxiety: 0.556
Accuracy for label Bipolar: 0.533

Classification Report:
              precision    recall  f1-score   support

      Normal       0.92      0.74      0.82       143
  Depression       0.70      0.94      0.80       115
     Anxiety       0.68      0.56      0.61        27
     Bipolar       0.89      0.53      0.67        15

    accuracy                           0.79       300
   macro avg       0.80      0.69      0.73       300
weighted avg       0.81      0.79      0.79       300


Confusion Matrix:
[[106  33   4   0]
 [  3 108   3   1]
 [  4   8  15   0]
 [  2   5   0   8]]संचालित द्वारा

5. मॉडल बनाना

मॉडल बनाते समय, हम bits and bytes लाइब्रेरी का उपयोग करके मॉडल से लीनियर मॉड्यूल नाम निकालने से शुरू करेंगे। 

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

इसके बाद हम प्रशिक्षण आर्ग्यूमेंट्स, मॉडल, टोकनाइज़र, LoRA कॉन्फ़िगरेशन और डेटासेट के साथ मॉडल ट्रेनर बनाएंगे। 

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

['down_proj', 'gate_proj', 'o_proj', 'v_proj', 'up_proj', 'q_proj', 'k_proj']संचालित द्वारा

output_dir="llama-3.1-fine-tuned-model"

peft_config = LoraConfig(
    lora_alpha=16,
    lora_dropout=0,
    r=64,
    bias="none",
    task_type="CAUSAL_LM",
    target_modules=modules,
)

training_arguments = TrainingArguments(
    output_dir=output_dir,                    # directory to save and repository id
    num_train_epochs=1,                       # number of training epochs
    per_device_train_batch_size=1,            # batch size per device during training
    gradient_accumulation_steps=8,            # number of steps before performing a backward/update pass
    gradient_checkpointing=True,              # use gradient checkpointing to save memory
    optim="paged_adamw_32bit",
    logging_steps=1,                         
    learning_rate=2e-4,                       # learning rate, based on QLoRA paper
    weight_decay=0.001,
    fp16=True,
    bf16=False,
    max_grad_norm=0.3,                        # max gradient norm based on QLoRA paper
    max_steps=-1,
    warmup_ratio=0.03,                        # warmup ratio based on QLoRA paper
    group_by_length=False,
    lr_scheduler_type="cosine",               # use cosine learning rate scheduler
    report_to="wandb",                  # report metrics to w&b
    eval_strategy="steps",              # save checkpoint every epoch
    eval_steps = 0.2
)

trainer = SFTTrainer(
    model=model,
    args=training_arguments,
    train_dataset=train_data,
    eval_dataset=eval_data,
    peft_config=peft_config,
    dataset_text_field="text",
    tokenizer=tokenizer,
    max_seq_length=512,
    packing=False,
    dataset_kwargs={
    "add_special_tokens": False,
    "append_concat_token": False,
    }
)संचालित द्वारा

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

अब मॉडल प्रशिक्षण शुरू करने का समय है:

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

मॉडल को फाइन-ट्यून करने में 1.5 घंटे लगे, और हमारा वैलिडेशन लॉस धीरे-धीरे कम हुआ। और बेहतर प्रदर्शन के लिए, पूरे डेटासेट पर कम से कम पाँच epochs के लिए प्रशिक्षण करने का प्रयास करें।

इसके बाद, हम Weights and Biases रन समाप्त करेंगे।

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

हम रन सारांश देख पाएंगे, जिसमें मॉडल प्रदर्शन के सभी आवश्यक मेट्रिक्स होंगे।

विस्तृत सारांश देखने के लिए, अपने Weights and Biases खाते पर जाएं और ब्राउज़र में रन देखें। इसमें इंटरैक्टिव विज़ुअलाइज़ेशन शामिल हैं।

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

# Save trained model and tokenizer
trainer.save_model(output_dir)
tokenizer.save_pretrained(output_dir)संचालित द्वारा

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

अब सबसे महत्वपूर्ण भाग आता है। क्या हमारा मॉडल फाइन-ट्यूनिंग के बाद बेहतर प्रदर्शन करेगा, या यह बदतर हो जाएगा? जानने के लिए, हमें टेस्ट सेट पर 'predict' फंक्शन चलाना होगा और फिर 'evaluate' फंक्शन चलाकर मॉडल मूल्यांकन रिपोर्ट जनरेट करनी होगी।

y_pred = predict(X_test, model, tokenizer)
evaluate(y_true, y_pred)संचालित द्वारा

जैसा कि आप नीचे के परिणामों से देख सकते हैं, मॉडल प्रदर्शन में बड़ा सुधार हुआ है—79% से बढ़कर 91.3% सटीकता। F1 स्कोर्स भी अच्छे दिख रहे हैं। 

100%|██████████| 300/300 [03:24<00:00,  1.47it/s]
Accuracy: 0.913
Accuracy for label Normal: 0.972
Accuracy for label Depression: 0.913
Accuracy for label Anxiety: 0.667
Accuracy for label Bipolar: 0.800

Classification Report:
              precision    recall  f1-score   support

      Normal       0.92      0.97      0.95       143
  Depression       0.93      0.91      0.92       115
     Anxiety       0.75      0.67      0.71        27
     Bipolar       1.00      0.80      0.89        15

    accuracy                           0.91       300
   macro avg       0.90      0.84      0.87       300
weighted avg       0.91      0.91      0.91       300


Confusion Matrix:
[[139   3   1   0]
 [  5 105   5   0]
 [  6   3  18   0]
 [  1   2   0  12]]संचालित द्वारा

अब हम Kaggle नोटबुक को सेव कर सकते हैं ताकि परिणाम और मॉडल फाइलें सहेजी जा सकें। इसके लिए, ऊपर दाईं ओर "Save Version" बटन पर क्लिक करें, वर्ज़न प्रकार "Quick Save" चुनें, और सेव आउटपुट प्रकार के रूप में "Always save output when creating a Quick Save" चुनें।

यदि आपको मॉडल को फाइन-ट्यून करने में परेशानी हो रही है, तो आगे की सहायता के लिए Kaggle notebook देखें। 

आप हमारे गाइड Fine-Tuning Llama 3 and Using It Locally का अनुसरण करके Llama 3.0 मॉडलों को फाइन-ट्यून करना भी सीख सकते हैं। 

फाइन-ट्यून किए गए Llama 3.1 मॉडल का मर्जिंग और सेविंग

इस सेक्शन में, हम एडेप्टर को बेस मॉडल के साथ मर्ज करेंगे और पूर्ण संस्करण को Hugging Face हब पर सहेजेंगे। 

सबसे पहले, हम GPU एक्सेलेरेशन के साथ नई Kaggle नोटबुक लॉन्च करेंगे और सहेजी गई नोटबुक को जोड़ेंगे ताकि मॉडल फाइलों तक पहुंच मिल सके। हम अन्य Kaggle नोटबुक्स को भी इनपुट के रूप में शामिल कर सकते हैं, ठीक वैसे ही जैसे डेटासेट जोड़ते हैं।

इसके बाद, हम आवश्यक Python पैकेज इंस्टॉल करेंगे। 

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

अगला कदम Hugging Face हब API में API कुंजी से लॉगिन करना है, ताकि हम अपने मॉडल फाइल्स को Hugging Face मॉडल रिपॉज़िटरी में पुश कर सकें। 

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

इसके बाद हम बेस मॉडल और फाइन-ट्यून मॉडल की डायरेक्टरी सेट कर सकते हैं।

base_model = "/kaggle/input/llama-3.1/transformers/8b-instruct/1"
fine_tuned_model = "/kaggle/input/fine-tune-llama-3-1-for-text-classification/llama-3.1-fine-tuned-model/"संचालित द्वारा

फिर, टोकनाइज़र और बेस मॉडल लोड करें। 

from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
from peft import PeftModel
import torch


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

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

हम नीचे दिखाए अनुसार बेस मॉडल को फाइन-ट्यून एडेप्टर के साथ मर्ज करेंगे। 

# Merge adapter with base model
model = PeftModel.from_pretrained(base_model_reload, fine_tuned_model)
model = model.merge_and_unload()संचालित द्वारा

मॉडल सेव करने से पहले, आइए जांच लें कि यह सही से काम कर रहा है। मॉडल और टोकनाइज़र के साथ टेक्स्ट जेनरेशन पाइपलाइन बनाएँ और सैंपल प्रॉम्प्ट दें। 

text = "I'm trapped in a storm of emotions that I can't control, and it feels like no one understands the chaos inside me"
prompt = f"""Classify the text into Normal, Depression, Anxiety, Bipolar, and return the answer as the corresponding mental health disorder label.
text: {text}
label: """.strip()

pipe = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
    torch_dtype=torch.float16,
    device_map="auto",
)

outputs = pipe(prompt, max_new_tokens=2, do_sample=True, temperature=0.1)
print(outputs[0]["generated_text"].split("label: ")[-1].strip())संचालित द्वारा

हमारा मॉडल बिल्कुल सही काम कर रहा है।

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

अब हम मॉडल और टोकनाइज़र को लोकल रूप से सहेज सकते हैं। 

model_dir = "Llama-3.1-8B-Instruct-Mental-Health-Classification"
model.save_pretrained(model_dir)
tokenizer.save_pretrained(model_dir)संचालित द्वारा

और फिर मॉडल और टोकनाइज़र को Hugging Face Hub पर पुश करें।

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

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

CommitInfo(commit_url='https://huggingface.co/kingabzpro/Llama-3.1-8B-Instruct-Mental-Health-Classification/commit/e1244abeaac159e0a48439095200a4190c2b493c', commit_message='Upload tokenizer', commit_description='', oid='e1244abeaac159e0a48439095200a4190c2b493c', pr_url=None, pr_revision=None, pr_num=None)संचालित द्वारा

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

स्रोत: kingabzpro/Llama-3.1-8B-Instruct-Mental-Health-Classification · Hugging Face

यदि आपको एडेप्टर को बेस मॉडल के साथ मर्ज करने में समस्या हो रही है, तो Kaggle notebook देखें।

यदि आपको LLMs का फाइन-ट्यूनिंग कठिन लगता है, तो Fine-Tuning OpenAI's GPT-4: A Step-by-Step Guide ट्यूटोरियल का अनुसरण करके OpenAI API का उपयोग कर कुछ पंक्तियों के कोड से किसी भी डेटासेट पर मॉडल को फाइन-ट्यून करने का आसान तरीका सीख सकते हैं।

अंतिम विचार

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

इस ट्यूटोरियल में, हमने मानसिक स्वास्थ्य वर्गीकरण डेटासेट पर Llama 3.1 मॉडल को फाइन-ट्यून करना सीखा। इस मॉडल का उपयोग उन मरीजों और यहां तक कि कर्मचारियों की पहचान के लिए किया जा सकता है जो अपने दैनिक जीवन में चुनौतियों का सामना कर रहे हैं।

यदि आप सोच रहे हैं कि LLMs के साथ कैसे शुरुआत करें और खुद मॉडलों को फाइन-ट्यून करना शुरू करें, तो Developing Large Language Models स्किल ट्रैक लेने पर विचार करें। इस पाठ्यक्रम श्रृंखला के साथ, आप LLMs में मजबूत नींव बनाएंगे, जो आपको नए AI-संचालित परिदृश्य में आगे बढ़ाएगी।