ई-कॉमर्स वर्गीकरण डेटासेट पर Phi-3.5 का फाइन-ट्यूनिंग

Microsoft ने Phi-3.5 श्रृंखला पेश करके Meta AI के साथ बड़े भाषा मॉडलों के प्रतिस्पर्धी परिदृश्य में प्रवेश किया है। इस श्रृंखला में एक छोटा भाषा मॉडल, एक विज़न भाषा मॉडल शामिल है, और यह उत्कृष्ट प्रदर्शन हासिल करने के लिए Mixture-of-Experts दृष्टिकोण अपनाता है।

इस ट्यूटोरियल में, हम Microsoft Phi-3.5 मॉडल परिवार का अन्वेषण करेंगे। हम Phi-3.5-mini-instruct मॉडल लोड करेंगे और इसे उनके टेक्स्ट विवरण के आधार पर ई-कॉमर्स उत्पादों को वर्गीकृत करने के लिए फाइन-ट्यून करेंगे। अंतिम चरणों में, हम दिखाएँगे कि LoRA (Low-Rank Adaptation) को बेस मॉडल के साथ कैसे मर्ज किया जाए और उसे Hugging Face पर पुश किया जाए। इससे कुशल क्लाउड परिनियोजन संभव होगा, जिससे मॉडल विभिन्न अनुप्रयोगों के लिए सुलभ हो जाएगा।

यह Master Large Language Models (LLMs) Concepts पाठ्यक्रम करें और LLM एप्लिकेशन, प्रशिक्षण पद्धतियाँ, नैतिक विचार और नवीनतम शोध के बारे में जानें।

छवि: लेखक

Microsoft Phi-3.5 का परिचय

इस Microsoft Phi-3.5 रिलीज में तीन नवोन्मेषी मॉडल शामिल हैं: Phi-3.5-mini, Phi-3.5-vision, और नवीनतम Phi-3.5-MoE, जो Mixture-of-Experts मॉडल है।

Phi-3.5-mini को उन्नत बहुभाषी समर्थन के लिए ऑप्टिमाइज़ किया गया है और इसमें प्रभावशाली 128K संदर्भ लंबाई है। छोटे आकार के बावजूद, यह बड़े मॉडलों की टक्कर का प्रदर्शन देता है—सुपरवाइज़्ड फाइन-ट्यूनिंग, प्रॉक्सिमल पॉलिसी ऑप्टिमाइज़ेशन और डायरेक्ट प्रेफरेंस ऑप्टिमाइज़ेशन जैसे कड़े सुधारों के कारण—जो सटीक निर्देश-अनुपालन सुनिश्चित करते हैं।

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

सबसे अलग मॉडल, Phi-3.5-MoE, 16 विशेषज्ञों और 6.6 अरब सक्रिय पैरामीटर्स वाली Mixture-of-Experts आर्किटेक्चर प्रस्तुत करता है। यह कम विलंबता, मज़बूत सुरक्षा और व्यापक बहुभाषी समर्थन के साथ असाधारण प्रदर्शन प्रदान करता है।

Phi-3.5 मॉडल परिवार ओपन-सोर्स समुदाय के लिए किफायती, उच्च-प्रदर्शन समाधान प्रदान करता है, जो छोटे भाषा मॉडलों और जनरेटिव AI को आगे बढ़ाता है।

Phi-3 आर्किटेक्चर, विशेषताएँ और अनुप्रयोगों के बारे में जानने के लिए, Phi-3 Tutorial: Microsoft के सबसे छोटे AI मॉडल के साथ हैंड्स-ऑन गाइड देखें।

Microsoft Phi-3.5 मॉडल तक पहुँच

इस खंड में, हम Phi-3.5-mini-instruct मॉडल लोड करेंगे और Kaggle प्लेटफ़ॉर्म पर मॉडल इन्फ़रेंस चलाएँगे।

T4x2 GPU सक्षम करके सत्र शुरू करें।

सभी आवश्यक Python पैकेजों को pip कमांड का उपयोग करके इंस्टॉल करें।

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

