Fine-tuning di Phi-3.5 sul dataset di classificazione E-commerce

Microsoft è entrata nel competitivo panorama dei large language model, affiancando Meta AI con l’introduzione della serie Phi-3.5. Questa serie include un small language model, un vision language model e adotta un approccio Mixture-of-Experts per raggiungere prestazioni di livello top. 

In questo tutorial esploreremo la famiglia di modelli Microsoft Phi-3.5. Caricheremo il modello Phi-3.5-mini-instruct e lo sottoporremo a fine-tuning per classificare prodotti e-commerce in base alle loro descrizioni testuali. Nei passaggi finali mostreremo come unire la LoRA (Low-Rank Adaptation) al modello base e pubblicarla su Hugging Face. Questo consentirà un deployment cloud efficiente, rendendo il modello accessibile per varie applicazioni.

Segui il corso Master Large Language Models (LLMs) Concepts e scopri applicazioni degli LLM, metodologie di training, considerazioni etiche e le ricerche più recenti.

Immagine dell’autore

Introduzione a Microsoft Phi-3.5

Il rilascio di Microsoft Phi-3.5 introduce tre modelli innovativi: Phi-3.5-mini, Phi-3.5-vision e l’ultima aggiunta, Phi-3.5-MoE, un modello Mixture-of-Experts.

Phi-3.5-mini è ottimizzato per un migliore supporto multilingue con un impressionante contesto da 128K. Nonostante le dimensioni ridotte, offre prestazioni paragonabili a modelli più grandi grazie a rigorosi miglioramenti tramite supervised fine-tuning, proximal policy optimization e direct preference optimization, garantendo una precisa aderenza alle istruzioni.

Phi-3.5-vision è un modello multimodale leggero e all’avanguardia, addestrato su dataset composti da dati sintetici e siti pubblici filtrati. Eccelle nella comprensione e nel reasoning su immagini multi-frame, risultando ideale per confronti dettagliati tra immagini, sintesi/narrazione multi-immagine e sintesi video, con ampie potenzialità applicative.

Il modello di punta, Phi-3.5-MoE, presenta un’architettura Mixture-of-Experts con 16 esperti e 6,6 miliardi di parametri attivi. Offre prestazioni eccezionali con latenza ridotta e solidi meccanismi di sicurezza, oltre a un ampio supporto multilingue. 

La famiglia Phi-3.5 offre soluzioni economicamente vantaggiose e ad alte prestazioni per la comunità open source, facendo progredire i small language model e l’AI generativa.

Per approfondire architettura, funzionalità e applicazioni di Phi-3, segui la guida Phi-3 Tutorial: Hands-On With Microsoft’s Smallest AI Model.

Accesso al modello Microsoft Phi-3.5

In questa sezione caricheremo il modello Phi-3.5-mini-instruct ed eseguiremo l’inferenza sulla piattaforma Kaggle. 

1. Avvia la sessione con GPU T4x2 abilitata. 

2. Installa tutti i pacchetti Python necessari usando il comando pip.

%%capture
%pip install -U transformers accelerateOfferto da

3. Carica l’intero modello e il tokenizer usando la libreria Transformers. 
4. Crea la pipeline di text-generation con modello e 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",
)Offerto da

5. Crea il messaggio con system prompt e query dell’utente e convertilo in chat prompt usando il chat template. 
6. Genera la risposta passando il prompt alla pipeline. 

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"])Offerto da

Abbiamo ottenuto un risultato accurato e dettagliato.

<|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 toOfferto da

7. Possiamo anche fornire alla pipeline di generazione testo un prompt personalizzato con istruzioni e trascrizione della chiamata per verificare se il modello segue il comando dell’utente.

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"])Offerto da

Come si vede, il modello si è comportato molto bene, segnalando la chiamata come fraudolenta e fornendo una spiegazione.

 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 theOfferto da

Se riscontri problemi nell’esecuzione del modello su Kaggle, consulta il notebook Kaggle Simple Model Inference of Phi-3.5. Include una configurazione preimpostata e il codice con gli output.

Fine-tuning di Microsoft Phi-3.5-mini-instruct

In questa guida impareremo a caricare e processare i dati di classificazione testuale E-commerce. Caricheremo anche il modello e il tokenizer, valuteremo il modello sul dataset di test prima del fine-tuning, costruiremo il trainer, effettueremo il fine-tuning sul training set e testeremo il modello dopo il fine-tuning.

Se è la tua prima volta con questo processo, leggi la nostra guida An Introductory Guide to Fine-Tuning LLMs e scopri la teoria dietro il fine-tuning degli LLM. 

1. Configurazione

Avvia un nuovo notebook Kaggle con accelerazione GPU abilitata. Poi assicurati di aver impostato i token API di Hugging Face e Weights & Biases come variabili d’ambiente usando i segreti di Kaggle.

