Tutorial su Mistral 7B: guida passo passo all'uso e al fine-tuning di Mistral 7B

Accedere a Mistral 7B

Possiamo accedere a Mistral 7B su HuggingFace, Vertex AI, Replicate, Sagemaker Jumpstart e Baseten.

C'è anche un modo nuovo e migliore per accedere al modello tramite la nuova funzionalità di Kaggle chiamata Models. Significa che non devi scaricare il modello o il dataset; puoi iniziare l'inferenza o il fine-tuning in pochi minuti.

In questa sezione impareremo a caricare il modello di Kaggle ed eseguire l'inferenza in pochi minuti.

Prima di iniziare, dobbiamo aggiornare le librerie essenziali per evitare l'errore KeyError: 'mistral.

!pip install -q -U transformers
!pip install -q -U accelerate
!pip install -q -U bitsandbytes

Dopodiché, creeremo una quantizzazione a 4 bit con configurazione di tipo NF4 utilizzando BitsAndBytes per caricare il nostro modello in precisione a 4 bit. Ci aiuterà a caricare il modello più velocemente e a ridurre l'impronta di memoria, così da poterlo eseguire su Google Colab o GPU consumer.

from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig, pipeline
import torch

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

Ora vedremo come aggiungere il modello Mistral 7B al nostro Notebook di Kaggle.

Immagine da Mistral | Kaggle

1. Clicca sul pulsante “+Add Models” nel pannello di destra.
2. Cerca il tuo modello e clicca sul pulsante con il segno più per aggiungerlo.
3. Seleziona la variante corretta “7b-v0.1-hf” e la versione.
4. Dopodiché, copia il percorso della directory e aggiungilo al tuo notebook.

Ora caricheremo il modello e il tokenizer usando la libreria Transformers.

model_name = "/kaggle/input/mistral/pytorch/7b-v0.1-hf/1"

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
        model_name,
        load_in_4bit=True,
        quantization_config=bnb_config,
        torch_dtype=torch.bfloat16,
        device_map="auto",
        trust_remote_code=True,
    )

Per semplificarci la vita, useremo la funzione pipeline della libreria Transformers per generare la risposta a partire dal prompt.

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

Forniremo quindi il prompt all'oggetto pipeline e imposteremo parametri aggiuntivi per creare il numero massimo di token e migliorare la risposta.

prompt = "As a data scientist, can you explain the concept of regularization in machine learning?"

sequences = pipe(
    prompt,
    do_sample=True,
    max_new_tokens=100, 
    temperature=0.7, 
    top_k=50, 
    top_p=0.95,
    num_return_sequences=1,
)
print(sequences[0]['generated_text'])

Come possiamo vedere, Mistral 7B ha generato risultati corretti spiegando il processo di regolarizzazione nel machine learning.

As a data scientist, can you explain the concept of regularization in machine learning?

Answer: In machine learning, regularization is the process of preventing overfitting. Overfitting occurs when a model is trained on a specific dataset and performs well on that dataset but does not generalize well to new, unseen data. Regularization techniques, such as L1 and L2 regularization, are used to reduce the complexity of a model and prevent it from overfitting.

Puoi duplicare ed eseguire il codice usando il notebook di Kaggle per la inferenza a 4 bit di Mistral 7B.

Nota: Kaggle fornisce memoria GPU sufficiente per caricare il modello anche senza quantizzazione a 4 bit. Puoi seguire il notebook Simple Inference di Mistral 7B per vedere come si fa.

Fine-tuning di Mistral 7B

In questa sezione, seguiremo passaggi simili alla guida Fine-Tuning di LLaMA 2: guida passo passo alla personalizzazione del Large Language Model per fare fine-tuning del modello Mistral 7B sul nostro dataset preferito guanaco-llama2-1k. Puoi anche leggere la guida per saperne di più su PEFT, quantizzazione a 4 bit, QLoRA e SFT.

Configurazione

Aggiorneremo e installeremo le librerie Python necessarie.

%%capture
%pip install -U bitsandbytes
%pip install -U transformers
%pip install -U peft
%pip install -U accelerate
%pip install -U trl

Dopodiché, caricheremo i moduli necessari per un fine-tuning efficace del modello.

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig,HfArgumentParser,TrainingArguments,pipeline, logging
from peft import LoraConfig, PeftModel, prepare_model_for_kbit_training, get_peft_model
import os,torch, wandb
from datasets import load_dataset
from trl import SFTTrainer

Nota che stiamo usando un Notebook Kaggle per fare fine-tuning del nostro modello. Archivieremo in modo sicuro le chiavi API cliccando sul pulsante "Add-ons" e selezionando l'opzione "Secret". Per accedere all'API in un notebook, copieremo ed eseguiremo lo snippet come mostrato di seguito.

Nel nostro caso, salveremo le chiavi API di Hugging Face e di Weights and Biases e le accederemo nel notebook di Kaggle.

from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()
secret_hf = user_secrets.get_secret("HUGGINGFACE_TOKEN")
secret_wandb = user_secrets.get_secret("wandb")

