Fine-tunen van Phi-3.5 op e-commercieclassificatiedataset

Microsoft heeft zich met de introductie van de Phi-3.5-serie naast Meta AI toegevoegd aan het competitieve landschap van grote taalmodellen. Deze serie omvat een klein taalmodel, een vision-taalmodel en maakt gebruik van een Mixture-of-Experts-aanpak om topprestaties te behalen. 

In deze tutorial verkennen we de Microsoft Phi-3.5-familie van modellen. We laden het Phi-3.5-mini-instruct-model en fine-tunen het om e-commerceproducten te classificeren op basis van hun tekstbeschrijvingen. In de laatste stappen laten we zien hoe je de LoRA (Low-Rank Adaptation) met het basismodel samenvoegt en naar Hugging Face pusht. Dit maakt efficiënte cloudimplementatie mogelijk, zodat het model toegankelijk is voor diverse toepassingen.

Volg de cursus Master Large Language Models (LLMs) Concepts en leer over LLM-toepassingen, trainingsmethoden, ethische overwegingen en het nieuwste onderzoek.

Afbeelding door auteur

Introductie van Microsoft Phi-3.5

De Microsoft Phi-3.5-release introduceert drie innovatieve modellen: Phi-3.5-mini, Phi-3.5-vision en de nieuwste toevoeging, Phi-3.5-MoE, een Mixture-of-Experts-model.

Phi-3.5-mini is geoptimaliseerd voor betere meertalige ondersteuning met een indrukwekkende contextlengte van 128K. Ondanks het kleinere formaat levert het prestaties die wedijveren met grotere modellen, dankzij strenge verbeteringen via supervised fine-tuning, proximal policy optimization en direct preference optimization, wat zorgt voor nauwkeurige opvolging van instructies.

Phi-3.5-vision is een geavanceerd, lichtgewicht multimodaal model dat is getraind op datasets bestaande uit synthetische data en gefilterde openbare websites. Het blinkt uit in begrip en redeneren over meerdere frames, waardoor het ideaal is voor gedetailleerde beeldvergelijking, samenvatting/vertelling over meerdere afbeeldingen en videosamenvatting, met brede toepassingsmogelijkheden.

Het opvallende model, Phi-3.5-MoE, beschikt over een Mixture-of-Experts-architectuur met 16 experts en 6,6 miljard actieve parameters. Het biedt uitzonderlijke prestaties met verminderde latentie en sterke veiligheidsmaatregelen, naast uitgebreide meertalige ondersteuning. 

De Phi-3.5-modelfamilie biedt kosteneffectieve, hoogwaardige oplossingen voor de openbroncommunity en stimuleert de ontwikkeling van kleine taalmodellen en generatieve AI.

Wil je meer leren over Phi-3-architectuur, functies en toepassingen? Volg dan de Phi-3 Tutorial: Hands-On With Microsoft’s Smallest AI Model-gids.

Toegang krijgen tot het Microsoft Phi-3.5-model

In deze sectie laden we het Phi-3.5-mini-instruct-model en voeren we modelinference uit op het Kaggle-platform. 

1. Start de sessie met T4x2 GPU ingeschakeld. 

2. Installeer alle benodigde Python-pakketten met het pip-commando.

%%capture
%pip install -U transformers accelerateMogelijk gemaakt door

3. Laad het volledige model en de tokenizer met de Transformers-bibliotheek. 
4. Maak de text-generation-pipeline met model en tokenizer. 

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",
)Mogelijk gemaakt door

5. Maak het bericht met de systeemprompt en gebruikersvraag en zet dit om naar de chatprompt met de chattemplate. 
6. Genereer het antwoord door de prompt aan de pipeline te geven. 

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"])Mogelijk gemaakt door

We kregen een nauwkeurig en gedetailleerd resultaat.

<|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 toMogelijk gemaakt door

7. We kunnen de textgeneration-pipeline zelfs een aangepaste prompt geven met de instructies en een calltranscriptie om te controleren of het model de opdracht van de gebruiker volgt.

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"])Mogelijk gemaakt door

