Llama 3 fijnslijpen en lokaal gebruiken: een stapsgewijze gids

Llama 3 begrijpen

Meta heeft een nieuwe serie large language models (LLM’s) uitgebracht, Llama 3: een verzameling vooraf getrainde en instruction‑tuned text‑to‑text‑modellen.

Llama 3 is een autoregressief taalmodel dat een geoptimaliseerde transformer‑architectuur gebruikt. Zowel de vooraf getrainde als de instruction‑tuned modellen hebben 8B en 70B parameters met een contextlengte van 8K tokens.

Llama 3 8B is het meest gelikete LLM op Hugging Face. De instruction‑tuned versie presteert beter dan Google’s Gemma 7B‑It en Mistral 7B Instruct op diverse prestatie‑metrics. De 70B instruction‑tuned versie heeft Gemini Pro 1.5 en Claude Sonnet op de meeste prestatie‑metrics voorbijgestreefd:

Bron: Meta Llama 3

Meta trainde Llama 3 op een nieuwe mix van publiek beschikbare online data, met meer dan 15 biljoen tokens. Het 8B‑model heeft een knowledge cutoff in maart 2023, het 70B‑model in december 2023. De modellen gebruiken Grouped‑Query Attention (GQA), wat het geheugengebruik vermindert en de efficiëntie verbetert.

De Llama 3‑modellen zijn uitgebracht onder een aangepaste commerciële licentie. Om toegang te krijgen, moet je een formulier invullen met je naam, affiliatie en e‑mail en de voorwaarden accepteren. Gebruik je verschillende e‑mailadressen voor platforms als Kaggle en Hugging Face, dan moet je het formulier mogelijk meerdere keren invullen.

Meer over Llama 3 lees je in dit artikel: Wat is Llama 3?.

1. Llama 3 fijnslijpen

Voor deze tutorial fine‑tunen we het Llama 3 8B‑Chat‑model met de dataset ruslanmv/ai-medical-chatbot. De dataset bevat 250k dialogen tussen een patiënt en een arts. We gebruiken een Kaggle Notebook om dit model en gratis GPU’s te gebruiken.

Installatie

Vóór we het Kaggle Notebook starten, vul je het Meta‑downloadformulier in met je Kaggle‑e-mailadres. Ga daarna naar de Llama 3‑modelpagina op Kaggle en accepteer de overeenkomst. De goedkeuring kan één tot twee dagen duren.

Laten we nu de volgende stappen nemen:

1. Start een nieuw Notebook op Kaggle en voeg het Llama 3‑model toe via de knop + Add Input, kies Models en klik op het plusje + naast het Llama 3‑model. Selecteer vervolgens het juiste framework, de variant en versie, en voeg het model toe.

2. Ga naar de Session options en kies GPU P100 als accelerator.

3. Genereer de tokens voor Hugging Face en Weights & Biases en maak de Kaggle Secrets aan. Je kunt Kaggle Secrets maken en activeren via Add-ons > Secrets > Add een nieuwe secret.

4. Start de Kaggle‑sessie door alle benodigde Python‑packages te installeren.

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

5. Importeer de benodigde Python‑pagina’s voor het laden van de dataset, het model en de tokenizer en voor het fijnslijpen.

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, setup_chat_formatMogelijk gemaakt door

6. We volgen het trainingsproces met Weights & Biases en slaan het fijn‑afgestelde model op bij Hugging Face. Daarvoor moeten we inloggen bij zowel Hugging Face Hub als Weights & Biases met de API‑sleutel.

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)

wb_token = user_secrets.get_secret("wandb")

wandb.login(key=wb_token)
run = wandb.init(
    project='Fine-tune Llama 3 8B on Medical Dataset', 
    job_type="training", 
    anonymous="allow"
)Mogelijk gemaakt door

7. Stel het basismodel, de dataset en de variabele voor het nieuwe model in. We laden het basismodel vanuit Kaggle en de dataset van de HugginFace Hub en slaan vervolgens het nieuwe model op.