Useremo l'API di Hugging Face per salvare e pubblicare il modello sull'Hugging Face Hub.

!huggingface-cli login --token $secret_hf

Per monitorare le prestazioni dell'LLM, inizializzeremo gli esperimenti su Weights and Biases tramite API.

wandb.login(key = secret_wandb)
run = wandb.init(
    project='Fine tuning mistral 7B', 
    job_type="training", 
    anonymous="allow"
)

In questa sezione imposteremo il modello di base, il dataset e il nuovo nome del modello. Il nome del nuovo modello sarà usato per salvare il modello con fine-tuning.

Nota: se stai usando la versione gratuita di Colab, dovresti caricare la versione sharded del modello (someone13574/Mistral-7B-v0.1-sharded).

Puoi anche caricare il modello dall'Hugging Face Hub usando il nome del modello base: mistralai/Mistral-7B-v0.1

base_model = "/kaggle/input/mistral/pytorch/7b-v0.1-hf/1"
dataset_name = "mlabonne/guanaco-llama2-1k"
new_model = "mistral_7b_guanaco"

Caricamento dei dati

Ora caricheremo il dataset dall'Hugging Face Hub e visualizzeremo la 100ª riga.

#Importing the dataset
dataset = load_dataset(dataset_name, split="train")
dataset["text"][100]

Caricamento del modello Mistral 7B

Ora caricheremo un modello in precisione a 4 bit da Kaggle per un addestramento più rapido. Questo passaggio è necessario se vuoi caricare e fare fine-tuning del modello su una GPU consumer.

bnb_config = BitsAndBytesConfig(  
    load_in_4bit= True,
    bnb_4bit_quant_type= "nf4",
    bnb_4bit_compute_dtype= torch.bfloat16,
    bnb_4bit_use_double_quant= False,
)
model = AutoModelForCausalLM.from_pretrained(
        base_model,
        load_in_4bit=True,
        quantization_config=bnb_config,
        torch_dtype=torch.bfloat16,
        device_map="auto",
        trust_remote_code=True,
)
model.config.use_cache = False # silence the warnings
model.config.pretraining_tp = 1
model.gradient_checkpointing_enable()

Caricamento del Tokenizer

Successivamente, caricheremo il tokenizer e lo configureremo per correggere il problema con fp16.

tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)
tokenizer.padding_side = 'right'
tokenizer.pad_token = tokenizer.eos_token
tokenizer.add_eos_token = True
tokenizer.add_bos_token, tokenizer.add_eos_token

Aggiunta dell'adapter al layer

Nel prossimo passaggio, includeremo un layer adapter nel nostro modello. Questo ci permetterà di fare fine-tuning usando un numero ridotto di parametri, rendendo l'intero processo più veloce ed efficiente in memoria. Per comprendere meglio i parametri, puoi fare riferimento alla documentazione ufficiale di PEFT.

model = prepare_model_for_kbit_training(model)
peft_config = LoraConfig(
    lora_alpha=16,
    lora_dropout=0.1,
    r=64,
    bias="none",
    task_type="CAUSAL_LM",
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj","gate_proj"]
)
model = get_peft_model(model, peft_config)

Iperparametri

È fondamentale impostare gli iperparametri giusti. Puoi conoscere ogni iperparametro leggendo il tutorial Fine-Tuning di LLaMA 2.

training_arguments = TrainingArguments(
    output_dir="./results",
    num_train_epochs=1,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=1,
    optim="paged_adamw_32bit",
    save_steps=25,
    logging_steps=25,
    learning_rate=2e-4,
    weight_decay=0.001,
    fp16=False,
    bf16=False,
    max_grad_norm=0.3,
    max_steps=-1,
    warmup_ratio=0.03,
    group_by_length=True,
    lr_scheduler_type="constant",
    report_to="wandb"
)

Parametri SFT

La libreria TRL di HuggingFace offre un'API intuitiva che consente di creare e addestrare modelli di Supervised fine-tuning (SFT) sul tuo dataset con il minimo sforzo di coding. Forniremo all'SFT Trainer i componenti necessari, come modello, dataset, configurazione Lora, tokenizer e parametri di training.

trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,
    peft_config=peft_config,
    max_seq_length= None,
    dataset_text_field="text",
    tokenizer=tokenizer,
    args=training_arguments,
    packing= False,
)

Addestramento del modello

Dopo aver configurato tutto, alleneremo il nostro modello.

trainer.train()

Nota che stai usando la versione T4 x2 della GPU, che può ridurre il tempo di addestramento a 1 ora e 30 minuti.

Salvataggio del modello con fine-tuning

Infine, salveremo l'adapter pre-addestrato e concluderemo l'esecuzione W&B.

trainer.model.save_pretrained(new_model)
wandb.finish()
model.config.use_cache = True

Possiamo caricare facilmente il nostro modello sull'Hugging Face Hub con una sola riga di codice, così da poterlo accedere da qualsiasi macchina.

trainer.model.push_to_hub(new_model, use_temp_dir=False)

Valutazione del modello

Puoi visualizzare le metriche di sistema e le prestazioni del modello andando su wandb.ai e controllando la run recente.