Installa tutti i pacchetti Python necessari. 

%%capture
%pip install -U bitsandbytes
%pip install -U transformers
%pip install -U accelerate
%pip install -U peft
%pip install -U trlOfferto da

Accedi al servizio Weights & Biases, firma la chiave API e avvia un nuovo progetto. 

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"Offerto da

Infine, carica tutti i pacchetti e le funzioni Python necessarie che useremo durante il processo di fine-tuning e valutazione.

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_splitOfferto da

2. Caricamento e processamento del dataset

Aggiungi il dataset E-commerce Text Classification al tuo notebook, come mostrato sotto. Il dataset consiste in due colonne: etichette (categorie e-commerce) e descrizioni testuali del prodotto.

Carica il file CSV, processalo e visualizza le prime 5 righe. 

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()Offerto da

Il dataset è composto dalla descrizione dei prodotti e dall’etichetta di categoria. 

Mescola il dataset e seleziona solo le prime 2000 righe. Questa è una guida d’esempio, pensata per velocizzare il fine-tuning addestrando il modello su un set limitato di campioni.

Successivamente divideremo i dati in train, evaluation e test. 

# 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:]Offerto da

Creeremo due funzioni. La funzione generate_prompt convertirà le colonne di testo in un prompt includendo istruzioni, descrizioni testuali ed etichette. La funzione generate_test_prompt fa lo stesso ma senza l’etichetta.

# 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"])Offerto da

Converte i dataframe di train ed evaluation di pandas in dataset di 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]Offerto da

Il testo include istruzioni di sistema, una descrizione del prodotto e un’etichetta. 

3. Caricamento del modello e del tokenizer

Carica il modello quantizzato a 4 bit e il tokenizer dall’Hugging Face Hub usando l’ID del repository. Poi configura modello e tokenizer affinché siano pronti all’uso.

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_idOfferto da

4. Valutazione del modello prima del fine-tuning 

Dobbiamo valutare il modello base prima del fine-tuning per stabilire se il fine-tuning migliora o meno i risultati. A tal fine, creeremo una funzione predict che prende il dataset di test e genera le categorie e-commerce in base al prodotto e alla descrizione testuale. 

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)Offerto da

Abbiamo una lista di categorie previste e ora le confronteremo con le categorie reali per generare il report di valutazione del modello. La funzione "evaluate" prende una lista di categorie previste e reali e genera un report di valutazione dettagliato. Il report include l’accuratezza media, l’accuratezza individuale per ogni categoria, un classification report e una confusion matrix.

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)Offerto da

Abbiamo raggiunto un’accuratezza media del 65%. Vediamo se il fine-tuning può migliorare questo punteggio.

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]]Offerto da

5. Configurazione del modello

Estrai dal modello il nome del modulo lineare. 

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)
modulesOfferto da

['gate_up_proj', 'down_proj', 'qkv_proj', 'o_proj']Offerto da

Usa il nome del modulo lineare per creare la LoRA. Effettueremo il fine-tuning solo della LoRA lasciando invariato il resto del modello, per risparmiare memoria e accelerare l’addestramento. 

Poi configura gli iperparametri del modello per l’ambiente Kaggle. Puoi modificarli per migliorare l’accuratezza e ridurre i tempi di training in base alla tua macchina. Per approfondire ciascun iperparametro, segui il tutorial Fine-Tuning Llama 2. 

Ora imposteremo un trainer per supervised fine-tuning (SFT) fornendo dataset di train ed evaluation, configurazione LoRA, argomenti di training, tokenizer e modello. 

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,
    }
)Offerto da

6. Addestramento del modello

Useremo la funzione .train per avviare il processo di fine-tuning. 

# Train model
trainer.train()Offerto da

La loss è diminuita gradualmente e avremmo potuto ottenere risultati ancora migliori con più epoche. 

Termina la run di Weights & Biases per generare il report di valutazione.

wandb.finish()
model.config.use_cache = TrueOfferto da

Puoi analizzare le prestazioni del modello visitando il sito di Weights & Biases, selezionando il tuo progetto e visualizzando l’analisi dell’addestramento.

Salva localmente il modello e il tokenizer, così potremo usarli più tardi per il merging e per il push su un server remoto.

# Save trained model and tokenizer
trainer.save_model(output_dir)
tokenizer.save_pretrained(output_dir)Offerto da

Questa guida è piuttosto ricca di codice. Se cerchi una soluzione più semplice, puoi effettuare il fine-tuning di un modello open source seguendo il tutorial LlaMA-Factory WebUI Beginner's Guide: Fine-Tuning LLMs. Per una soluzione ancora più semplice in cui non devi preoccuparti dell’hardware, consigliamo caldamente il tutorial Fine-tuning GPT-4o Mini: A Step-by-Step Guide. Ti aiuterà a fare fine-tuning nel cloud con pochissimo codice.