base_model = "/kaggle/input/llama-3/transformers/8b-chat-hf/1"
dataset_name = "ruslanmv/ai-medical-chatbot"
new_model = "llama-3-8b-chat-doctor"Mogelijk gemaakt door

8. Stel het datatype en de attention‑implementatie in.

torch_dtype = torch.float16
attn_implementation = "eager"Mogelijk gemaakt door

Het model en de tokenizer laden

In dit gedeelte laden we het model vanuit Kaggle. Door geheugenbeperkingen kunnen we het volledige model niet laden. Daarom laden we het model met 4‑bit precisie.

Ons doel in dit project is het geheugengebruik te verminderen en het fijnslijpproces te versnellen.

# QLoRA config
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch_dtype,
    bnb_4bit_use_double_quant=True,
)

# Load model
model = AutoModelForCausalLM.from_pretrained(
    base_model,
    quantization_config=bnb_config,
    device_map="auto",
    attn_implementation=attn_implementation
)Mogelijk gemaakt door

Laad de tokenizer en stel vervolgens een model en tokenizer in voor conversatietaken met AI. Standaard wordt de chatml‑template van OpenAI gebruikt, die de invoer omzet naar een chatachtig formaat.

# Load tokenizer
tokenizer = AutoTokenizer.from_pretrained(base_model)
model, tokenizer = setup_chat_format(model, tokenizer)Mogelijk gemaakt door

De adapter aan de laag toevoegen

Het volledige model fijnslijpen kost veel tijd, dus om de trainingstijd te verbeteren, koppelen we een adapterlaag met een beperkt aantal parameters, waardoor het proces sneller en geheugen‑efficiënter wordt.

# LoRA config
peft_config = LoraConfig(
    r=16,
    lora_alpha=32,
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
    target_modules=['up_proj', 'down_proj', 'gate_proj', 'k_proj', 'q_proj', 'v_proj', 'o_proj']
)
model = get_peft_model(model, peft_config)Mogelijk gemaakt door

De dataset laden

Om onze dataset te laden en voor te bewerken, doen we het volgende:

1. Laad de dataset ruslanmv/ai-medical-chatbot, shuffle deze en selecteer alleen de bovenste 1000 rijen. Dit verkort de trainingstijd aanzienlijk.

2. Formatteer de chattemplate om het conversatiegericht te maken. Combineer de patiëntvragen en artsantwoorden in een kolom "text".

3. Toon een voorbeeld uit de tekstkolom (de kolom “text” heeft een chatachtig formaat met speciale tokens).

#Importing the dataset
dataset = load_dataset(dataset_name, split="all")
dataset = dataset.shuffle(seed=65).select(range(1000)) # Only use 1000 samples for quick demo

def format_chat_template(row):
    row_json = [{"role": "user", "content": row["Patient"]},
               {"role": "assistant", "content": row["Doctor"]}]
    row["text"] = tokenizer.apply_chat_template(row_json, tokenize=False)
    return row

dataset = dataset.map(
    format_chat_template,
    num_proc=4,
)

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

4. Splits de dataset in een train‑ en validatieset.

dataset = dataset.train_test_split(test_size=0.1)Mogelijk gemaakt door

Het model configureren en trainen

We stellen de hyperparameters van het model in zodat we het op Kaggle kunnen draaien. Je kunt over elke hyperparameter leren in de tutorial Llama 2 fijnslijpen.

We fine‑tunen het model één epoch en loggen de metrics met Weights & Biases.

training_arguments = TrainingArguments(
    output_dir=new_model,
    per_device_train_batch_size=1,
    per_device_eval_batch_size=1,
    gradient_accumulation_steps=2,
    optim="paged_adamw_32bit",
    num_train_epochs=1,
    evaluation_strategy="steps",
    eval_steps=0.2,
    logging_steps=1,
    warmup_steps=10,
    logging_strategy="steps",
    learning_rate=2e-4,
    fp16=False,
    bf16=False,
    group_by_length=True,
    report_to="wandb"
)Mogelijk gemaakt door

