Llama 3.2 fijn-afstemmen en lokaal gebruiken: een stapsgewijze gids

De wereld van large language models (LLM’s) verandert de laatste tijd razendsnel. Nieuwere LLM’s worden kleiner en slimmer ontworpen, waardoor ze goedkoper en makkelijker te gebruiken zijn dan de grotere modellen. 

Met de release van Llama 3.2 hebben we nu toegang tot kleinere modellen, zoals de 1B- en 3B-varianten. Hoewel deze kleinere modellen in algemene taken niet altijd de nauwkeurigheid van grotere modellen evenaren, kun je ze fijn-afstemmen zodat ze uitblinken in specifieke toepassingen, zoals emotieclassificatie in klantenservicetrajecten. Daarmee kunnen ze in zulke domeinen traditionele modellen mogelijk vervangen.

In deze tutorial verkennen we de mogelijkheden van de Llama 3.2 vision- en lichtgewichte modellen. We leren hoe je het Llama 3.2 3B-model opent, het fijnstemt op een klantenservicedataset, en het vervolgens samenvoegt en exporteert naar de Hugging Face Hub. Tot slot converteren we het model naar GGUF-formaat en gebruiken we het lokaal met de Jan-applicatie.

Als je nieuw bent met AI, raden we je sterk aan om de AI Fundamentals skill track te volgen en de basis van ChatGPT, large language models, generatieve AI en meer te leren.

Afbeelding door auteur

Introductie van Llama 3.2

De familie van open-sourcemodellen Llama 3.2 kent twee varianten: de lichte en vision-modellen. De vision-modellen blinken uit in redeneerwerk met beelden en het overbruggen van visie en taal, terwijl de lichte modellen sterk zijn in meertalige tekstopwekking en tool-calling op edge-apparaten.

Lichte modellen

Het lichte model heeft twee kleinere varianten: 1B en 3B. Deze modellen zijn goed in meertalige tekstopwekking en tool-calling-taken. Ze zijn klein, waardoor ze op een apparaat kunnen draaien zodat data het apparaat niet verlaat en snelle tekstopwekking mogelijk is tegen lage rekenkosten.

Om deze efficiënte lichte modellen te maken, gebruikt Llama 3.2 technieken als pruning en knowledge distillation. Pruning verkleint het model terwijl de prestaties behouden blijven, en bij knowledge distillation draagt een groter netwerk kennis over aan een kleiner netwerk, wat de prestaties verbetert.

Het 3B-model presteert beter dan andere modellen zoals Gemma 2 (2,6B) en Phi 3.5-mini bij taken zoals instructieopvolging, samenvatten, prompt herschrijven en toolgebruik.

Bron: Llama 3.2: Revolutionizing edge AI and vision with open, customizable models

Vision-modellen

De vision-modellen komen in twee varianten: 11B en 90B. Deze modellen ondersteunen beeldredeneren. De 11B en 90B kunnen documenten, diagrammen en grafieken begrijpen en interpreteren en taken uitvoeren als image captioning en visual grounding. Deze geavanceerde vision-capaciteiten zijn mogelijk gemaakt door voorgetrainde beeldencoders te integreren met taalmodellen via adaptergewichten met cross-attention-lagen.

Vergeleken met Claude 3 Haiku en GPT-4o mini doen de Llama 3.2 vision-modellen het uitstekend op beeldherkenning en diverse visuele begripstaken, waardoor ze robuuste tools zijn voor multimodale AI-toepassingen.

Bron: Llama 3.2: Revolutionizing edge AI and vision with open, customizable models

Meer leren over use-cases, benchmarks, Llama Guard 3 en de modelarchitectuur van Llama 3.2? Lees dan onze nieuwste blog, Llama 3.2 Guide: How It Works, Use Cases & More.

Toegang krijgen tot de lichte Llama 3.2-modellen in Kaggle

Hoewel het Llama 3.2-model gratis beschikbaar en open source is, moet je nog steeds de voorwaarden accepteren en het formulier op de website invullen. 

