E-Ticaret Sınıflandırma Veri Kümesinde Phi-3.5’in İnce Ayarı

Microsoft, Phi-3.5 serisini tanıtarak Meta AI ile birlikte büyük dil modelleri alanındaki rekabete katıldı. Bu seri; küçük bir dil modeli, bir görsel-dil modeli içeriyor ve üst düzey performansa ulaşmak için Uzman Karışımı (Mixture-of-Experts) yaklaşımını kullanıyor. 

Bu eğitimde Microsoft Phi-3.5 model ailesini inceleyeceğiz. Phi-3.5-mini-instruct modelini yükleyip metin açıklamalarına dayanarak e-ticaret ürünlerini sınıflandırmak üzere ince ayar yapacağız. Son adımlarda, LoRA’yı (Low-Rank Adaptation) temel modelle nasıl birleştireceğimizi ve Hugging Face’e nasıl yükleyeceğimizi göstereceğiz. Bu sayede verimli bulut dağıtımı mümkün olacak ve model çeşitli uygulamalar için erişilebilir hale gelecek.

Şu kursu alın: Büyük Dil Modelleri (LLM) Kavramları ve LLM uygulamaları, eğitim metodolojileri, etik hususlar ve en güncel araştırmalar hakkında bilgi edinin.

Görsel: Yazar

Microsoft Phi-3.5’e Giriş

Microsoft Phi-3.5 sürümü üç yenilikçi modeli tanıtıyor: Phi-3.5-mini, Phi-3.5-vision ve en yeni ekleme olan Uzman Karışımı (MoE) modeli Phi-3.5-MoE.

Phi-3.5-mini, etkileyici 128K bağlam uzunluğuyla gelişmiş çok dilli destek için optimize edilmiştir. Daha küçük boyutuna rağmen, denetimli ince ayar, yakınsal politika optimizasyonu ve doğrudan tercih optimizasyonu ile yapılan sıkı iyileştirmeler sayesinde, talimatlara hassas uyumu güvenceye alarak daha büyük modellerle yarışan bir performans sunar.

Phi-3.5-vision, sentetik veriler ve filtrelenmiş kamuya açık web sitelerinden oluşan veri kümeleri üzerinde eğitilmiş, son teknoloji, hafif bir çok modlu modeldir. Çok kareli görsel anlama ve akıl yürütmede üstündür; ayrıntılı görsel karşılaştırmaları, çok görselli özetleme/hikâye anlatımı ve video özetleme gibi geniş uygulama alanlarında idealdir.

Öne çıkan model Phi-3.5-MoE, 16 uzman ve 6,6 milyar etkin parametreye sahip bir Uzman Karışımı mimarisi sunar. Düşük gecikme süresi ve güçlü güvenlikle birlikte kapsamlı çok dilli destekle olağanüstü performans sağlar. 

Phi-3.5 model ailesi, açık kaynak topluluğu için uygun maliyetli, yüksek performanslı çözümler sunarak küçük dil modellerini ve üretken yapay zekâyı ileri taşıyor.

Phi-3 mimarisi, özellikleri ve kullanım alanları hakkında bilgi edinmek için Phi-3 Eğitimi: Microsoft’un En Küçük Yapay Zekâ Modeliyle Uygulamalı Çalışma rehberini izleyin.

Microsoft Phi-3.5 Modeline Erişim

Bu bölümde Phi-3.5-mini-instruct modelini yükleyecek ve Kaggle platformunda çıkarım (inference) çalıştıracağız. 

1. Oturumu T4x2 GPU etkin olacak şekilde başlatın. 

2. Gerekli tüm Python paketlerini pip komutuyla yükleyin.

%%capture
%pip install -U transformers accelerateAltyapı:

3. Transformers kütüphanesini kullanarak tam modeli ve belirteçleyiciyi (tokenizer) yükleyin. 
4. text-generation hattını (pipeline) model ve belirteçleyiciyle oluşturun. 

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",
)Altyapı:

5. Sistem komutu ve kullanıcı sorgusuyla ileti oluşturun ve sohbet şablonunu kullanarak sohbet girdisine dönüştürün. 
6. İpucunu (prompt) hat üzerinden vererek yanıt üretin. 

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"])Altyapı:

Doğru ve ayrıntılı bir sonuç elde ettik.

<|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 toAltyapı:

7. Modelin kullanıcının komutlarına uyup uymadığını görmek için, talimatlar ve çağrı dökümü içeren özel bir istemle metin üretim hattını besleyebiliriz.

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"])Altyapı:

Görüldüğü üzere, model görüşmeyi sahtekârlık olarak işaretleyip bir açıklama sunarak oldukça iyi performans gösterdi.

 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 theAltyapı:

Modeli Kaggle platformunda çalıştırırken sorun yaşıyorsanız, önceden yapılandırılmış kurulum ve çıktıların da yer aldığı Phi-3.5’in Basit Model Çıkarımı Kaggle not defterine bakın.

Microsoft Phi-3.5-mini-instruct’a İnce Ayar

Bu rehberde E-ticaret metin sınıflandırma verilerini yükleyip işlemesini öğreneceğiz. Ayrıca modeli ve belirteçleyiciyi yükleyecek, ince ayardan önce testi veri kümesi üzerinde değerlendirecek, eğiticiyi (trainer) oluşturacak, modeli eğitim seti üzerinde ince ayar yapacak ve ince ayardan sonra test edeceğiz.

Süreçte yeniyseniz, LLM’lere İnce Ayara Giriş Rehberi yazımızı okuyarak teoriyi öğrenin. 

1. Kurulum

GPU hızlandırması etkin yeni bir Kaggle not defteri başlatın. Ardından Kaggle secrets kullanarak Hugging Face ve Weights & Biases API belirtecini ortam değişkeni olarak ayarladığınızdan emin olun.

Gerekli tüm Python paketlerini yükleyin. 

%%capture
%pip install -U bitsandbytes
%pip install -U transformers
%pip install -U accelerate
%pip install -U peft
%pip install -U trlAltyapı:

Weights & Biases hizmetine giriş yapın, API anahtarını imzalayın ve yeni projeyi başlatın. 

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"Altyapı:

Son olarak, ince ayar ve değerlendirme sürecinde kullanacağımız tüm Python paketlerini ve işlevleri yükleyin.

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_splitAltyapı:

2. Veri kümesini yükleme ve işleme

E-ticaret Metin Sınıflandırma veri kümesini aşağıda gösterildiği gibi not defterinize ekleyin. Veri kümesi iki sütundan oluşur: etiketler (e-ticaret kategorileri) ve ürünün metin açıklamaları.

CSV dosyasını yükleyin, işleyin ve ilk 5 satıra göz atın. 

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()Altyapı:

Veri kümesi, ürünlerin açıklamalarından ve kategori etiketinden oluşur. 

Veri kümesini karıştırın ve yalnızca ilk 2000 satırı seçin. Bu, sınırlı sayıda örnek üzerinde ince ayar yaparak süreci hızlandırmayı amaçlayan bir örnek rehberdir.

Ardından veriyi eğitim, değerlendirme ve test veri kümelerine böleceğiz. 

# 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:]Altyapı:

İki işlev oluşturacağız. generate_prompt işlevi metin sütunlarını talimatlar, metin açıklamaları ve etiketler dâhil olmak üzere isteme dönüştürecek. generate_test_prompt işlevi aynıdır ancak etiketsizdir.

# 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"])Altyapı:

Pandas eğitim ve değerlendirme veri çerçevelerini Hugging Face veri kümelerine dönüştürün. 

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

train_data['text'][3]Altyapı:

Metin; sistem talimatları, ürünün metin açıklaması ve etiketten oluşur. 

3. Model ve belirteçleyiciyi yükleme

4 bit kuantize modeli ve belirteçleyiciyi Hugging Face Hub’dan depo kimliğini kullanarak yükleyin. Ardından model ve belirteçleyiciyi kullanıma hazır olacak şekilde yapılandırın.

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_idAltyapı:

4. İnce ayardan önce model değerlendirmesi 

İnce ayarın sonuçları iyileştirip iyileştirmediğini anlamak için temel modeli önce değerlendirmemiz gerekir. Bunun için, test veri kümesini alıp ürün ve metin açıklamasına göre e-ticaret kategorileri üreten bir predict işlevi oluşturacağız. 

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)Altyapı:

Elimizde tahmin edilen kategoriler listesi var; şimdi bunları gerçek kategorilerle karşılaştırıp model değerlendirme raporu üreteceğiz. "evaluate" işlevi tahmin ve gerçek kategori listelerini alır ve ayrıntılı bir değerlendirme raporu oluşturur. Bu rapor; ortalama doğruluk, her kategori için bireysel doğruluk, sınıflandırma raporu ve karışıklık matrisini içerir.

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)Altyapı:

Ortalama %65 doğruluk elde ettik. İnce ayarın bu skoru iyileştirip iyileştirmediğine bakalım.

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]]Altyapı:

5. Modeli yapılandırma

Doğrusal modül adlarını modelden çıkarın. 

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)
modulesAltyapı:

['gate_up_proj', 'down_proj', 'qkv_proj', 'o_proj']Altyapı:

LoRA’yı oluşturmak için doğrusal modül adlarını kullanın. Bellekten tasarruf etmek ve eğitimi hızlandırmak için yalnızca LoRA üzerinde ince ayar yapacak, modelin geri kalanını sabit bırakacağız. 

Ardından, Kaggle ortamı için modelin hiperparametrelerini yapılandırın. Makinenize göre bu parametreleri değiştirerek doğruluğu artırabilir ve eğitim süresini azaltabilirsiniz. Her hiperparametre hakkında bilgi edinmek için Llama 2’ye İnce Ayar eğitimine göz atın. 

Şimdi denetimli ince ayar (SFT) eğiticisini kuracak ve eğitim ile değerlendirme veri kümelerini, LoRA yapılandırmasını, eğitim argümanlarını, belirteçleyiciyi ve modeli sağlayacağız. 

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,
    }
)Altyapı:

6. Model eğitimi

.train işlevini kullanarak ince ayar sürecini başlatacağız. 

# Train model
trainer.train()Altyapı:

Kayıp kademeli olarak azaldı ve daha fazla epoch ile daha iyi sonuçlar elde edebilirdik. 

Değerlendirme raporunu oluşturmak için Weights & Biases çalışmasını sonlandırın.

wandb.finish()
model.config.use_cache = TrueAltyapı:

Model performansını analiz etmek için Weights & Biases sitesini ziyaret edip projenizi seçerek eğitim analizini görüntüleyebilirsiniz.

Modeli ve belirteçleyiciyi yerel olarak kaydedin ki daha sonra model birleştirme için kullanıp uzak sunucuya gönderebilelim.

# Save trained model and tokenizer
trainer.save_model(output_dir)
tokenizer.save_pretrained(output_dir)Altyapı:

Bu rehber oldukça kod ağırlıklı. Daha basit bir çözüm arıyorsanız, LlaMA-Factory WebUI Başlangıç Rehberi: LLM’lere İnce Ayar eğitimini izleyerek bir açık kaynak modele ince ayar yapabilirsiniz. Donanım sorunlarıyla uğraşmak istemediğiniz daha da basit bir çözüm için, GPT-4o Mini’ye İnce Ayar: Adım Adım Rehber eğitimini şiddetle öneririz. Bu sayede minimum kodla bulutta ince ayar yapabilirsiniz.

7. İnce ayardan sonra modeli test etme

Model performansının ince ayardan sonra iyileşip iyileşmediğini test edelim. Önce tahmin edilen etiketlerin bir listesini oluşturup gerçek etiketlerle birlikte evaluate işlevine vereceğiz. 

y_pred = predict(X_test, model, tokenizer)
evaluate(y_true, y_pred)Altyapı:

Model doğruluğu yaklaşık %32,31 arttı ve diğer performans metrikleri de harika görünüyor. Books kategorisi dışında, model kategorileri oldukça isabetli şekilde belirledi.

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]]Altyapı:

Kaggle not defterini sağ üstteki "Save Version" düğmesine tıklayarak kaydettiğinizden emin olun. Ardından hızlı kaydetme seçeneğini seçin ve kaydetme çıktısı seçeneğini; model dosyasını ve tüm kodu kapsayacak şekilde değiştirin.

Modelde ince ayar sırasında sorunlarla karşılaşırsanız lütfen Metin Sınıflandırma için Phi-3.5’e İnce Ayar Kaggle not defterine bakın.

İnce Ayarlı Modeli Birleştirme ve Dışa Aktarma

Modeli birleştirip Hugging Face’e dışa aktarmak için önce yeni bir Kaggle not defteri oluşturacak ve kaydedilmiş not defterini ekleyerek ince ayarlı model ve belirteçleyiciye erişeceğiz. 