We zetten nu een supervised fine‑tuning (SFT) trainer op en geven een train‑ en evaluatiedataset, LoRA‑configuratie, trainingsargumenten, tokenizer en model mee. We houden max_seq_length op 512 om GPU‑geheugen tijdens training niet te overschrijden.

trainer = SFTTrainer(
    model=model,
    train_dataset=dataset["train"],
    eval_dataset=dataset["test"],
    peft_config=peft_config,
    max_seq_length=512,
    dataset_text_field="text",
    tokenizer=tokenizer,
    args=training_arguments,
    packing= False,
)Mogelijk gemaakt door

We starten het fijnslijpproces met de volgende code.

trainer.train()Mogelijk gemaakt door

Zowel de train‑ als validatieverlies zijn gedaald. Overweeg drie epochs te trainen op de volledige dataset voor betere resultaten.

Model evalueren

Wanneer je de Weights & Biases‑sessie afrondt, wordt de run‑geschiedenis en samenvatting gegenereerd.

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

De prestatie‑metrics van het model worden ook opgeslagen onder de specifieke projectnaam in je Weights & Biases‑account.

Laten we het model evalueren op een voorbeeldvraag van een patiënt om te controleren of het goed is fijn‑afgesteld.

Om een reactie te genereren, moeten we berichten omzetten naar een chatformaat, door de tokenizer halen, het resultaat aan het model voeren en vervolgens de gegenereerde token decoderen om de tekst te tonen.

messages = [
    {
        "role": "user",
        "content": "Hello doctor, I have bad acne. How do I get rid of it?"
    }
]

prompt = tokenizer.apply_chat_template(messages, tokenize=False, 
                                       add_generation_prompt=True)

inputs = tokenizer(prompt, return_tensors='pt', padding=True, 
                   truncation=True).to("cuda")

outputs = model.generate(**inputs, max_length=150, 
                         num_return_sequences=1)

text = tokenizer.decode(outputs[0], skip_special_tokens=True)

print(text.split("assistant")[1])Mogelijk gemaakt door

Blijkt dat we zelfs met één epoch gemiddelde resultaten kunnen krijgen.

Het modelbestand opslaan

We slaan nu de fijn‑afgestelde adapter op en pushen deze naar de Hugging Face Hub. De Hub‑API maakt automatisch de repository en slaat het adapterbestand op.

trainer.model.save_pretrained(new_model)
trainer.model.push_to_hub(new_model, use_temp_dir=False)Mogelijk gemaakt door

Zoals we zien is ons opgeslagen adapterbestand aanzienlijk kleiner dan het basismodel.

Uiteindelijk slaan we het notebook met het adapterbestand op om het te mergen met het basismodel in een nieuw notebook.

Om het Kaggle Notebook op te slaan, klik je rechtsboven op Save Version, kies je als versietype Quick Save, open je de geavanceerde instellingen, selecteer je Always save output when creating a Quick Save en druk je op Save.

Heb je problemen bij het draaien van de code, raadpleeg dan dit Kaggle Notebook: Fine‑tune Llama 3 8B on Medical Dataset.

We hebben ons model fijn‑afgesteld met de GPU. Je kunt ook leren om LLM’s te fine‑tunen met TPU’s via de tutorial Fine‑tunen en inferentie draaien op Google’s Gemma‑model met TPU’s.

Wil je leren hoe je andere modellen fijn‑slijpt? Bekijk dan deze Mistral 7B‑tutorial: een stapsgewijze gids voor het gebruiken en fijnslijpen van Mistral 7B.

2. Llama 3 mergen

Om het fijn‑afgestelde model lokaal te gebruiken, moeten we eerst de adapter met het basismodel mergen en vervolgens het volledige model opslaan.

Installatie

Volg deze stappen:

1. Maak een nieuw Kaggle Notebook en installeer alle benodigde Python‑packages. Zorg dat je de GPU als accelerator gebruikt.

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

2. Log in op de Hugging Face Hub met Kaggle Secrets. Dit helpt ons om het volledige fijn‑afgestelde model eenvoudig te uploaden.

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

3. Voeg het Llama 3 8B Chat‑model toe en het fijn‑afgestelde Kaggle Notebook dat we zojuist hebben opgeslagen. We kunnen Notebooks aan de huidige sessie toevoegen, net zoals je datasets en modellen toevoegt.

Door een Notebook aan de Kaggle‑sessie toe te voegen, krijgen we toegang tot de outputbestanden. In ons geval is dat een modeladapterbestand.

4. Stel de variabelen in met de locatie van het basismodel en de adapter.

base_model = "/kaggle/input/llama-3/transformers/8b-chat-hf/1"
new_model = "/kaggle/input/fine-tune-llama-3-8b-on-medical-dataset/llama-3-8b-chat-doctor/"Mogelijk gemaakt door

Het basismodel met de adapter mergen

We laden eerst de tokenizer en het basismodel met de transformers‑bibliotheek. Daarna richten we het chatformaat in met de trl‑bibliotheek. Tot slot laden en mergen we de adapter met het basismodel via de PEFT‑bibliotheek.

De functie merge_and_unload() helpt ons de adaptergewichten met het basismodel te mergen en dit als zelfstandig model te gebruiken.

from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
from peft import PeftModel
import torch
from trl import setup_chat_format
# 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,
)

base_model_reload, tokenizer = setup_chat_format(base_model_reload, tokenizer)

# Merge adapter with base model
model = PeftModel.from_pretrained(base_model_reload, new_model)

model = model.merge_and_unload()Mogelijk gemaakt door

Modelinferentie

Om te verifiëren of ons model correct is gemerged, voeren we een eenvoudige inferentie uit met pipeline uit de transformers‑bibliotheek. We converteren het bericht met de chattemplate en geven vervolgens een prompt aan de pipeline. De pipeline is geïnitialiseerd met het model, de tokenizer en het taaktype.

Terzijde: je kunt device_map instellen op "auto" als je meerdere GPU’s wilt gebruiken.

messages = [{"role": "user", "content": "Hello doctor, I have bad acne. How do I get rid of it?"}]

prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
pipe = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
    torch_dtype=torch.float16,
    device_map="auto",
)

outputs = pipe(prompt, max_new_tokens=120, do_sample=True, temperature=0.7, top_k=50, top_p=0.95)
print(outputs[0]["generated_text"])Mogelijk gemaakt door

Ons fijn‑afgestelde model werkt naar verwachting na het mergen.

Het gemergde model opslaan en pushen

We slaan nu een tokenizer en model op met de functie save_pretrained().

model.save_pretrained("llama-3-8b-chat-doctor")
tokenizer.save_pretrained("llama-3-8b-chat-doctor")Mogelijk gemaakt door

De modelfiles worden opgeslagen in het safetensors‑formaat en de totale modelgrootte is ongeveer 16 GB.

We kunnen alle bestanden naar de Hugging Face Hub pushen met de functie push_to_hub().

model.push_to_hub("llama-3-8b-chat-doctor", use_temp_dir=False)
tokenizer.push_to_hub("llama-3-8b-chat-doctor", use_temp_dir=False)Mogelijk gemaakt door

Tot slot kunnen we het Kaggle Notebook opslaan zoals we eerder deden.

Met het Kaggle Notebook Fine Tuned Adapter to fully model kun je eventuele problemen bij het draaien van de code oplossen.

3. Het model converteren naar Llama.cpp GGUF

We kunnen de safetensors‑bestanden niet lokaal gebruiken, omdat de meeste lokale AI‑chatbots deze niet ondersteunen. In plaats daarvan converteren we het naar het GGUF‑bestandsformaat van llama.cpp.