Zo krijg je toegang tot het nieuwste Llama 3.2-model op het Kaggle-platform:

1. Ga naar de website llama.com en vul het formulier in met je gegevens. Selecteer zowel de lichte als de vision-modellen. 

Bron: Download Llama

2. Ga naar de Meta | Llama 3.2-modelpagina en klik op de knop “Submit Form”. 

Bron: Meta | Llama 3.2 | Kaggle

3. Accepteer alle voorwaarden en klik op de knop “Submit”. 

Bron: Meta | Llama 3.2 | Kaggle

4. Wacht een paar minuten tot je de optie ziet om te downloaden of een nieuw notebook te maken. Selecteer het tabblad Transformers en de modelvariant, en klik vervolgens op de knop “+ New Notebook”.

5. Het Kaggle-notebook wordt gestart met het nieuwste Llama-model. Om het te laten werken, hoeven we alleen de accelerator te wijzigen naar “GPU T4 x2”.

6. Werk de Python-pakketten Transformers en Accelerate bij. 

%%capture
%pip install -U transformers accelerate

7. Laad de tokenizer en het model met het Transformers-pakket. In plaats van de Hugging Face-modelrepo op te geven, specificeren we de lokale map waar ons model staat.

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


base_model = "/kaggle/input/llama-3.2/transformers/3b-instruct/1"

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,
)

8. Stel pad_token_id in om waarschuwingsmeldingen te vermijden.

if tokenizer.pad_token_id is None:
    tokenizer.pad_token_id = tokenizer.eos_token_id
if model.config.pad_token_id is None:
    model.config.pad_token_id = model.config.eos_token_id

9. Maak de tekstgeneratiepipeline met het model en de tokenizer. 

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

10. Voer de pipeline uit met de aangepaste prompt. In ons geval vragen we naar Vincent van Gogh.

messages = [{"role": "user", "content": "Who is Vincent van Gogh?"}]

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

outputs = pipe(prompt, max_new_tokens=120, do_sample=True)

print(outputs[0]["generated_text"])

Het antwoord is behoorlijk accuraat. 

11. Laten we systeeminstructies meegeven om te zien of het complexe prompts begrijpt en volgt. We tonen de resultaten als HTML door de Markdown-code te combineren. 

from IPython.display import Markdown, display

messages = [
    {
        "role": "system",
        "content": "You are a skilled Python developer specializing in database management and optimization.",
    },
    {
        "role": "user",
        "content": "I'm experiencing a sorting issue in my database. Could you please provide Python code to help resolve this problem?",
    },
]

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

outputs = pipe(prompt, max_new_tokens=512, do_sample=True)

display(
    Markdown(
            outputs[0]["generated_text"].split(
                "<|start_header_id|>assistant<|end_header_id|>"
            )[1]
        )
    )

Het resultaat is zeer accuraat. Het model presteert behoorlijk goed, ondanks dat het slechts 3 miljard parameters heeft.

Heb je moeite om toegang te krijgen tot de lichte Llama 3.2-modellen? Raadpleeg dan het notebook Accessing the Llama 3.2 Lightweight Models.

Toegang krijgen tot de Llama 3.2 Vision-modellen in Kaggle

Toegang krijgen tot het Vision-model is eenvoudig, en je hoeft je geen zorgen te maken over GPU-geheugen, want we gebruiken meerdere GPU’s in deze gids. 

1. Dien het formulier in op de Meta | Llama 3.2 Vision-modelpagina. Accepteer alle voorwaarden en klik op de knop “Submit”. 

Bron: Meta | Llama 3.2 Vision | Kaggle

2. Scroll naar beneden, selecteer het tabblad Transformer en de vision-modelvariant, en klik vervolgens op “+ New Notebook”.

Bron: Meta | Llama 3.2 Vision | Kaggle

3. Zorg dat je “GPU T4 x2” gebruikt als accelerator. 
4. Werk de Python-pakketten Transformers en Accelerate bij.