Zoals we zien, presteerde het model behoorlijk goed: het markeerde het gesprek als frauduleus en gaf een uitleg.

 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 theMogelijk gemaakt door

Heb je problemen met het draaien van het model op het Kaggle-platform? Raadpleeg dan het Simple Model Inference of Phi-3.5 Kaggle-notebook. Het bevat een kant-en-klare setup en code met outputs.

Fine-tunen van Microsoft Phi-3.5-mini-instruct

In deze gids leren we de e-commercie-tekstclassificatiedata te laden en te verwerken. We laden ook het model en de tokenizer, evalueren het model op de testdataset vóór het fine-tunen, bouwen de trainer, fine-tunen het model op de trainingsset en testen het model na het fine-tunen.

Ben je nieuw met dit proces? Lees dan zeker onze gids An Introductory Guide to Fine-Tuning LLMs en leer de theorie achter het fine-tunen van LLM’s. 

1. Opzetten

Start het nieuwe Kaggle-notebook met GPU-versnelling ingeschakeld. Zorg er vervolgens voor dat je de Hugging Face- en Weights & Biases-API-token als omgevingsvariabelen hebt ingesteld via de Kaggle secrets.

Installeer alle benodigde Python-pakketten. 

%%capture
%pip install -U bitsandbytes
%pip install -U transformers
%pip install -U accelerate
%pip install -U peft
%pip install -U trlMogelijk gemaakt door

Log in bij de Weights and Biases-service, teken de API-sleutel en start het nieuwe project. 

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"Mogelijk gemaakt door

Laad tot slot alle benodigde Python-pakketten en functies die we gaan gebruiken tijdens het fine-tunen en evalueren.

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_splitMogelijk gemaakt door

2. Het dataset laden en verwerken

Voeg de E-commerce Text Classification-dataset toe aan je notebook, zoals hieronder getoond. De dataset bestaat uit twee kolommen: labels (e-commercecategorieën) en tekstbeschrijvingen van het product.

Laad het CSV-bestand, verwerk het en bekijk de bovenste 5 rijen. 

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()Mogelijk gemaakt door

De dataset bestaat uit de beschrijving van de producten en het categorielabel. 

Shuffle de dataset en selecteer alleen de bovenste 2000 rijen. Dit is een voorbeeldgids, bedoeld om het fine-tunen te versnellen door het model op een beperkte set samples te trainen.

Vervolgens splitsen we de data in train-, evaluatie- en testdatasets. 

# 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:]Mogelijk gemaakt door

We maken twee functies. De functie generate_prompt zet tekstkolommen om in de prompt, inclusief instructies, tekstbeschrijvingen en labels. De functie generate_test_prompt is hetzelfde, maar dan zonder het label.

# 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"])Mogelijk gemaakt door

Zet de pandas-train- en evaluatiedataframes om naar Hugging Face-datasets. 

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

train_data['text'][3]Mogelijk gemaakt door

De tekst bestaat uit systeeminstructies, een tekstbeschrijving van het product en een label. 

3. Het model en de tokenizer laden

Laad het 4-bit gequantiseerde model en de tokenizer van de Hugging Face Hub met behulp van de repository-ID. Stel vervolgens het model en de tokenizer zo in dat ze klaar zijn voor gebruik.

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_idMogelijk gemaakt door

4. Modelevaluatie vóór fine-tunen 

We moeten het basismodel evalueren vóór het fine-tunen om te bepalen of het fine-tunen de resultaten verbetert. Hiervoor maken we een predict-functie die de testdataset neemt en e-commercecategorieën genereert op basis van het product en de tekstbeschrijving. 

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)Mogelijk gemaakt door