Installatie

Start een nieuwe Kaggle Notebook‑sessie en voeg het Notebook Fine Tuned Adapter to the full model toe.

Clone de llama.cpp‑repository en installeer het llama.cpp‑framework met het commando make zoals hieronder.

Terzijde: onderstaand commando werkt alleen voor het Kaggle Notebook. Mogelijk moet je wat aanpassen om het op andere platforms of lokaal te draaien.

%cd /kaggle/working
!git clone --depth=1 https://github.com/ggerganov/llama.cpp.git
%cd /kaggle/working/llama.cpp
!sed -i 's|MK_LDFLAGS   += -lcuda|MK_LDFLAGS   += -L/usr/local/nvidia/lib64 -lcuda|' Makefile
!LLAMA_CUDA=1 conda run -n base make -j > /dev/nullMogelijk gemaakt door

Safetensors converteren naar GGUF‑modelformaat

Draai de volgende opdracht in een Kaggle Notebook‑cel om het model naar het GGUF‑formaat te converteren.

De convert-hf-to-gguf.py vereist een inputmodelmap, outputbestandspad en out‑type.

!python convert-hf-to-gguf.py /kaggle/input/fine-tuned-adapter-to-full-model/llama-3-8b-chat-doctor/ \
    --outfile /kaggle/working/llama-3-8b-chat-doctor.gguf \
    --outtype f16Mogelijk gemaakt door

Binnen enkele minuten is het model geconverteerd en lokaal opgeslagen. Sla daarna het notebook op om het bestand te bewaren.

Als je problemen ondervindt bij het draaien van bovenstaande code, raadpleeg dan het Kaggle Notebook HF LLM to GGUF.

4. Het GGUF‑model kwantiseren

Gewone laptops hebben niet genoeg RAM en GPU‑geheugen om het volledige model te laden, dus moeten we het GGUF‑model kwantiseren, waarbij we het 16 GB‑model terugbrengen naar circa 4–5 GB.

Installatie

Start een nieuwe Kaggle Notebook‑sessie en voeg het Notebook HF LLM to GGUF toe.

Installeer vervolgens llama.cpp door het volgende commando in een Kaggle Notebook‑cel te draaien.

%cd /kaggle/working
!git clone --depth=1 https://github.com/ggerganov/llama.cpp.git
%cd /kaggle/working/llama.cpp
!sed -i 's|MK_LDFLAGS   += -lcuda|MK_LDFLAGS   += -L/usr/local/nvidia/lib64 -lcuda|' Makefile
!LLAMA_CUDA=1 conda run -n base make -j > /dev/nullMogelijk gemaakt door

Kwantisatie

Het kwantisatiescript vereist een GGUF‑modelmap, een outputbestandspad en een kwantisatiemethode. We converteren het model met de methode Q4_K_M.

%cd /kaggle/working/

!./llama.cpp/llama-quantize /kaggle/input/hf-llm-to-gguf/llama-3-8b-chat-doctor.gguf llama-3-8b-chat-doctor-Q4_K_M.gguf Q4_K_MMogelijk gemaakt door

De modelgrootte is flink gedaald van 15317,05 MB naar 4685,32 MB.

Het modelbestand naar Hugging Face pushen

Om het enkele bestand naar de Hugging Face Hub te pushen, doen we het volgende:

1. Inloggen op de Hugging Face Hub met de API‑sleutel.
2. Het API‑object aanmaken.
3. Het bestand uploaden met lokaal pad, repo‑pad, repo‑id en repo‑type.

from huggingface_hub import login
from kaggle_secrets import UserSecretsClient
from huggingface_hub import HfApi
user_secrets = UserSecretsClient()
hf_token = user_secrets.get_secret("HUGGINGFACE_TOKEN")
login(token = hf_token)