%%capture
%pip install -U transformers accelerate

5. Laad de image processor en het Llama 3.2 vision-model. 

import torch
from transformers import MllamaForConditionalGeneration, AutoProcessor

base_model = "/kaggle/input/llama-3.2-vision/transformers/11b-vision-instruct/1"

processor = AutoProcessor.from_pretrained(base_model)

model = MllamaForConditionalGeneration.from_pretrained(
    base_model,
    low_cpu_mem_usage=True,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)

Zoals je ziet gebruikt dit bijna 25 GB aan GPU-geheugen. Dit is niet te draaien op een laptop of de gratis versie van Google Colab.

6. Laad de afbeelding. We hebben de uitgelichte afbeelding uit de tutorial gebruikt: OpenAI o1-preview Tutorial: Building a Machine Learning Project.
7. Schrijf het bericht en zet het om in een prompt met een chattemplate. Schrijf het bericht en zet het om in een prompt met een chattemplate. 
8. Verwerk zowel de afbeelding als de tekst en geef ze aan het model om de respons te genereren. 

import requests
from PIL import Image

url = "https://media.datacamp.com/cms/google/ad_4nxcz-j3ir2begccslzay07rqfj5ttakp2emttn0x6nkygls5ywl0unospj2s0-mrwpdtmqjl1fagh6pvkkjekqey_kwzl6qnodf143yt66znq0epflvx6clfoqw41oeoymhpz6qrlb5ajer4aeniogbmtwtd.png"
image = Image.open(requests.get(url, stream=True).raw)

messages = [
    {"role": "user", "content": [
        {"type": "image"},
        {"type": "text", "text": "Describe the tutorial feature image."}
    ]}
]
input_text = processor.apply_chat_template(messages, add_generation_prompt=True)
inputs = processor(image, input_text, return_tensors="pt").to(model.device)

output = model.generate(**inputs, max_new_tokens=120)
print(processor.decode(output[0]))

Als resultaat krijgen we een gedetailleerde beschrijving van de afbeelding. Die is behoorlijk accuraat. 

Loop je tegen problemen aan bij het draaien van bovenstaande code? Raadpleeg dan het Accessing the Llama 3.2 Vision Models-Kaggle-notebook.

Llama 3.2 3B Instruct fijn-afstemmen

In dit deel leren we hoe je het Llama 3.2 3B Instruct-model fijnstemt met de Transformers-bibliotheek op de klantenservicedataset. We gebruiken Kaggle om gratis GPU’s te gebruiken en meer RAM te krijgen dan bij Colab. 

1. Installatie

Start een nieuw notebook op Kaggle en stel de omgevingsvariabelen in. We gebruiken de Hugging Face API om het model op te slaan en Weights & Biases om de prestaties te volgen.

Installeer en update alle benodigde Python-pakketten. 

%%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 wandb

Laad de Python-pakketten en functies die we tijdens het fijn-afstemmen en evalueren gebruiken.

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_format

Log in op de Hugging Face CLI 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)

Log in bij Weights & Biases met de API-sleutel en maak het nieuwe project aan. 

wb_token = user_secrets.get_secret("wandb")

wandb.login(key=wb_token)
run = wandb.init(
    project='Fine-tune Llama 3.2 on Customer Support Dataset', 
    job_type="training", 
    anonymous="allow"
)

Stel de variabelen in voor basismodel, dataset en nieuwe modelnaam. We gebruiken ze op meerdere plekken in dit project, dus het is handig dit vooraf te doen om verwarring te voorkomen.

base_model = "/kaggle/input/llama-3.2/transformers/3b-instruct/1"
new_model = "llama-3.2-3b-it-Ecommerce-ChatBot"
dataset_name = "bitext/Bitext-customer-support-llm-chatbot-training-dataset"

2. Het model en de tokenizer laden

Stel het datatype en de attention-implementatie in.