Transformers लाइब्रेरी का उपयोग करके पूरा मॉडल और टोकनाइज़र लोड करें।
text-generation पाइपलाइन मॉडल और टोकनाइज़र के साथ बनाएँ।

from transformers import AutoTokenizer,AutoModelForCausalLM,pipeline
import torch

base_model = "microsoft/Phi-3.5-mini-instruct"

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

सिस्टम प्रॉम्प्ट और उपयोगकर्ता क्वेरी के साथ संदेश बनाएँ और चैट टेम्पलेट का उपयोग करके उसे चैट प्रॉम्प्ट में बदलें।
पाइपलाइन को प्रॉम्प्ट प्रदान करके प्रतिक्रिया जनरेट करें।

messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "What is the tallest building in the world?"}
]

# Apply the chat template to the messages
prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)

# Generate the output using the pipeline
outputs = pipe(prompt, max_new_tokens=120, do_sample=True)

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

हमें सटीक और विस्तृत परिणाम मिला।

<|system|>
You are a helpful assistant.<|end|>
<|user|>
What is the tallest building in the world?<|end|>
<|assistant|>
 As of my knowledge cutoff in 2023, the tallest building in the world is the Burj Khalifa, located in Dubai, United Arab Emirates. It stands at a remarkable 828 meters (2,716.5 feet) tall once its antenna is included. Completed in January 2010, the Burj Khalifa marks a significant achievement in architecture and engineering, setting numerous records. It provides office space, luxury condominiums, and various leisure facilities. This landmark continues toसंचालित द्वारा

हम निर्देशों और कॉल ट्रांस्क्रिप्शन के साथ एक कस्टम प्रॉम्प्ट देकर भी टेक्स्ट जनरेशन पाइपलाइन को प्रदान कर सकते हैं ताकि जाँचा जा सके कि मॉडल उपयोगकर्ता के निर्देशों का पालन करता है या नहीं।

prompt = """
        In a call center environment, classify customer interactions as 'Fraudulent' or 'Non-Fraudulent'. 
        Consider factors such as the nature of the inquiry, caller verification details, transaction history, and any red flags raised during the call.
        [Lisa Adams, contacts the call center claiming unauthorized transactions on her credit card statement. She demands a full refund, asserting that she has never visited the merchant in question.] =
        """
outputs = pipe(prompt, max_new_tokens=120, do_sample=True)
print(outputs[0]["generated_text"])संचालित द्वारा

जैसा कि हम देख सकते हैं, मॉडल ने अच्छा प्रदर्शन किया है—कॉल को धोखाधड़ीपूर्ण के रूप में फ़्लैग किया और स्पष्टीकरण भी प्रदान किया।

 In a call center environment, classify customer interactions as 'Fraudulent' or 'Non-Fraudulent'. 
        Consider factors such as the nature of the inquiry, caller verification details, transaction history, and any red flags raised during the call.
        [Lisa Adams, contacts the call center claiming unauthorized transactions on her credit card statement. She demands a full refund, asserting that she has never visited the merchant in question.] =
        
        Call Interaction Classification: Fraudulent
        
        Explanation: 
        The situation described by Lisa Adams indicates a potential case of credit card fraud. There are several red flags in this interaction that suggest the customer might be reporting unauthorized transactions:

1. The caller claims unauthorized transactions - This is a common indicator of fraud, especially if the transactions were for places or services the customer did not recognize or didn't patronize according to their personal knowledge or documented transaction history (e.g., no visits to theसंचालित द्वारा

यदि आपको Kaggle प्लेटफ़ॉर्म पर मॉडल चलाने में समस्या हो रही है, तो कृपया Simple Model Inference of Phi-3.5 Kaggle नोटबुक देखें। इसमें पूर्वनिर्मित सेटअप, कोड और आउटपुट शामिल हैं।

Microsoft Phi-3.5-mini-instruct का फाइन-ट्यूनिंग

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

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

1. सेटअप