api = HfApi()
api.upload_file(
    path_or_fileobj="/kaggle/working/llama-3-8b-chat-doctor-Q4_K_M.gguf",
    path_in_repo="llama-3-8b-chat-doctor-Q4_K_M.gguf",
    repo_id="kingabzpro/llama-3-8b-chat-doctor",
    repo_type="model",
)
Mogelijk gemaakt door

Ons model is succesvol naar de externe server gepusht, zoals hieronder te zien is.

Heb je nog steeds problemen, raadpleeg dan het Kaggle Notebook GGUF to Quantize, met alle code en output.

Zoek je een eenvoudigere manier om je model te converteren en te kwantiseren? Bezoek dan deze Hugging Face Space en geef de Hub Model Id op.

5. Het fijn‑afgestelde model lokaal gebruiken

Om het GGUF‑model lokaal te gebruiken, moet je het downloaden en importeren in de Jan‑applicatie.

Het model downloaden vanaf Hugging Face

Om het model te downloaden, doen we het volgende:

1. Ga naar onze Hugging Face‑repository.

2. Klik op het tabblad Files.

3. Klik op het gequantiseerde modelbestand met de GGUF‑extensie.

4. Klik op de knop download.

Het duurt enkele minuten om het bestand lokaal te downloaden.

De Jan‑applicatie installeren

Download en installeer de Jan‑applicatie via Jan AI.

Zo ziet het eruit wanneer je de Jan‑toepassing voor Windows start:

Het fijn‑afgestelde model laden in Jan

Om het model aan de Jan‑applicatie toe te voegen, importeren we het gequantiseerde GGUF‑bestand.

Ga naar het Hub‑menu en klik op Import Model, zoals hieronder getoond. Geef de locatie van het zojuist gedownloade bestand op en dat is alles.

Ga naar het menu Thread en selecteer het fijn‑afgestelde model.

Het fijn‑afgestelde model gebruiken in Jan

Voordat we het model gebruiken, moeten we het aanpassen om de respons correct weer te geven. Eerst passen we de Prompt‑template aan in de sectie Model Parameters.

<|im_start|>system
{system_message}<|im_end|>
<|im_start|>user
{prompt}<|im_end|>
<|im_start|>assistantMogelijk gemaakt door

We voegen de Stop‑token toe en zetten het maximum aantal tokens op 512 in de inferentieparameters.

<endofstring>, Best, Regards, Thanks,-->Mogelijk gemaakt door

We beginnen vragen te stellen en de arts reageert dienovereenkomstig.

Ons fijn‑afgestelde model werkt lokaal perfect.

Dit model werkt met GPT4ALL, Llama.cpp, Ollama en veel andere lokale AI‑applicaties. Wil je leren hoe je elk daarvan gebruikt, bekijk dan deze tutorial over hoe je LLM’s lokaal draait.

Conclusie

Het fijnslijpen van het Llama 3‑model op een aangepaste dataset en het lokaal gebruiken ervan, opent veel mogelijkheden voor het bouwen van innovatieve applicaties. Potentiële use‑cases variëren van privé en gepersonaliseerde conversational‑AI‑oplossingen tot domeinspecifieke chatbots, tekstclassificatie, vertaling, vraag‑en‑antwoord‑systemen, gepersonaliseerde aanbevelingen en zelfs toepassingen voor gezondheidszorg en marketingautomatisering.

Met de frameworks Ollama en LangChain is je eigen AI‑applicatie bouwen toegankelijker dan ooit en heb je slechts een paar regels code nodig. Volg daarvoor de tutorial LlamaIndex: een dataframework voor toepassingen op basis van Large Language Models (LLM’s).

In deze tutorial hebben we geleerd om Llama 3 8B Chat fijn te slijpen op een medische dataset. We hebben het proces doorlopen van het mergen van de adapter met het basismodel, het converteren naar het GGUF‑formaat en het kwantiseren voor lokaal gebruik in een Jan‑chatbotapplicatie.

Wil je meer leren? Bekijk dan deze skill track met vier cursussen over Developing Large Language Models.