# Set torch dtype and attention implementation
if torch.cuda.get_device_capability()[0] >= 8:
    !pip install -qqq flash-attn
    torch_dtype = torch.bfloat16
    attn_implementation = "flash_attention_2"
else:
    torch_dtype = torch.float16
    attn_implementation = "eager"

Laad het model en de tokenizer door de lokale modelmap op te geven. Hoewel ons model klein is, kost het laden van het volledige model en fijn-afstemmen tijd. In plaats daarvan laden we het model in 4-bit-kwantisatie.

# 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
)

# Load tokenizer
tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)

3. De dataset laden en verwerken

We laden de Bitext-customer-support-llm-chatbot-dataset van de Hugging Face Hub. Dit is een hybride synthetische dataset die we gebruiken om onze eigen aangepaste klantenservice-chatbot te bouwen.

We laden, schudden en selecteren slechts 1000 samples. We stemmen het model af op een kleine subset om de trainingstijd te beperken, maar je kunt altijd de volledige dataset gebruiken.

Vervolgens maken we de kolom "text" met de systeeminstructies, gebruikersvragen en assistentantwoorden. Daarna converteren we de JSON-respons naar het chatformaat.

#Importing the dataset
dataset = load_dataset(dataset_name, split="train")
dataset = dataset.shuffle(seed=65).select(range(1000)) # Only use 1000 samples for quick demo
instruction = """You are a top-rated customer service agent named John. 
    Be polite to customers and answer all their questions.
    """
def format_chat_template(row):
    
    row_json = [{"role": "system", "content": instruction },
               {"role": "user", "content": row["instruction"]},
               {"role": "assistant", "content": row["response"]}]
    
    row["text"] = tokenizer.apply_chat_template(row_json, tokenize=False)
    return row

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

Zoals je ziet hebben we de klantvraag en het assistentantwoord gecombineerd in een chatformaat. 

dataset['text'][3]

4. Het model configureren

Haal de lineaire modelnamen uit het model. 

import bitsandbytes as bnb

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)

Gebruik de naam van de lineaire module om de LoRA-adapter te maken. We stemmen alleen de LoRA-adapter fijn en laten de rest van het model ongemoeid om geheugen te besparen en sneller te trainen. 

# LoRA config
peft_config = LoraConfig(
    r=16,
    lora_alpha=32,
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
    target_modules=modules
)
model, tokenizer = setup_chat_format(model, tokenizer)
model = get_peft_model(model, peft_config)

We configureren de hyperparameters van het model om het in de Kaggle-omgeving te draaien. Je kunt elke hyperparameter begrijpen via de tutorial Fine-Tuning Llama 2 en ze aanpassen om de training op jouw systeem te optimaliseren.

#Hyperparamter
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,
    eval_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"
)

We richten nu een supervised fine-tuning (SFT) trainer in en geven een train- en evaluatieset, LoRA-configuratie, trainingsargument, tokenizer en model mee. 

# Setting sft parameters
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,
)

5. Modeltraining

Start het trainingsproces en monitor de training- en validatieverlies-metrics. 

trainer.train()

Het trainingverlies nam geleidelijk af. Dat is een goed teken. 

De gedetailleerde runhistorie wordt gegenereerd wanneer we de Weights & Biases-run afronden. 

wandb.finish()

Je kunt altijd het Weights & Biases-dashboard bezoeken om de modelmetrics grondig te bekijken.

6. Modelinference

Om het fijn-afgestemde model te testen, geven we een voorbeeldprompt uit de dataset mee. 

messages = [{"role": "system", "content": instruction},
    {"role": "user", "content": "I bought the same item twice, cancel order {{Order Number}}"}]

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_new_tokens=150, num_return_sequences=1)

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

print(text.split("assistant")[1])

Het fijn-afgestemde model heeft de stijl overgenomen en een nauwkeurig antwoord gegeven.

7. De tokenizer en het model opslaan