GPU त्वरक सक्षम करके नया Kaggle नोटबुक लॉन्च करें। फिर, सुनिश्चित करें कि आपने Kaggle secrets का उपयोग करके Hugging Face और Weights & Biases API टोकन को वातावरण चर के रूप में सेट किया है।

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

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

Weights and Biases सेवा में लॉग इन करें, API कुंजी साइन करें, और नया प्रोजेक्ट प्रारंभ करें।

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 Phi-3.5-it on Ecommerce Text Classification', 
    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. डेटासेट लोड करना और प्रोसेस करना

अपने नोटबुक में E-commerce Text Classification डेटासेट जोड़ें, जैसा नीचे दिखाया गया है। डेटासेट में दो कॉलम हैं: लेबल (ई-कॉमर्स श्रेणियाँ) और उत्पाद के टेक्स्ट विवरण।

CSV फ़ाइल लोड करें, उसे प्रोसेस करें और शीर्ष 5 पंक्तियाँ देखें।

df = pd.read_csv("/kaggle/input/ecommerce-text-classification/ecommerceDataset.csv")
df.columns = ["label","text"]
df.loc[:,'label'] = df.loc[:,'label'].str.replace('Clothing & Accessories','Clothing')
df.head()संचालित द्वारा

डेटासेट में उत्पाद का विवरण और श्रेणी लेबल शामिल है।

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

अगले चरण में, हम डेटा को ट्रेन, मूल्यांकन और टेस्ट डेटासेट में विभाजित करेंगे।

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

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

हम दो फ़ंक्शन बनाएँगे। generate_prompt फ़ंक्शन टेक्स्ट कॉलम को प्रॉम्प्ट में बदलेगा, जिसमें निर्देश, टेक्स्ट विवरण और लेबल शामिल होंगे। generate_test_prompt फ़ंक्शन वही है, बस इसमें लेबल नहीं होगा।

# Define the prompt generation functions
def generate_prompt(data_point):
    return f"""
            Classify the E-commerce text into Electronics, Household, Books and Clothing.
text: {data_point["text"]}
label: {data_point["label"]}""".strip()