7. Test del modello dopo il fine-tuning

Verifichiamo se le prestazioni del modello sono migliorate dopo il fine-tuning. Genereremo innanzitutto un elenco di etichette previste e lo passeremo alla funzione evaluate insieme alle etichette reali. 

y_pred = predict(X_test, model, tokenizer)
evaluate(y_true, y_pred)Offerto da

L’accuratezza del modello è migliorata di circa il 32,31%, e anche il resto delle metriche appare ottimo. A parte la categoria Books, il modello è stato in grado di identificare le categorie con buona precisione.

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]]Offerto da

Assicurati di salvare il notebook Kaggle cliccando sul pulsante "Save Version" in alto a destra. Poi seleziona l’opzione di salvataggio rapido e modifica l’opzione di salvataggio output per includere il salvataggio del file del modello e di tutto il codice.

Se riscontri problemi durante il fine-tuning del modello, consulta il notebook Kaggle Fine-tune Phi-3.5 for Text Classification.

Unione ed esportazione del modello fine-tunato

Per unire ed esportare il modello su Hugging Face, creeremo innanzitutto un nuovo notebook Kaggle e aggiungeremo il notebook salvato per accedere al modello e al tokenizer sottoposti a fine-tuning. 

Aggiungere un altro notebook Kaggle è simile ad aggiungere un dataset o un modello. Clicca sul pulsante “+ Add Input”, incolla il link del notebook e poi premi il pulsante add. 

Imposta l’API di Hugging Face come variabile d’ambiente usando i segreti di Kaggle e installa tutti i pacchetti Python necessari per il caricamento e l’unione del modello.

%%capture
%pip install -U bitsandbytes
%pip install -U transformers
%pip install -U accelerate
%pip install -U peftOfferto da

Imposta le variabili del modello base e del modello fine-tunato con l’ID del modello e il percorso dell’adapter del modello.

# 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/"Offerto da

Carica il modello completo dall’Hugging Face Hub insieme al 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,
)Offerto da

Unisci il modello base con l’adapter in due righe di codice. 

# Merge adapter with base model
model = PeftModel.from_pretrained(base_model_reload, fine_tuned_model)
model = model.merge_and_unload()Offerto da

Per testare se l’unione è avvenuta correttamente, creeremo una pipeline di generazione testo con il modello unito e il tokenizer, e passeremo un prompt di esempio per generare la risposta.

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())Offerto da

Il modello ha previsto correttamente la categoria del prodotto. 

HouseholdOfferto da

Salveremo localmente il modello completo indicando la directory del modello. 

model_dir = "Phi-3.5-mini-instruct-Ecommerce-Text-Classification"
model.save_pretrained(model_dir)
tokenizer.save_pretrained(model_dir)Offerto da

Esegui il push del modello salvato su Hugging Face Hub. Prima effettua il login alla CLI di Hugging Face usando la chiave API estratta dai segreti di Kaggle, poi usa la funzione push_to_hub per caricare sia il modello che il tokenizer.

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)Offerto da

È stato creato un nuovo repository di modello e tutti i file sono stati caricati nel repository di Hugging Face.

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

Se hai problemi a unire il modello ed esportarlo, dai un’occhiata al notebook Kaggle Phi-3.5 Fine-tuned Adapter to the full model. 

Dai anche un’occhiata al nostro nuovissimo tutorial su Fine-tuning Llama 3.2 e utilizzo in locale: guida step-by-step. In questo tutorial imparerai a effettuare il fine-tuning del modello su un dataset personalizzato usando GPU gratuite, unire ed esportare il modello su Hugging Face Hub e convertire il modello fine-tunato in formato GGUF per usarlo in locale con l’app Jan.

Conclusione

I large language model stanno diventando più piccoli ed efficienti, con costi operativi ridotti e migliore adattabilità in vari settori. In questo tutorial abbiamo esplorato i modelli Phi-3.5 Mini, Vision e MoE. Abbiamo anche visto come accedere ai modelli Phi-3.5 Mini usando i Kaggle Notebooks.

Successivamente abbiamo effettuato il fine-tuning sui dati di classificazione e valutato le prestazioni, ottenendo un miglioramento significativo dall’accuratezza del 65% all’86%—un risultato notevole. Prestazioni simili non sono ottenibili con il solo RAG o function calling.

Infine, abbiamo integrato la LoRA con il modello base ed esportato il modello completo su Hugging Face Hub, dove è disponibile per tutti.

Il prossimo passo del tuo percorso è costruire un progetto seguendo l’elenco di 12 progetti LLM per tutti i livelli. Include progetti LLM per principianti, studenti intermedi, laureandi e professionisti. Ogni progetto arriva con codice sorgente, guida visiva e link di supporto.