Sla het fijn-afgestemde model lokaal op en push het ook naar de Hugging Face Hub. De functie push_to_hub maakt een nieuwe modelrepository en pusht de modelbestanden naar je Hugging Face-repo. 

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

Bron: kingabzpro/llama-3.2-3b-it-Ecommerce-ChatBot

Wil je de grotere Llama 3-modellen fijn-afstemmen? Bekijk dan de tutorial Fine-Tuning Llama 3.1 for the Text Classification. Deze tutorial is erg populair en helpt je LLM’s op de volledige taak in te zetten. 

8. Het notebook opslaan

Klik rechtsboven op de knop "Save Version", kies de quick save-optie en wijzig de save output-optie om het modelbestand en alle code op te slaan.

Bekijk het Fine-tune Llama 3.2 on Customer Support-Kaggle-notebook voor broncode, resultaten en output. 

Dit is een gids met veel code. Zoek je een no-code of low-code gids voor het fijn-afstemmen van LLM’s? Bekijk dan de LlaMA-Factory WebUI Beginner's Guide: Fine-Tuning LLMs. 

Fijn-afgestemde Llama 3.2 samenvoegen en exporteren 

We maken een nieuw notebook en voegen het eerder opgeslagen notebook toe om toegang te krijgen tot de fijn-afgestemde LoRA-adapter, zodat we geheugenproblemen vermijden. 

Zorg ervoor dat je ook het basismodel “Llama 3.2 3B Instruct” hebt toegevoegd.

Installeer en update alle benodigde Python-pakketten. 

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

Log in op de Hugging Face CLI om het samengevoegde model naar de Hugging Face Hub te pushen. 

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)

Geef de locatie op van het basismodel en de fijn-afgestemde LoRA. We gebruiken die om het basismodel te laden en het met de adapter te mergen.

# Model
base_model_url = "/kaggle/input/llama-3.2/transformers/3b-instruct/1"
new_model_url = "/kaggle/input/fine-tune-llama-3-2-on-customer-support/llama-3.2-3b-it-Ecommerce-ChatBot/"

Laad de tokenizer en het volledige model. 

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, pipeline
from peft import PeftModel
import torch
from trl import setup_chat_format
# Reload tokenizer and model
tokenizer = AutoTokenizer.from_pretrained(base_model_url)

base_model_reload= AutoModelForCausalLM.from_pretrained(
    base_model_url,
    low_cpu_mem_usage=True,
    return_dict=True,
    torch_dtype=torch.float16,
    device_map="auto",
)

Pas het chatformaat toe op model en tokenizer. Voeg daarna het basismodel samen met de LoRA-adapter.

# Merge adapter with base model
base_model_reload, tokenizer = setup_chat_format(base_model_reload, tokenizer)
model = PeftModel.from_pretrained(base_model_reload, new_model_url)

model = model.merge_and_unload()

Om te controleren of het model succesvol is samengevoegd, geven we voorbeeldprompts mee en genereren we de respons. 

instruction = """You are a top-rated customer service agent named John. 
    Be polite to customers and answer all their questions.
    """

messages = [{"role": "system", "content": instruction},
    {"role": "user", "content": "I have to see what payment payment modalities are accepted"}]

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_new_tokens=150, num_return_sequences=1)

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

print(text.split("assistant")[1])

Zoals je ziet werkt ons fijn-afgestemde model perfect. 

Sla de tokenizer en het model lokaal op. 

new_model = "llama-3.2-3b-it-Ecommerce-ChatBot"

model.save_pretrained(new_model)
tokenizer.save_pretrained(new_model)

Push de tokenizer en het samengevoegde model naar de Hugging Face-modelrepository.

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

Na een paar minuten kun je alle modelbestanden met metadata-bestanden zien in je Hugging Face-repository.

Bron: kingabzpro/llama-3.2-3b-it-Ecommerce-ChatBot

Je kunt de broncode ook bekijken in het Merging and Exporting Fine-tuned Llama 3.2-Kaggle-notebook om meer te leren over samenvoegen en uploaden naar de Hugging Face Hub.