Immagine da wandb.ai

Per eseguire l'inferenza del modello, dobbiamo fornire sia gli oggetti modello sia tokenizer alla pipeline. Poi possiamo fornire il prompt in stile dataset all'oggetto pipeline.

logging.set_verbosity(logging.CRITICAL)

prompt = "How do I find true love?"
pipe = pipeline(task="text-generation", model=model, tokenizer=tokenizer, max_length=200)
result = pipe(f"<s>[INST] {prompt} [/INST]")
print(result[0]['generated_text'])

Generiamo la risposta per un altro prompt.

prompt = "What is Datacamp Career track?"
result = pipe(f"<s>[INST] {prompt} [/INST]")
print(result[0]['generated_text'])

Sembra che stiamo ottenendo risposte perfette alle nostre domande semplici.

Link importanti per Mistral 7B:

• Mistral 7B Notebook di fine-tuning
• Mistral 7B Modello con fine-tuning

Immagine da Mistral 7B 4bit QLoRA Fine-tuning | Kaggle

Link importanti per Mistral 7B Instruct:

• Mistral 7B Notebook di fine-tuning Instruct

Mistral 7B Modello Instruct con fine-tuning

Merge dell'adapter

In questa sezione, caricheremo il modello base e collegheremo l'adapter usando PeftModel, eseguiremo l'inferenza, fonderemo i pesi del modello e lo pubblicheremo sull'Hugging Face Hub.

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

Caricare il modello base con adapter

Per prima cosa ricaricheremo il modello base e l'adapter con fine-tuning usando peft. La funzione seguente collegherà l'adapter al modello base.

base_model_reload = AutoModelForCausalLM.from_pretrained(
        base_model,
        return_dict=True,
        low_cpu_mem_usage=True,
        device_map="auto",
        trust_remote_code=True,
)

model = PeftModel.from_pretrained(base_model_reload, new_model)

Ricaricare il tokenizer

Carica il tokenizer del modello base e correggi il problema con fp16.

tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "right"

Inferenza

Crea una pipeline di inferenza con tokenizer e modello.

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

Fornisci il prompt ed esegui la pipeline per generare la risposta.

prompt = "How become a DataCamp certified data professional"

sequences = pipe(
    f"<s>[INST] {prompt} [/INST]",
    do_sample=True,
    max_new_tokens=100, 
    temperature=0.7, 
    top_k=50, 
    top_p=0.95,
    num_return_sequences=1,
)
print(sequences[0]['generated_text'])

Pubblicare il modello con fine-tuning

Ora fonderemo l'adapter con il modello base, così potrai usare direttamente il modello con fine-tuning, come l'originale Mistral 7B, ed eseguire l'inferenza. Per farlo, useremo la funzione merge_and_unload.

Dopo il merge del modello, pubblicheremo sia il tokenizer sia il modello sull'Hugging Face Hub. Puoi anche seguire il notebook Kaggle se ti blocchi da qualche parte.

model = model.merge_and_unload()

model.push_to_hub(new_model, use_temp_dir=False)
tokenizer.push_to_hub(new_model, use_temp_dir=False)

Immagine da kingabzpro/mistral_7b_guanaco

Come puoi vedere, invece del solo adapter, ora abbiamo un modello completo di dimensioni 13,98 GB.

Immagine da kingabzpro/mistral_7b_guanaco

Accedere al modello con fine-tuning

Per mostrare che possiamo caricare ed eseguire l'inferenza senza l'aiuto del modello base, caricheremo il modello con fine-tuning dall'Hugging Face Hub ed eseguiremo l'inferenza.

from transformers import pipeline


pipe = pipeline(
    "text-generation", 
    model = "kingabzpro/mistral_7b_guanaco",
    device_map="auto"
)

prompt = "How do I become a data engineer in 6 months?"

sequences = pipe(
    f"<s>[INST] {prompt} [/INST]",
    do_sample=True,
    max_new_tokens=200, 
    temperature=0.7, 
    top_k=50, 
    top_p=0.95,
    num_return_sequences=1,)

print(sequences[0]['generated_text'])

Conclusione

Mistral 7B rappresenta un entusiasmante progresso nelle capacità dei large language model. Grazie a innovazioni come la Grouped-query Attention e la Sliding Window Attention, raggiunge prestazioni all'avanguardia restando abbastanza efficiente da poter essere distribuito.

In questo tutorial abbiamo imparato come accedere al modello Mistral 7B su Kaggle. Inoltre, abbiamo visto come fare fine-tuning del modello su un piccolo dataset e fondere l'adapter con il modello base.

Questa guida è una risorsa completa sia per gli appassionati di machine learning sia per chi è alle prime armi e vuole sperimentare e addestrare un large language model su GPU consumer.

Se sei nuovo ai large language model, ti consigliamo il corso Master LLMs Concepts. Per chi è interessato a iniziare una carriera nell'intelligenza artificiale, iscriversi allo skill track AI Fundamentals è un ottimo primo passo.

Risorse

• Blog ufficiale
• GitHub
• Articolo di ricerca
• Hugging Face
• Ollama