We hebben een lijst met voorspelde categorieën, en nu vergelijken we die met de werkelijke categorieën om het modelevaluatierapport te genereren. De functie "evaluate" neemt een lijst met voorspelde en werkelijke categorieën en genereert een gedetailleerd evaluatierapport. Dit rapport bevat de gemiddelde nauwkeurigheid, de individuele nauwkeurigheid per categorie, een classificatierapport en een verwarringsmatrix.

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)Mogelijk gemaakt door

We behaalden een gemiddelde nauwkeurigheid van 65%. Laten we kijken of fine-tunen deze score kan verbeteren.

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]]Mogelijk gemaakt door

5. Het model instellen

Haal de lineaire modelnamen uit het model. 

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)
modulesMogelijk gemaakt door

['gate_up_proj', 'down_proj', 'qkv_proj', 'o_proj']Mogelijk gemaakt door

Gebruik de lineaire modulenaam om de LoRA te maken. We fine-tunen alleen de LoRA en laten de rest van het model ongemoeid om geheugen te besparen en de trainingstijd te verkorten. 

Configureer vervolgens de hyperparameters van het model voor de Kaggle-omgeving. Je kunt deze parameters aanpassen om de nauwkeurigheid te verbeteren en de trainingstijd te verkorten, afhankelijk van je machine. Wil je over elke hyperparameter leren, volg dan de Fine-Tuning Llama 2-tutorial. 

We richten nu een supervised fine-tuning (SFT) trainer in en geven een train- en evaluatiedataset, LoRA-configuratie, trainingsargumenten, tokenizer en model mee. 

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,
    }
)Mogelijk gemaakt door

6. Modeltraining

We gebruiken de .train-functie om het fine-tuneproces te starten. 

# Train model
trainer.train()Mogelijk gemaakt door

De loss is geleidelijk gedaald, en met meer epochs hadden we mogelijk nog betere resultaten behaald. 

Sluit de Weights & Biases-run af om het evaluatierapport te genereren.

wandb.finish()
model.config.use_cache = TrueMogelijk gemaakt door

Je kunt de modelprestaties analyseren door naar de website van Weights & Biases te gaan, je project te selecteren en de trainingsanalyse te bekijken.

Sla het model en de tokenizer lokaal op zodat we ze later kunnen gebruiken voor het samenvoegen van het model en het pushen naar de externe server.

# Save trained model and tokenizer
trainer.save_model(output_dir)
tokenizer.save_pretrained(output_dir)Mogelijk gemaakt door

Deze gids is behoorlijk code-intensief. Zoek je een eenvoudigere oplossing, dan kun je een open-source model fine-tunen met de LlaMA-Factory WebUI Beginner's Guide: Fine-Tuning LLMs-tutorial. Wil je het nóg eenvoudiger zonder zorgen over hardware, dan raden we de Fine-tuning GPT-4o Mini: A Step-by-Step Guide-tutorial aan. Hiermee kun je in de cloud fine-tunen met minimale code.

7. Testen van het model na fine-tunen

Laten we testen of de modelprestaties zijn verbeterd na het fine-tunen. We genereren eerst een lijst met voorspelde labels en geven die aan de evaluate-functie samen met de werkelijke labels. 

y_pred = predict(X_test, model, tokenizer)
evaluate(y_true, y_pred)Mogelijk gemaakt door

De modelnauwkeurigheid verbeterde met ongeveer 32,31%, en de overige prestatie-indicatoren zien er uitstekend uit. Behalve voor de categorie Books wist het model de categorieën vrij nauwkeurig te identificeren.

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]]Mogelijk gemaakt door

Zorg dat je het Kaggle-notebook opslaat door rechtsboven op de knop "Save Version" te klikken. Kies vervolgens voor quick save en wijzig de optie voor opslaan van output zodat ook het modelbestand en alle code worden opgeslagen.

Krijg je problemen tijdens het fine-tunen van het model, raadpleeg dan het Fine-tune Phi-3.5 for Text Classification Kaggle-notebook.

Het samensmelten en exporteren van het gefinetunede model