Başka bir Kaggle not defteri eklemek, veri kümesi ve model eklemeye benzerdir. “+ Add Input” düğmesine tıklayın, not defterinin bağlantısını yapıştırın ve ekle düğmesine basın. 

Kaggle secrets kullanarak Hugging Face API’sini ortam değişkeni olarak ayarlayın ve modeli yükleyip birleştirmek için gerekli tüm Python paketlerini kurun.

%%capture
%pip install -U bitsandbytes
%pip install -U transformers
%pip install -U accelerate
%pip install -U peftAltyapı:

Temel model ve ince ayarlı model değişkenlerini model kimliği ve adaptörün konumuyla ayarlayın.

# 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/"Altyapı:

Tam modeli Hugging Face hub’dan belirteçleyiciyle birlikte yükleyin.

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,
)Altyapı:

Temel modeli adaptörle iki satır kodla birleştirin. 

# Merge adapter with base model
model = PeftModel.from_pretrained(base_model_reload, fine_tuned_model)
model = model.merge_and_unload()Altyapı:

Modelin başarıyla birleştirilip birleştirilmediğini test etmek için, birleştirilmiş model ve belirteçleyiciyle bir metin üretim hattı oluşturacak ve örnek istemi geçirerek yanıt üreteceğiz.

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())Altyapı:

Model, ürün kategorisini doğru şekilde tahmin etti. 

HouseholdAltyapı:

Modeli tam hâliyle yerel olarak, model dizinini vererek kaydedeceğiz. 

model_dir = "Phi-3.5-mini-instruct-Ecommerce-Text-Classification"
model.save_pretrained(model_dir)
tokenizer.save_pretrained(model_dir)Altyapı:

Kaydedilen modeli Hugging Face hub’a gönderin. Önce Kaggle secrets’tan çıkarılan API anahtarıyla Hugging Face CLI’a giriş yapın, ardından hem modeli hem de belirteçleyiciyi göndermek için push_to_hub işlevini kullanın.

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)Altyapı:

Yeni bir model deposu oluşturuldu ve tüm dosyalar Hugging Face model deposuna gönderildi.

Kaynak: kingabzpro/Phi-3.5-mini-instruct-Ecommerce-Text-Classification

Modeli birleştirme ve dışa aktarma konusunda sorun yaşıyorsanız, Phi-3.5 İnce Ayarlı Adaptörü tam modele Kaggle not defterine göz atın. 

Ayrıca en yeni eğitimimize de göz atın: Llama 3.2’ye İnce Ayar ve Yerelde Kullanım: Adım Adım Rehber. Bu eğitimde ücretsiz GPU’larla özel bir veri kümesi üzerinde ince ayar yapmayı, modeli birleştirip Hugging Face Hub’a dışa aktarmayı ve ince ayarlı modeli Jan uygulamasıyla yerelde kullanılabilmesi için GGUF biçimine dönüştürmeyi öğreneceksiniz.

Sonuç

Büyük dil modelleri giderek daha küçük ve verimli hale geliyor; bu da işletim maliyetlerini düşürürken farklı alanlarda uyarlanabilirliği artırıyor. Bu eğitimde Phi-3.5 Mini, Vision ve MoE modellerini inceledik. Ayrıca Kaggle Not Defterlerini kullanarak Phi-3.5 Mini modellere nasıl erişileceğini öğrendik.

Sonrasında modelleri sınıflandırma verileri üzerinde ince ayar yapıp değerlendirdik ve doğruluğu %65’ten %86’ya çıkararak kayda değer bir iyileşme sağladık—bu, tek başına RAG veya fonksiyon çağrısıyla elde edilemeyecek bir başarıdır.

Son olarak, LoRA’yı temel modelle entegre edip tamamını Hugging Face Hub’a aktardık; böylece herkesin kullanımına sunulmuş oldu.

Sıradaki adımınız, şu listedeki projeleri takip ederek bir proje geliştirmek: Her Seviyeye Uygun 12 LLM Projesi. Listede başlangıç, orta, son sınıf ve uzman seviyeleri için LLM projeleri yer alıyor. Her proje; kaynak kod, görsel rehber ve destekleyici bağlantılarla birlikte geliyor.