def generate_test_prompt(data_point):
    return f"""
            Classify the E-commerce text into Electronics, Household, Books and Clothing.
text: {data_point["text"]}
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[:,'label']
X_test = pd.DataFrame(X_test.apply(generate_test_prompt, axis=1), columns=["text"])संचालित द्वारा

pandas के ट्रेन और मूल्यांकन डेटा डेटाफ़्रेम को Hugging Face डेटासेट्स में बदलें।

# Convert to datasets
train_data = Dataset.from_pandas(X_train[["text"]])
eval_data = Dataset.from_pandas(X_eval[["text"]])

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

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

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

Hugging Face Hub से रिपॉज़िटरी ID का उपयोग करके 4-बिट क्वांटाइज़्ड मॉडल और टोकनाइज़र लोड करें। फिर, मॉडल और टोकनाइज़र को उपयोग के लिए तैयार कर दें।

base_model_name = "microsoft/Phi-3.5-mini-instruct"

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 फ़ंक्शन बनाएँगे जो टेस्ट डेटासेट लेता है और उत्पाद तथा टेक्स्ट विवरण के आधार पर ई-कॉमर्स श्रेणियाँ जनरेट करता है।

def predict(test, model, tokenizer):
    y_pred = []
    categories = ["Electronics", "Household", "Books", "Clothing"]
    
    for i in tqdm(range(len(test))):
        prompt = test.iloc[i]["text"]
        pipe = pipeline(task="text-generation", 
                        model=model, 
                        tokenizer=tokenizer, 
                        max_new_tokens=4, 
                        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)संचालित द्वारा

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

def evaluate(y_true, y_pred):
    labels = ["Electronics", "Household", "Books", "Clothing"]
    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)संचालित द्वारा

हमने औसतन 65% शुद्धता हासिल की। आइए देखें कि क्या फाइन-ट्यूनिंग से यह स्कोर बेहतर हो सकता है।

Accuracy: 0.645
Accuracy for label Electronics: 0.950
Accuracy for label Household: 0.531
Accuracy for label Books: 0.561
Accuracy for label Clothing: 0.658

Classification Report:
              precision    recall  f1-score   support

 Electronics       0.46      0.95      0.62        40
   Household       0.83      0.53      0.65        81
       Books       0.96      0.56      0.71        41
    Clothing       0.86      0.66      0.75        38

   micro avg       0.69      0.65      0.67       200
   macro avg       0.78      0.67      0.68       200
weighted avg       0.79      0.65      0.67       200


Confusion Matrix:
[[38  0  1  0]
 [33 43  0  2]
 [ 9  6 23  2]
 [ 2  3  0 25]]संचालित द्वारा

5. मॉडल सेटअप

मॉडल से लीनियर मॉड्यूल नाम निकालें।

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

['gate_up_proj', 'down_proj', 'qkv_proj', 'o_proj']संचालित द्वारा

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

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

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

output_dir="Phi-3.5-mini-instruct"

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=4,            # number of steps before performing a backward/update pass
    gradient_checkpointing=True,              # use gradient checkpointing to save memory
    optim="paged_adamw_8bit",
    logging_steps=1,                         
    learning_rate=2e-5,                       # learning rate, based on QLoRA paper
    weight_decay=0.001,
    fp16=False,
    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. मॉडल प्रशिक्षण

फाइन-ट्यूनिंग प्रक्रिया शुरू करने के लिए हम .train फ़ंक्शन का उपयोग करेंगे।

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

लॉस धीरे-धीरे कम हुआ है, और अधिक epochs के साथ हम और भी बेहतर परिणाम प्राप्त कर सकते थे।

मूल्यांकन रिपोर्ट जनरेट करने के लिए Weights & Biases रन समाप्त करें।

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

आप Weights & Biases वेबसाइट पर जाकर, अपना प्रोजेक्ट चुनकर और प्रशिक्षण विश्लेषण देखकर मॉडल के प्रदर्शन का विश्लेषण कर सकते हैं।

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

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

यह गाइड काफी कोड-प्रधान है। यदि आप सरल समाधान ढूँढ रहे हैं, तो आप LlaMA-Factory WebUI Beginner's Guide: Fine-Tuning LLMs ट्यूटोरियल का अनुसरण करके ओपन-सोर्स मॉडल को फाइन-ट्यून कर सकते हैं। और भी सरल समाधान के लिए, जहाँ आपको हार्डवेयर संबंधी समस्याओं की चिंता नहीं करनी पड़ेगी, हम Fine-tuning GPT-4o Mini: A Step-by-Step Guide ट्यूटोरियल की अत्यधिक अनुशंसा करते हैं। इससे आप क्लाउड पर न्यूनतम कोड के साथ फाइन-ट्यून कर पाएँगे।

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

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

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

मॉडल की शुद्धता लगभग 32.31% तक सुधरी, और शेष प्रदर्शन मेट्रिक्स प्रभावशाली दिखते हैं। Books श्रेणी को छोड़कर, मॉडल श्रेणियों की पहचान काफ़ी सटीकता से कर पाया।

Accuracy: 0.860
Accuracy for label Electronics: 0.825
Accuracy for label Household: 0.926
Accuracy for label Books: 0.683
Accuracy for label Clothing: 0.947

Classification Report:
              precision    recall  f1-score   support

 Electronics       0.97      0.82      0.89        40
   Household       0.88      0.93      0.90        81
       Books       0.90      0.68      0.78        41
    Clothing       0.88      0.95      0.91        38

   micro avg       0.90      0.86      0.88       200
   macro avg       0.91      0.85      0.87       200
weighted avg       0.90      0.86      0.88       200


Confusion Matrix:
[[33  6  1  0]
 [ 1 75  2  3]
 [ 0  3 28  2]
 [ 0  1  0 36]]संचालित द्वारा

सुनिश्चित करें कि आप ऊपर दाईं ओर "Save Version" बटन पर क्लिक करके Kaggle नोटबुक सेव करें। फिर, क्विक सेव विकल्प चुनें और सेव आउटपुट विकल्प को बदलकर मॉडल फ़ाइल और पूरे कोड को शामिल करें।

यदि आपको मॉडल को फाइन-ट्यून करते समय समस्याएँ आती हैं, तो कृपया Fine-tune Phi-3.5 for Text Classification Kaggle नोटबुक देखें।

फाइन-ट्यून किए गए मॉडल का मर्ज और एक्सपोर्ट

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

दूसरा Kaggle नोटबुक जोड़ना, डेटासेट और मॉडल जोड़ने जैसा ही है। “+ Add Input” बटन पर क्लिक करें, नोटबुक का लिंक पेस्ट करें, और फिर add बटन दबाएँ।

Kaggle secrets का उपयोग करके Hugging Face API को वातावरण चर के रूप में सेट करें और मॉडल लोड व मर्ज करने के लिए सभी आवश्यक Python पैकेज इंस्टॉल करें।

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

बेस मॉडल और फाइन-ट्यून किए गए मॉडल वेरिएबल्स को मॉडल ID और मॉडल एडेप्टर के लोकेशन के साथ सेट करें।

# Model
base_model = "microsoft/Phi-3.5-mini-instruct"
fine_tuned_model = "/kaggle/input/fine-tune-phi-3-5-for-text-classification/Phi-3.5-mini-instruct/"संचालित द्वारा

Hugging Face hub से टोकनाइज़र के साथ पूरा मॉडल लोड करें।

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 = "Inalsa Dazzle Glass Top, 3 Burner Gas Stove with Rust Proof Powder Coated Body, Black Toughened Glass Top, 2 Medium and 1 Small High Efficiency Brass Burners, Aluminum Mixing Tubes, Powder Coated Body, Inbuilt Stainless Steel Drip Trays, 360 degree Swivel Nozzle,Bigger Legs to Facilitate Cleaning Under Cooktop"
prompt = f"""Classify the E-commerce text into Electronics, Household, Books and Clothing.
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=4, do_sample=True, temperature=0.1)
print(outputs[0]["generated_text"].split("label: ")[-1].strip())1].strip())संचालित द्वारा