Om het model samen te voegen en naar Hugging Face te exporteren, maken we eerst een nieuw Kaggle-notebook en voegen we het opgeslagen notebook toe om toegang te krijgen tot het gefinetunede model en de tokenizer. 

Het toevoegen van een ander Kaggle-notebook lijkt op het toevoegen van een dataset en een model. Klik op de knop “+ Add Input”, plak de link van het notebook en druk op de add-knop. 

Stel de Hugging Face API in als omgevingsvariabele via de Kaggle secrets en installeer alle benodigde Python-pakketten voor het laden en samenvoegen van het model.

%%capture
%pip install -U bitsandbytes
%pip install -U transformers
%pip install -U accelerate
%pip install -U peftMogelijk gemaakt door

Stel de variabelen voor het basismodel en het gefinetunede model in met de model-ID en de locatie van de modeladapter.

# 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/"Mogelijk gemaakt door

Laad het volledige model van de Hugging Face Hub, samen met de tokenizer.

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,
)Mogelijk gemaakt door

Voeg het basismodel samen met de adapter met twee regels code. 

# Merge adapter with base model
model = PeftModel.from_pretrained(base_model_reload, fine_tuned_model)
model = model.merge_and_unload()Mogelijk gemaakt door

Om te testen of het model succesvol is samengevoegd, maken we een textgeneration-pipeline met het samengevoegde model en de tokenizer, en geven we een voorbeeldprompt om een respons te genereren.

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())Mogelijk gemaakt door

Het model heeft de productcategorie correct voorspeld. 

HouseholdMogelijk gemaakt door

We slaan het volledige model lokaal op door de modelmap op te geven. 

model_dir = "Phi-3.5-mini-instruct-Ecommerce-Text-Classification"
model.save_pretrained(model_dir)
tokenizer.save_pretrained(model_dir)Mogelijk gemaakt door

Push het opgeslagen model naar de Hugging Face Hub. Log eerst in op de Hugging Face CLI met de API-sleutel die is opgehaald uit Kaggle secrets, en gebruik vervolgens de functie push_to_hub om zowel het model als de tokenizer te pushen.

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)Mogelijk gemaakt door

Er is een nieuwe modelrepository aangemaakt en alle bestanden zijn naar de Hugging Face-modelrepository gepusht.

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

Heb je moeite met het samenvoegen en exporteren van het model, bekijk dan het Phi-3.5 Fine-tuned Adapter to the full model Kaggle-notebook. 

Bekijk ook onze nieuwste tutorial over Fine-tuning Llama 3.2 en lokaal gebruiken: een stapsgewijze gids. In deze tutorial leer je hoe je het model fine-tunet op een aangepaste dataset met gratis GPU’s, het model samenvoegt en naar de Hugging Face Hub exporteert, en het gefinetunede model converteert naar GGUF-formaat zodat het lokaal met de Jan-applicatie kan worden gebruikt.

Conclusie

Grote taalmodellen worden kleiner en efficiënter, wat leidt tot lagere operationele kosten en betere aanpasbaarheid in verschillende domeinen. In deze tutorial hebben we de Phi-3.5 Mini-, Vision- en MoE-modellen verkend. We hebben ook geleerd hoe je toegang krijgt tot Phi-3.5 Mini-modellen met Kaggle Notebooks.

Vervolgens hebben we de modellen gefinetuned op classificatiedata en hun prestaties geëvalueerd, met een aanzienlijke verbetering van 65% naar 86% nauwkeurigheid—een opmerkelijke prestatie. Dergelijke prestaties bereik je niet met alleen RAG of function calling.

Tot slot hebben we de LoRA met het basismodel geïntegreerd en het complete model geëxporteerd naar de Hugging Face Hub, waar het voor iedereen beschikbaar is.

De volgende stap in je leerpad is het bouwen van een project met de lijst 12 LLM Projects For All Levels. Deze bevat LLM-projecten voor beginners, gevorderden, afstudeerders en experts. Elk project bevat broncode, een visuele gids en ondersteunende links.