Corso
Sviluppare applicazioni LLM con LangChain
3 ore
51.9K
È un momento entusiasmante nel mondo dell'IA. Grandi aziende come Google, Meta e Twitter stanno puntando molto sull'open-source dei loro large language model (LLM). Di recente, il team di Google DeepMind ha lanciato Gemma, una famiglia di LLM leggeri e open-source costruiti sulla stessa ricerca e tecnologia usate per creare i modelli Gemini di Google.
Immagine Fonte
Qui vedremo i modelli Gemma, come accedervi usando GPU e TPU nel cloud e come addestrare l'ultimo modello Gemma 7b-it su un dataset di role-play.
Capire Gemma di Google
Gemma (dal latino per “pietra preziosa”) è una famiglia di modelli open di tipo text-to-text, decoder-only, sviluppati da vari team di Google, in particolare Google DeepMind. Si ispira ai modelli Gemini ed è progettata per essere leggera e compatibile con tutti i principali framework.
Google ha rilasciato i pesi del modello in due dimensioni, Gemma 2B e Gemma 7B, disponibili sia in versione pre-addestrata sia con istruzioni (instruction-tuned), come Gemma 2B-it e Gemma 7B-it.
Come sappiamo, Gemma condivide componenti tecniche simili con Gemini, raggiungendo prestazioni best-in-class per le rispettive dimensioni rispetto ad altri modelli open come Llama-2 di Meta. Ha superato Llama-2 in tutti i benchmark per LLM.
Immagine Fonte
Gemma supporta un'ampia varietà di strumenti e sistemi, inclusi tool multi-framework come Keras 3.0, PyTorch nativo, JAX e Transformers di Hugging Face. Funziona anche su dispositivi diffusi come laptop, desktop, IoT, mobile e cloud.
Ora puoi eseguire inferenza e supervised fine-tuning (SFT) su Cloud TPU gratuiti usando il tuo framework di machine learning preferito, come Keras 3.0.
Google ha anche introdotto, insieme a Gemma, un Responsible Generative AI Toolkit per offrire linee guida, strumenti essenziali e metodi di classificazione della sicurezza, aiutando gli sviluppatori a creare applicazioni di IA più sicure.
Se sei alle prime armi con il mondo dell'IA e degli LLM, ti consigliamo lo skill track AI Fundamentals. Ti fornirà conoscenze pratiche su temi popolari come ChatGPT, large language model, IA generativa e altro ancora.
Come accedere al modello Gemma di Google
Accedere a Gemma è semplicissimo: puoi iniziare a usarlo gratis su HuggingChat e Poe. Puoi anche usarlo in locale scaricando i pesi del modello da Hugging Face e utilizzando GPT4ALL o LMStudio.
In questa sezione impareremo a caricare il modello Gemma ed eseguire l'inferenza usando le GPU e le TPU gratuite fornite dalla piattaforma Kaggle.
Eseguire l'inferenza di Gemma su TPU
Puoi andare su Keras/Gemma, scorrere verso il basso, selezionare la variante di modello “gemma_instruct_2b_en” e fare clic sul pulsante “New Notebook”. Si aprirà un Cloud Notebook con il modello Gemma nella directory di input.
Seleziona l'acceleratore “TPU VM v3-8” andando nel pannello di destra e scorrendo verso il basso.
Assicurati di aver installato e aggiornato tutte le librerie Python necessarie.
!pip install -q tensorflow-cpu
!pip install -q -U keras-nlp tensorflow-hub
!pip install -q -U keras>=3
!pip install -q -U tensorflow-textPer verificare il numero di TPU disponibili, puoi usare la libreria `jax` e la funzione `device` per visualizzare i dispositivi TPU. Abbiamo accesso a 8 TPU.
import jax
jax.devices()[TpuDevice(id=0, process_index=0, coords=(0,0,0), core_on_chip=0),
TpuDevice(id=1, process_index=0, coords=(0,0,0), core_on_chip=1),
TpuDevice(id=2, process_index=0, coords=(1,0,0), core_on_chip=0),
TpuDevice(id=3, process_index=0, coords=(1,0,0), core_on_chip=1),
TpuDevice(id=4, process_index=0, coords=(0,1,0), core_on_chip=0),
TpuDevice(id=5, process_index=0, coords=(0,1,0), core_on_chip=1),
TpuDevice(id=6, process_index=0, coords=(1,1,0), core_on_chip=0),
TpuDevice(id=7, process_index=0, coords=(1,1,0), core_on_chip=1)]Ora abiliteremo la TPU per Keras 3 impostando `jax` come backend di Keras.
import os
os.environ["KERAS_BACKEND"] = "jax"Dopo la configurazione iniziale, accedere al modello Gemma e generare una risposta è piuttosto semplice. Useremo la libreria `keras_nlp` per caricare il modello da Kaggle e poi fornire il prompt alla funzione `generate`.
import keras
import keras_nlp
model_name = "/kaggle/input/gemma/keras/gemma_instruct_2b_en/2"
gemma_lm = keras_nlp.models.GemmaCausalLM.from_preset(model_name)
prompt = "Can you share an interesting fact about Leonardo da Vinci?"
gemma_lm.generate(prompt, max_length=100)Ecco il risultato:
"Can you share an interesting fact about Leonardo da Vinci?\n\nSure, here's an interesting fact about Leonardo da Vinci:\n\nLeonardo da Vinci was born in a village called Vinci, Italy, which is now part of the city of Florence."
Puoi facilmente eseguire il notebook Kaggle (Gemma-2B-V2 Simple Inference on TPU) e iniziare a generare risposte usando TPU gratuite.
Eseguire l'inferenza di Gemma su GPU
Ora impareremo a generare la risposta usando GPU e un framework transformer invece di Keras.
Puoi andare su google/gemma, scorrere verso il basso, selezionare transformers, scegliere la variante di modello “7b-it” e fare clic sul pulsante “New Notebook”. Questo aprirà un Cloud Notebook con la versione corretta del modello Gemma nella directory di input.
Nota: puoi anche scorrere più in basso nella pagina per accedere alla sezione di inferenza. Qui puoi testare tutti i tipi di varianti di Gemma fornendo un prompt e generando la risposta. È veloce e comodo.
Nel nuovo notebook, cambia il titolo e poi imposta l'acceleratore su GPT T4 x2.
Installa e aggiorna tutti i pacchetti Python necessari.
%%capture
%pip install -U bitsandbytes
%pip install -U transformers
%pip install -U accelerateNon possiamo caricare l'intero modello Gemma 7b-it sulle GPU di Kaggle a causa della VRAM limitata. Per risolvere questo problema caricheremo il modello usando la quantizzazione a 4 bit con configurazione di tipo NF4 tramite BitsAndBytes. Carichiamo anche il tokenizer.
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, AutoConfig
modelName = "/kaggle/input/gemma/transformers/7b-it/2"
bnbConfig = BitsAndBytesConfig(
load_in_4bit = True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.bfloat16,
)
model = AutoModelForCausalLM.from_pretrained(
modelName,
device_map = "auto",
quantization_config=bnbConfig
)
tokenizer = AutoTokenizer.from_pretrained(modelName)Crea un semplice template di prompt con System, User e AI. Abbiamo chiesto al modello di generare il codice per visualizzare il pattern a stella in Python.
Passa il prompt finale a un tokenizer e poi al modello per generare una previsione. Decodificheremo quindi tali previsioni e convertiremo la risposta in una stringa. Infine useremo la funzione Markdown per visualizzare la risposta in stile Markdown.
from IPython.display import Markdown, display
system = "You are a skilled software engineer who consistently produces high-quality Python code."
user = "Write a Python code to display text in a star pattern."
prompt = f"System: {system} \n User: {user} \n AI: "
inputs = tokenizer(prompt, return_tensors='pt', padding=True, truncation=True).to("cuda")
outputs = model.generate(**inputs, max_length=500, num_return_sequences=1)
text = tokenizer.decode(outputs[0], skip_special_tokens=True)
Markdown(text.split("AI:")[1])Come possiamo vedere, Gemma 7b-it ha fatto un ottimo lavoro.
Puoi eseguire il codice in autonomia clonando il notebook Kaggle Gemma-7B Simple Inference on GPU.
Come fare fine-tuning di Gemma di Google: guida passo passo
In questa sezione impareremo a fare fine-tuning del modello Gemma 7b-it sul dataset hieunguyenminh/roleplay. Useremo come acceleratore la GPU P100 di Kaggle.
Leggi la nostra guida, Guida introduttiva al fine-tuning degli LLM, per capire ogni passaggio nel dettaglio.
Impostazione
È importante installare e aggiornare tutti i pacchetti Python necessari per evitare errori.
%%capture
%pip install -U bitsandbytes
%pip install -U transformers
%pip install -U peft
%pip install -U accelerate
%pip install -U trl
%pip install -U datasetsCarica tutti i pacchetti che useremo per caricare dataset, modello e tokenizer ed eseguire supervised fine-tuning (SFT) e inferenza.
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 SFTTrainerDefinisci i nomi per il modello base e il dataset, oltre al nome del modello con fine-tuning, che caricheremo in seguito su Hugging Face Hub.
Queste variabili verranno utilizzate in varie fasi, come il caricamento di dataset e modello, la tokenizzazione, il training e il salvataggio del modello.
base_model = "/kaggle/input/gemma/transformers/7b-it/2"
dataset_name = "hieunguyenminh/roleplay"
new_model = "gemma-7b-it-v2-role-play"Login alla CLI di Hugging Face
Caricheremo la chiave API di Hugging Face dai segreti di Kaggle (variabili d'ambiente).
from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()
secret_hf = user_secrets.get_secret("HUGGINGFACE_TOKEN")Usa la chiave API per accedere alla CLI di Hugging Face. Questo ci consentirà di accedere al modello e anche di salvarlo su Hugging Face Hub.
!huggingface-cli login --token $secret_hfInizializzare lo spazio di lavoro W&B
Inizializza lo spazio di lavoro Weights & Biases (W&B) usando la chiave API di W&B. Useremo questo workspace per tracciare l'addestramento del modello.
secret_wandb = user_secrets.get_secret("wandb")
# Monitoring the LLM
wandb.login(key = secret_wandb)
run = wandb.init(
project='Fine tuning Gemma 7B',
job_type="training",
anonymous="allow"
)Caricare il dataset
Recupera le prime 1000 righe di dati dal dataset di role-play disponibile su Hugging Face e mostra un campione della colonna `text`.
#Loading the dataset
dataset = load_dataset(dataset_name, split="train[0:1000]")
dataset["text"][100]Il nostro dataset consiste in una conversazione continua tra utente e assistente in stile celebrità. È un role-play.
Caricare il modello e il tokenizer
Per evitare problemi di memoria, caricheremo il modello in precisione a 4 bit usando BitsAndBytesConfig. Caricherà il modello direttamente da Kaggle senza scaricarlo.
# Load base model(Gemma 7B-it)
bnbConfig = BitsAndBytesConfig(
load_in_4bit = True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.bfloat16,
)
model = AutoModelForCausalLM.from_pretrained(
base_model,
quantization_config=bnbConfig,
device_map="auto"
)
model.config.use_cache = False # silence the warnings. Please re-enable for inference!
model.config.pretraining_tp = 1
model.gradient_checkpointing_enable()Carica il tokenizer e configura il pad token per risolvere il problema con fp16.
# Load tokenizer
tokenizer = AutoTokenizer.from_pretrained(base_model)
tokenizer.padding_side = 'right'
tokenizer.pad_token = tokenizer.eos_token
tokenizer.add_eos_token = True
tokenizer.add_bos_token, tokenizer.add_eos_tokenAggiungere il layer adapter
Aggiungendo il layer adapter al nostro modello possiamo fare fine-tuning in modo più efficiente. Invece di addestrare l'intero modello, aggiorniamo solo i parametri dei layer adapter, accelerando il processo di training.
I nostri moduli target saranno 'o_proj', 'q_proj', 'up_proj', 'v_proj', 'k_proj', 'down_proj' e 'gate_proj'.
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=['o_proj', 'q_proj', 'up_proj', 'v_proj', 'k_proj', 'down_proj', 'gate_proj']
)
model = get_peft_model(model, peft_config)Addestrare il modello
Per avviare l'addestramento dobbiamo specificare gli iperparametri. Questi parametri sono fondamentali e possono essere modificati per migliorare il processo di training e le prestazioni del modello.
Se vuoi comprendere meglio ogni iperparametro, ti suggeriamo di leggere il tutorial Fine-tuning di LLaMA 2.
training_arguments = TrainingArguments(
output_dir="./gemma-7b-v2-role-play",
num_train_epochs=1,
per_device_train_batch_size=2,
gradient_accumulation_steps=1,
optim="paged_adamw_32bit",
save_strategy="epoch",
logging_steps=100,
logging_strategy="steps",
learning_rate=2e-4,
fp16=False,
bf16=False,
group_by_length=True,
report_to="wandb"
)Per impostare l'SFT (Supervised Fine-tuning) trainer, dobbiamo fornirgli modello, dataset, configurazione Lora, tokenizer e parametri di training come argomenti.
trainer = SFTTrainer(
model=model,
train_dataset=dataset,
peft_config=peft_config,
max_seq_length= 512,
dataset_text_field="text",
tokenizer=tokenizer,
args=training_arguments,
packing= False,
)Ora eseguiremo il processo di training usando la funzione `.train`. Il fine-tuning ha richiesto circa 1 ora e 1 minuto. La training loss è diminuita gradualmente e puoi ridurla ulteriormente aumentando il numero di epoche.
trainer.train()
Termina la sessione W&B e configura il modello per l'inferenza.
wandb.finish()
model.config.use_cache = True
Abbiamo addestrato il modello su due tipi di acceleratori GPU. Sembra che la P100 sia stata due volte più veloce della T4 2X.
Salvare il modello
Ora salveremo localmente l'adapter del modello e poi caricheremo il modello su Hugging Face hub. Il comando `push_to_hub` creerà il repo e invierà al hub la configurazione e i pesi dell'adapter.
# Save the fine-tuned model
trainer.model.save_pretrained(new_model)
trainer.model.push_to_hub(new_model, use_temp_dir=False)Nota: questo è solo un adapter; per salvare il modello completo servono circa 18 GB.
Possiamo visualizzare il modello su Hugging Face andando alla pagina del profilo e cercando il nuovo modello.
Immagine Fonte
Inferenza del modello
Per generare una risposta usando il nostro modello con fine-tuning, dobbiamo seguire alcuni passaggi.
Per prima cosa creeremo un prompt nel formato del dataset di role-play. Poi passeremo il prompt al tokenizer e successivamente al modello per generare le predizioni.
Per tradurre l'output previsto in testo leggibile, lo decodificheremo usando il tokenizer.
prompt = '''<|system|>Harry Potter is a wizard known for his distinctive lightningshaped scar and his remarkable journey through magic and battles against the dark wizard Voldemort.
<|user|> What is the meaning of hate?
<|assistant|>'''
inputs = tokenizer(prompt, return_tensors='pt', padding=True, truncation=True).to("cuda")
outputs = model.generate(**inputs, max_length=500, num_return_sequences=1)
text = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(text)Niente male. Sta anche ponendo pertinenti domande di follow-up.
Proviamolo di nuovo con un nuovo personaggio: Michel Jordan.
prompt = '''<|system|>Michael Jordan an NBA legend known for his competitive drive six championship wins with the Chicago Bulls.
<|user|> What motivates you in the life?
<|assistant|>'''
inputs = tokenizer(prompt, return_tensors='pt', padding=True, truncation=True).to("cuda")
outputs = model.generate(**inputs, max_length=500, num_return_sequences=1)
text = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(text)Direi che abbiamo fatto un buon lavoro nel fare fine-tuning del modello base per comprendere il nuovo stile di generazione delle risposte.
Se hai difficoltà a fare fine-tuning del tuo modello sul tuo dataset, dai un'occhiata al notebook Kaggle Gemma-7B 4-bit QLoRA Fine-tuning.
Puoi anche imparare a fare fine-tuning del modello top di gamma seguendo il tutorial Fine-tuning di GPT-4 di OpenAI.
Inferenza Gemma 7B con adapter per il role-play
Per generare una risposta, non possiamo semplicemente caricare l'adapter salvato. Dobbiamo unire l'adapter con fine-tuning al modello base (Gemma 7b-it).
In questa sezione vedremo come caricare il modello base e l'adapter e fonderli per generare una risposta.
1. Installa tutte le librerie Python necessarie.
%%capture
%pip install -U bitsandbytes
%pip install -U transformers
%pip install -U accelerate
%pip install -U peft2. Carica la chiave API dai segreti di Kaggle ed esegui il login alla CLI di Hugging Face.
from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()
secret_hf = user_secrets.get_secret("HUGGINGFACE_TOKEN")!huggingface-cli login --token $secret_hf3. Fornisci il percorso del modello base e dell'adapter.
base_model = "/kaggle/input/gemma/transformers/7b-it/2"
new_model = "kingabzpro/gemma-7b-it-v2-role-play"4. Carica il modello base.
from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
from peft import PeftModel
import torch
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,
)5. Carica e unisci l'adapter con il modello base
model = PeftModel.from_pretrained(base_model_reload, new_model)
6. Carica il tokenizer
tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "right"7. Passa il prompt attraverso il tokenizer e poi al modello per la generazione della risposta.
prompt = '''<|system|> Alan Watts's colorful journey explored the depths of philosophy and religion, weaving together Eastern wisdom and Western insights.
<|user|> What does the self actually amount to?
<|assistant|>'''
inputs = tokenizer(prompt, return_tensors='pt', padding=True, truncation=True).to("cuda")
outputs = model.generate(**inputs, max_length=500, num_return_sequences=1)
text = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(text)Alan Watts ha spiegato perfettamente il significato di “sé”.
Il codice sorgente per unire il modello base con l'adapter è disponibile qui: Gemma 7B Inference with Role Play Adopter.
Iscriviti al webinar Fine-tuning del tuo modello Llama 2 per guardare un tutorial video tenuto da un esperto del settore.
Considerazioni finali
Google aveva avviato la rivoluzione dei large language model anni fa ma non è riuscita a capitalizzarla. Ora l'azienda sta apportando i cambiamenti necessari alla sua strategia per tornare a essere leader del settore.
Con il recente lancio del modello open-source Gemma, Google ha fatto un passo per rafforzare la ricerca in IA e, in cambio, potrà costruire modelli ancora migliori in futuro.
L'azienda ha finalmente compreso la forza della community open-source e come possa trarne vantaggio. Usando piattaforme cloud, framework nativi e piattaforme come Kaggle, Colab e Vertex AI, Google punta a sfruttare al massimo la community open-source e restare avanti alla concorrenza.
In questo tutorial abbiamo visto i modelli Gemma e come accedervi usando GPU e TPU nel cloud. Abbiamo anche illustrato il processo di fine-tuning dell'ultimo modello Gemma 7b-it usando un dataset di role-play.
Il prossimo passo del tuo percorso nell'IA è creare la tua applicazione basata su LLM. Dai un'occhiata al tutorial su come costruire applicazioni LLM con LangChain e scopri come usare un potente framework Python per sviluppare applicazioni di IA all'avanguardia.
Argomenti