मॉडल ने उत्पाद श्रेणी का सटीक पूर्वानुमान लगाया है।

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

हम मॉडल डायरेक्टरी प्रदान करके पूरे मॉडल को लोकल रूप से सेव करेंगे।

model_dir = "Phi-3.5-mini-instruct-Ecommerce-Text-Classification"
model.save_pretrained(model_dir)
tokenizer.save_pretrained(model_dir)संचालित द्वारा

सेव किए गए मॉडल को Hugging Face hub पर पुश करें। पहले Kaggle secrets से निकाली गई API कुंजी का उपयोग करके Hugging Face CLI में लॉग इन करें, और फिर push_to_hub फ़ंक्शन का उपयोग करके मॉडल और टोकनाइज़र दोनों को पुश करें।

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)


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

इसने नया मॉडल रिपॉज़िटरी बना दिया है और सभी फ़ाइलें Hugging Face मॉडल रिपॉज़िटरी पर पुश कर दी हैं।

स्रोत: kingabzpro/Phi-3.5-mini-instruct-Ecommerce-Text-Classification

यदि आपको मॉडल को मर्ज करने और एक्सपोर्ट करने में समस्या हो रही है, तो कृपया Phi-3.5 Fine-tuned Adapter to the full model Kaggle नोटबुक देखें।

इसके अलावा, हमारा नवीनतम ट्यूटोरियल Fine-tuning Llama 3.2 और उसे लोकल रूप से उपयोग करना: चरण-दर-चरण गाइड भी देखें। इस ट्यूटोरियल में, आप फ्री GPUs का उपयोग करके कस्टम डेटासेट पर मॉडल को फाइन-ट्यून करना, मॉडल को Hugging Face Hub पर मर्ज और एक्सपोर्ट करना, और फाइन-ट्यून किए गए मॉडल को GGUF फ़ॉर्मेट में बदलना सीखेंगे ताकि उसे Jan एप्लिकेशन के साथ लोकल रूप से उपयोग किया जा सके।

