Fine-tuning van Google Gemma: LLM's verbeteren met aangepaste instructies

Het is een spannende tijd in de wereld van AI. Grote bedrijven zoals Google, Meta en Twitter zetten zwaar in op het opensourcen van hun large language models (LLM's). Onlangs lanceerde het Google DeepMind-team Gemma - een familie van lichte, open-source LLM's, gebouwd op hetzelfde onderzoek en dezelfde technologie als Google's Gemini-modellen.

Afbeelding Bron

Hier leren we over de Gemma-modellen, hoe je er toegang toe krijgt met cloud-GPU's en -TPU's, en hoe je het nieuwste Gemma 7b-it-model traint op een role-play-dataset.

Google's Gemma begrijpen

Gemma (Latijn voor „kostbare steen”) is een familie van text-to-text, decoder-only, open modellen ontwikkeld door verschillende teams bij Google, met name Google DeepMind. Het is geïnspireerd op de Gemini-modellen en ontworpen om lichtgewicht te zijn en compatibel met alle belangrijke frameworks.

Google heeft modelgewichten vrijgegeven voor twee groottes van Gemma, namelijk Gemma 2B en Gemma 7B, die beschikbaar zijn met voorgetrainde en instruction-tuned varianten zoals Gemma 2B-it en Gemma 7B-it.

Zoals we weten deelt Gemma vergelijkbare technische componenten met Gemini, en behaalt het prestaties van topniveau voor hun grootte vergeleken met andere open modellen zoals Meta's Llama-2. Het presteert beter dan Llama-2 op alle LLM-benchmarks.

Afbeelding Bron

Gemma ondersteunt een breed scala aan tools en systemen, waaronder multi-framework tools zoals Keras 3.0, native PyTorch, JAX en Hugging Face Transformers. Het draait ook op populaire apparaattypen, waaronder laptop, desktop, IoT, mobiel en cloud.

Je kunt nu inference en supervised fine-tuning (SFT) draaien op gratis Cloud TPU's met je favoriete machine learning-framework zoals Keras 3.0.

Google heeft samen met Gemma ook een Responsible Generative AI Toolkit geïntroduceerd om ontwikkelaars richtlijnen, essentiële tools en veiligheidsclassificatiemethoden te bieden voor het bouwen van veiligere AI-toepassingen.

Als je nieuw bent in de wereld van AI en LLM's, raden we je aan om het AI Fundamentals-skill track te volgen. Dit geeft je praktische kennis van populaire AI-onderwerpen zoals ChatGPT, large language models, generatieve AI en meer.

Hoe krijg je toegang tot Google's Gemma-model

Toegang krijgen tot Gemma is supermakkelijk; je kunt er gratis mee aan de slag op HuggingChat en Poe. Je kunt het zelfs lokaal gebruiken door de modelgewichten te downloaden van Hugging Face en vervolgens GPT4ALL of LMStudio te gebruiken.

In deze sectie leren we het Gemma-model te laden en inference te draaien met gratis GPU's en TPU's die door het Kaggle-platform worden aangeboden.

Gemma-inference draaien op TPU's

Ga naar Keras/Gemma, scroll naar beneden, selecteer de modelvariant „gemma_instruct_2b_en” en klik op de knop „New Notebook”. Er wordt een Cloud Notebook gestart met het Gemma-model in de inputdirectory.

Selecteer als accelerator „TPU VM v3-8” door naar het rechterpaneel te gaan en naar beneden te scrollen.

Zorg dat je alle benodigde Python-bibliotheken hebt geïnstalleerd en geüpdatet.

!pip install -q tensorflow-cpu
!pip install -q -U keras-nlp tensorflow-hub
!pip install -q -U keras>=3
!pip install -q -U tensorflow-textMogelijk gemaakt door

Om het beschikbare aantal TPU's te controleren, kun je de `jax`-bibliotheek en de functie `device` gebruiken om de TPU-apparaten weer te geven. We hebben toegang tot 8 TPU's.

import jax

jax.devices()Mogelijk gemaakt door

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

We schakelen nu TPU in voor Keras 3 door `jax` als Keras-backend in te stellen.

import os

os.environ["KERAS_BACKEND"] = "jax"Mogelijk gemaakt door

Na de eerste setup is toegang krijgen tot het Gemma-model en een reactie genereren vrij eenvoudig. We gebruiken de `keras_nlp`-bibliotheek om het model van Kaggle te laden en geven vervolgens de prompt door aan de functie `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)Mogelijk gemaakt door

Hier is het resultaat:

"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."

Je kunt het Kaggle-notebook (Gemma-2B-V2 Simple Inference on TPU) eenvoudig draaien en meteen reacties genereren met gratis TPU's.

Gemma-inference draaien op GPU's

Nu leren we een reactie te genereren met GPU's en met een transformer-framework in plaats van Keras.

Ga naar google/gemma, scroll naar beneden, selecteer transformers, kies de modelvariant „7b-it” en klik op de knop „New Notebook”. Dit start een Cloud Notebook met de juiste versie van het Gemma-model in de inputdirectory.

Opmerking: je kunt nog verder naar beneden scrollen om bij de inference-sectie te komen. Hier kun je alle soorten Gemma-varianten testen door een prompt op te geven en een reactie te genereren. Het is snel en handig.

Wijzig in het nieuwe notebook de titel en verander vervolgens de accelerator naar GPT T4 x2.

Installeer en update alle benodigde Python-pakketten.

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

We kunnen het volledige Gemma 7b-it-model niet op Kaggle-GPU's laden vanwege beperkte VRAM. Om dit op te lossen laden we het model met 4-bit quantization met NF4-typeconfiguratie via BitsAndBytes. Laad ook de 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)Mogelijk gemaakt door

Maak een eenvoudige prompttemplate met System, User en AI. We hebben het model gevraagd om de code te genereren om het sterpatroon weer te geven met Python.

Geef de uiteindelijke prompt door een tokenizer en vervolgens aan een model om een voorspelling te genereren. Daarna decoderen we die voorspellingen en zetten we de reactie om naar een string. Tot slot gebruiken we de Markdown-functie om de reactie in Markdown-stijl weer te geven.

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

Zoals we zien, heeft Gemma 7b-it uitstekend werk geleverd.

Je kunt de code zelf draaien door het Kaggle-notebook Gemma-7B Simple Inference on GPU te clonen.

Hoe fine-tune je Google's Gemma: een stapsgewijze handleiding

In deze sectie leren we het Gemma 7b-it-model te fine-tunen op een hieunguyenminh/roleplay-dataset. We gebruiken Kaggle GPU P100 als accelerator.

Lees onze gids, Een introductiegids voor het fine-tunen van LLM's, om elke stap in detail te begrijpen.

Installatie

Het is belangrijk om alle benodigde Python-pakketten te installeren en te updaten om fouten te voorkomen.

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

Laad alle pakketten die we gaan gebruiken om de dataset, het model en de tokenizer te laden, en om supervised fine-tuning (SFT) en inference uit te voeren.

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

Definieer namen voor het basismodel en de dataset, evenals de naam van het gefinetunede model, dat we later naar Hugging Face Hub gaan uploaden.

Deze variabelen gebruiken we in verschillende stadia, zoals het laden van de dataset en het model, tokenizen, trainen en opslaan van het model.

base_model = "/kaggle/input/gemma/transformers/7b-it/2"
dataset_name = "hieunguyenminh/roleplay"
new_model = "gemma-7b-it-v2-role-play"Mogelijk gemaakt door

Inloggen op Hugging Face CLI

We laden de Hugging Face API-sleutel uit Kaggle secrets (omgevingsvariabelen).

from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()
secret_hf = user_secrets.get_secret("HUGGINGFACE_TOKEN")Mogelijk gemaakt door

Gebruik de API-sleutel om in te loggen op de Hugging Face CLI. Zo kunnen we toegang krijgen tot het model en het ook opslaan op Hugging Face Hub.

!huggingface-cli login --token $secret_hfMogelijk gemaakt door

W&B-werkruimte initialiseren

Start de Weights & Biases (W&B)-werkruimte met de W&B API-sleutel. We gebruiken deze werkruimte om de modeltraining te volgen.

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

De dataset laden

Haal de eerste 1000 rijen op uit de role-play-dataset die beschikbaar is op Hugging Face en toon een sample uit de kolom `text`.

#Loading the dataset
dataset = load_dataset(dataset_name, split="train[0:1000]")
dataset["text"][100]Mogelijk gemaakt door

Onze dataset bestaat uit een doorlopend gesprek tussen de gebruiker en de assistent in de stijl van een beroemdheid. Het is role-playing.

Het model en de tokenizer laden

Om geheugenproblemen te voorkomen, laden we ons model in 4-bit-precisie met BitsAndBytesConfig. Het model wordt direct vanaf Kaggle geladen zonder te downloaden.

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

Laad de tokenizer en configureer de pad token om het probleem met fp16 op te lossen.

# 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_tokenMogelijk gemaakt door

De adapterlaag toevoegen

Door de adapterlaag aan ons model toe te voegen, kunnen we efficiënter fine-tunen. In plaats van het hele model te trainen, hoeven we alleen de parameters van de adapterlagen bij te werken, wat het trainingsproces versnelt.

Onze doelmodules zijn 'o_proj', 'q_proj', 'up_proj', 'v_proj', 'k_proj', 'down_proj' en '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)Mogelijk gemaakt door

Het model trainen

Om met trainen te beginnen, moeten we de hyperparameters specificeren. Deze parameters zijn fundamenteel en kunnen worden aangepast om het trainingsproces te verbeteren en de modelprestaties te verhogen.

Als je elke hyperparameter beter wilt begrijpen, raden we de tutorial Fine-tuning LLaMA 2 aan.

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

Om de Supervised Fine-tuning (SFT) trainer in te stellen, moeten we het model, de dataset, de Lora-configuratie, de tokenizer en de trainingsparameters als argumenten meegeven.

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

We starten nu het trainingsproces met de functie `.train`. Het fine-tunen duurde bijna 1 uur en 1 minuut. Het trainingverlies nam geleidelijk af, en je kunt dit verlies verder verminderen door het aantal epochs te verhogen.

trainer.train()Mogelijk gemaakt door

Sluit de W&B-sessie af en configureer het model voor inference.

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

We hebben het model op twee typen GPU-accelerators getraind. Het lijkt erop dat de P100 twee keer zo snel was als de T4 2X.

Het model opslaan

We slaan nu de modeladapter lokaal op en uploaden het model daarna naar de Hugging Face hub. Het commando `push_to_hub` maakt de repo aan en pusht de adapterconfig en adaptergewichten naar de hub.

# Save the fine-tuned model
trainer.model.save_pretrained(new_model)
trainer.model.push_to_hub(new_model, use_temp_dir=False)Mogelijk gemaakt door

Opmerking: dit is slechts een adapter; het volledige model opslaan kost rond de 18 GB.

We kunnen het model bekijken op Hugging Face door naar de profielpagina te gaan en te zoeken naar het nieuwe model.

Afbeelding Bron

Modelinference

Om een reactie te genereren met ons gefinetunede model, moeten we een paar stappen volgen.

Eerst maken we een prompt in het role-play-datasetformaat. Vervolgens geven we de prompt door aan de tokenizer en daarna aan het model om voorspellingen te genereren.

Om de voorspelde output naar leesbare tekst te vertalen, decoderen we deze met de 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)Mogelijk gemaakt door

Helemaal niet slecht. Het stelt ook relevante vervolgvragen.

Probeer het nog eens met een nieuw personage: 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)Mogelijk gemaakt door

Ik denk dat we goed werk hebben geleverd door het basismodel te fine-tunen om de nieuwe stijl van reactiegeneratie te begrijpen.

Als je moeite hebt om je model op je dataset te fine-tunen, bekijk dan het Kaggle-notebook Gemma-7B 4-bit QLoRA Fine-tuning.

Je kunt ook leren hoe je het best presterende model in het veld fine-tunet door de tutorial Fine-tuning van OpenAI's GPT-4 te volgen.

Gemma 7B-inference met role-play-adapter

Om een reactie te genereren, kunnen we niet simpelweg de opgeslagen adapter laden. We moeten de gefinetunede adapter samenvoegen met het basismodel (Gemma 7b-it).

In deze sectie leren we hoe je het basismodel en de adapter laadt en ze samenvoegt om een reactie te genereren.

1. Installeer alle benodigde Python-bibliotheken.

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

2. Laad de API-sleutel uit Kaggle secrets en log in op de Hugging Face CLI.

from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()
secret_hf = user_secrets.get_secret("HUGGINGFACE_TOKEN")Mogelijk gemaakt door

!huggingface-cli login --token $secret_hfMogelijk gemaakt door

3. Geef de locatie op van het basismodel en de adapter.

base_model = "/kaggle/input/gemma/transformers/7b-it/2"
new_model = "kingabzpro/gemma-7b-it-v2-role-play"Mogelijk gemaakt door

4. Laad het basismodel.

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

5. Laad en voeg de adapter samen met het basismodel

model = PeftModel.from_pretrained(base_model_reload, new_model)Mogelijk gemaakt door

6. Laad de tokenizer

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

7. Geef de prompt door de tokenizer en vervolgens het model voor reactiegeneratie.

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

Alan Watts heeft de betekenis van „zelf” perfect uitgelegd.

De broncode voor het samenvoegen van het basismodel met de adapter is beschikbaar op Gemma 7B Inference with Role Play Adopter.

Meld je aan voor het webinar Fine-tuning van je eigen Llama 2-model om een videotutorial van een industrie-expert te bekijken.

Tot slot

Google heeft jaren geleden de revolutie van large language models op gang gebracht, maar kon daar niet van profiteren. Nu brengt het bedrijf de nodige veranderingen aan in zijn strategie om opnieuw een marktleider te worden.

Met de recente lancering van een open-source model, Gemma, heeft Google een stap gezet om AI-onderzoek een boost te geven en kan het op termijn nog betere modellen bouwen.

Het bedrijf heeft eindelijk de kracht van de open-sourcegemeenschap ingezien en hoe het daarvan kan profiteren. Door gebruik te maken van cloudplatforms, native frameworks en platforms zoals Kaggle, Colab en Vertex AI wil Google het maximale halen uit de open-sourcegemeenschap en de concurrentie voorblijven.

In deze tutorial hebben we geleerd over Gemma-modellen en hoe je er toegang toe krijgt via cloud-GPU's en -TPU's. We hebben ook het proces behandeld van het fine-tunen van het nieuwste Gemma 7b-it-model met een role-play-dataset.

De volgende stap in je AI-reis is om je eigen toepassing op basis van een LLM te bouwen. Bekijk de tutorial over hoe je LLM-toepassingen bouwt met LangChain en ontdek hoe je een krachtig Python-framework gebruikt om geavanceerde AI-toepassingen te ontwikkelen.