De volgende stap in dit project is het volledige model converteren naar het GGUF-formaat en het vervolgens kwantiseren. Daarna kun je het lokaal gebruiken met je favoriete chatapp, zoals Jan, Msty of GPT4ALL. Volg de gids Fine-Tuning Llama 3 and Using It Locally om te leren hoe je LLM’s naar GGUF converteert en ze lokaal op je laptop gebruikt.

Het samengevoegde model converteren naar GGUF-formaat

Om het fijn-afgestemde model lokaal te gebruiken, moeten we het eerst naar GGUF-formaat converteren. Waarom? Omdat dit het llama.cpp-formaat is en door alle desktop-chatbotapplicaties wordt geaccepteerd. 

Het converteren van het samengevoegde model naar llama.cpp-formaat is vrij eenvoudig. Ga naar de GGUF My Repo-pagina op de Hugging Face Hub. Log in met je Hugging Face-account. Typ de link naar de fijn-afgestemde modelrepository “kingabzpro/llama-3.2-3b-it-Ecommerce-ChatBot” en druk op de knop “Submit”. 

Bron: GGUF My Repo

Binnen enkele seconden wordt de gekwantiseerde versie van het model aangemaakt in een nieuwe Hugging Face-repository. 

Bron: kingabzpro/llama-3.2-3b-it-Ecommerce-ChatBot-Q4_K_M-GGUF

Klik op het tabblad “Files” en download alleen het GGUF-bestand. 

Bron: llama-3.2-3b-it-ecommerce-chatbot-q4_k_m.gguf

Het fijn-afgestemde model lokaal gebruiken

We gebruiken de Jan-chatbotapplicatie om ons fijn-afgestemde model lokaal te gebruiken. Ga naar de officiële website, jan.ai, om de applicatie te downloaden en te installeren. 

Bron: Jan

Klik op de instellingen, selecteer het menu “My Models” en druk op de knop “Import Model”. Geef daarna de lokale map van het model op. 

Ga naar het chatmenu en selecteer het fijn-afgestemde model, zoals hieronder.

Klik op het tabblad “Assistant” in het rechterpaneel en typ de systeemprompt.

Systeemprompt: “You are a top-rated customer service agent named John. Be polite to customers and answer all their questions.”

Klik op het tabblad “Model”, direct naast “Assistant”, en wijzig het stopteken in “<|eot_id|>”.

Dat is alles. Stel je vraag aan de klantenservice-AI over het probleem dat je ervaart. 

Prompt: “How do I order multiple items from the same vendor?”

De respons was accuraat en supersnel—bijna 102 tokens per seconde.

Conclusie

Fijn-afstemmen van kleinere LLM’s bespaart kosten en verbetert de inferentietijd. Met genoeg data kun je de modelprestaties op bepaalde taken verbeteren tot in de buurt van GPT-4-mini. Kort gezegd: de toekomst van AI draait om het gebruik van meerdere kleinere LLM’s in een grid met een master-slave-relatie. 

Het mastermodeI ontvangt de initiële prompt en beslist welk gespecialiseerd model het beste de antwoorden kan genereren. Dit vermindert rekentijd, verbetert de resultaten en verlaagt de operationele kosten.

In deze tutorial hebben we Llama 3.2 besproken en hoe je er in Kaggle toegang toe krijgt. We hebben ook geleerd hoe je het lichte Llama 3.2-model fijnstemt op de klantenservicedataset, zodat het in een bepaalde stijl reageert en domeinspecifieke informatie accuraat geeft. Daarna hebben we de LoRA-adapter samengevoegd met het basismodel en het volledige model naar de Hugging Face Hub gepusht. Tot slot hebben we het samengevoegde model naar GGUF geconverteerd en het lokaal op de laptop gebruikt met de Jan-chatbotapplicatie.

Volg onze Working with Hugging Face interactieve cursus om te leren werken met de tool en modellen fijn te stemmen.