निष्कर्ष

बड़े भाषा मॉडल छोटे और अधिक दक्ष हो रहे हैं, जिससे परिचालन लागत कम हो रही है और विभिन्न क्षेत्रों में अनुकूलन क्षमता बेहतर हो रही है। इस ट्यूटोरियल में, हमने Phi-3.5 Mini, Vision, और MoE मॉडलों का अन्वेषण किया। हमने Kaggle नोटबुक्स का उपयोग करके Phi-3.5 Mini मॉडलों तक पहुँच बनाना भी सीखा।

इसके बाद, हमने वर्गीकरण डेटा पर मॉडलों को फाइन-ट्यून किया और उनके प्रदर्शन का मूल्यांकन किया—65% से 86% शुद्धता तक महत्वपूर्ण सुधार हासिल किया—जो उल्लेखनीय उपलब्धि है। ऐसा प्रदर्शन केवल RAG या फ़ंक्शन कॉलिंग से संभव नहीं है।

अंत में, हमने LoRA को बेस मॉडल के साथ एकीकृत किया और पूरे मॉडल को Hugging Face Hub पर एक्सपोर्ट किया, जहाँ यह सभी के उपयोग के लिए उपलब्ध है।

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

लेखक

Abid Ali Awan

LinkedIn Twitter

एक प्रमाणित डेटा साइंटिस्ट के रूप में, मैं अत्याधुनिक तकनीक का उपयोग करके नवाचारी मशीन लर्निंग अनुप्रयोग बनाने के लिए उत्साहित रहता/रहती हूँ। स्पीच रिकॉग्निशन, डेटा विश्लेषण और रिपोर्टिंग, MLOps, संवादात्मक AI और NLP में मजबूत पृष्ठभूमि के साथ, मैंने ऐसे बुद्धिमान सिस्टम विकसित करने में अपनी विशेषज्ञता निखारी है जो वास्तविक प्रभाव डाल सकें। तकनीकी दक्षता के अलावा, मैं जटिल अवधारणाओं को स्पष्ट और संक्षिप्त भाषा में प्रस्तुत करने में भी निपुण हूँ। परिणामस्वरूप, मैं डेटा साइंस पर एक मांग में रहने वाला/वाली ब्लॉगर बन गया/गई हूँ, और डेटा प्रोफेशनलों के बढ़ते समुदाय के साथ अपने अनुभव और विचार साझा करता/करती हूँ। वर्तमान में, मैं कंटेंट निर्माण और संपादन पर केंद्रित हूँ, बड़े भाषा मॉडलों के साथ काम करते हुए ऐसा प्रभावशाली और आकर्षक कंटेंट विकसित कर रहा/रही हूँ जो व्यवसायों और व्यक्तियों दोनों को अपने डेटा का अधिकतम लाभ उठाने में मदद कर सके।

विषय

बड़े भाषा मॉडल कृत्रिम बुद्धिमत्ता

प्रौद्योगिकियाँ

विषय

ई-कॉमर्स वर्गीकरण डेटासेट पर Phi-3.5 का फाइन-ट्यूनिंग

AI के साथ खोजें

Microsoft Phi-3.5 का परिचय

Microsoft Phi-3.5 मॉडल तक पहुँच

Microsoft Phi-3.5-mini-instruct का फाइन-ट्यूनिंग

1. सेटअप

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

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

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

5. मॉडल सेटअप

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

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

फाइन-ट्यून किए गए मॉडल का मर्ज और एक्सपोर्ट

निष्कर्ष

विषय

शीर्ष LLM कोर्स

Python में LLMs का परिचय

LangChain के साथ LLM एप्लिकेशन विकसित करना

Llama 3 के साथ काम करना

प्रौद्योगिकियाँ

विषय

शीर्ष LLM कोर्स

Python में LLMs का परिचय

LangChain के साथ LLM एप्लिकेशन विकसित करना

Llama 3 के साथ काम करना