Llama 3.1 fijn-afstemmen voor tekstclassificatie

Voordat we beginnen, een korte noot: bij AI-toepassingen in de zorg is het cruciaal om stil te staan bij mogelijke schadelijke gevolgen voor patiënten. Het onderstaande voorbeeld, hoewel uitgebreid, is uitsluitend bedoeld om fine-tunen op een real-world dataset te illustreren. Werk je aan AI-use-cases in de zorg of andere gevoelige domeinen, lees dan zeker onze gids over AI-ethiek.

In deze tutorial maken we kennis met de Llama 3.1-modellen en finetunen we het Llama-3.1-8b-It-model op sentimentanalyse voor de mental health-dataset. Ons doel is het model zo aan te passen dat het op basis van tekst de psychische gezondheidstoestand van een patiënt kan voorspellen. We voegen de adapter ook samen met het basismodel en slaan het volledige model op in de Hugging Face Hub. 

We leren over Llama 3.1-modellen, hoe je ze op Kaggle kunt gebruiken en hoe je met de Transformer-bibliotheek inferentie draait. We finetunen ook het Llama-3.1-8b-It-model op de classificatiedataset voor mentale gezondheid. Tot slot mergen we de opgeslagen adapter met het basismodel en pushen we het volledige model naar de Hugging Face Hub.

Ben je nieuw met dit onderwerp, lees dan eerst ons artikel Een introductiegids voor het finetunen van LLM’s. 

Afbeelding door de auteur

Introductie van Llama 3.1

Llama 3.1 is de nieuwste serie meertalige large language models (LLM’s) ontwikkeld door Meta AI, die de grenzen van taalbegrip en -generatie verleggen. Er zijn drie groottes: 8B, 70B en 405B parameters.

Llama 3.1-modellen zijn gebaseerd op een autoregressieve taalmodelarchitectuur met geoptimaliseerde transformers en kunnen worden gefinetuned voor diverse NLP-taken en datasets. Ze zijn getraind op een divers corpus van publiek beschikbare online data, ondersteunen acht talen (Engels, Duits, Frans, Italiaans, Portugees, Hindi, Spaans en Thais) en hebben een contextlengte van 128k. 

Llama 3.1-modellen zijn voor iedereen beschikbaar onder aangepaste commerciële licenties en vereisen minimale persoonlijke informatie om de modelgewichten te downloaden.

Llama 3.1 is geoptimaliseerd voor meertalige dialogen en presteert beter dan Gemma 2, GPT‑3.5 Turbo en GPT‑4o op diverse benchmarks, waaronder algemene chat, coderen, wiskunde, redeneren en meer. Het is veruit het snelste en nauwkeurigste open-sourcemodel dat beschikbaar is.

Bron: Llama 3.1 (meta.com)

Meer weten over het Llama 3.1-model? Lees Wat is Meta’s Llama 3.1 405B? Werking, use-cases & meer.

Aan de slag met Llama 3.1

Voor deze tutorial gebruiken we Kaggle Notebook als ontwikkelomgeving, omdat het gratis GPU’s en TPU’s biedt. Volg deze stappen om het Llama 3.1-model in een Kaggle-notebook te gebruiken:

1. Vul het formulier in op meta.com met hetzelfde e-mailadres als je Kaggle-account.

2. Ga naar de Meta | Llama 3.1-modelrepository op Kaggle en klik op de knop "access the model". Accepteer alle voorwaarden en na enkele seconden krijg je toegang tot het model.

3. Start het Kaggle-notebook met Llama 3.1-modellen door op de knop "Code" rechtsboven op de modelpagina te klikken.

4. Selecteer het framework, de variant en de versie, en klik op de knop "Add Model".

5. Installeer de benodigde Python-pakketten in het Kaggle-notebook met het volgende commando:

%pip install -U transformers accelerateMogelijk gemaakt door

6. Laad het model en de tokenizer met de Transformers-bibliotheek vanuit de lokale map.

7. Maak de text-generation pipeline met model, tokenizer, torch-type en device map.

from transformers import AutoTokenizer,AutoModelForCausalLM,pipeline
import torch

base_model = "/kaggle/input/llama-3.1/transformers/8b-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,
)
pipe = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
    torch_dtype=torch.float16,
    device_map="auto",
)Mogelijk gemaakt door

8. Schrijf het bericht en zet het om naar de juiste prompt met de chattemplate.

9. Draai de pipeline met de prompt en print de gegenereerde output.

messages = [{"role": "user", "content": "What is the tallest building in the world?"}]

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

Het antwoord is nauwkeurig en gedetailleerd. 

Loop je vast bij de modelinference, raadpleeg dan het Kaggle-notebook Llama 3.1 Simple Model Inference. 

Llama 3.1 finetunen voor classificatie van psychische aandoeningen 

Nu moeten we de dataset laden, verwerken en het Llama 3.1-model finetunen. We vergelijken ook de modelprestaties vóór en na het finetunen.

Als je nieuw bent met LLM’s, raad ik aan eerst de cursus Master Large Language Models (LLMs) Concepts te volgen voordat je aan het finetunen begint.

1. Installatie

We starten eerst een nieuw Kaggle-notebook en het Llama 3.1-model, net zoals in de vorige sectie.

Daarna installeren we de benodigde Python-pakketten zoals hieronder beschreven:

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

Vervolgens voegen we de Sentiment Analysis for Mental Health-data toe aan het Kaggle-notebook.  Klik hiervoor op de knop “Add Input” rechtsboven en plak de modellink in de zoekbalk. Klik daarna op de plusknop (+) om het model toe te voegen.

We volgen de prestaties met de Weights and Biases-API. Daarvoor hebben we de API-sleutel nodig. Stel de API-sleutel in Kaggle in via Secrets en activeer deze, zoals hieronder getoond.  

Daarna kunnen we het Weights and Biases-project starten met de API-sleutel.

import wandb

from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()

wb_token = user_secrets.get_secret("wandb")

wandb.login(key=wb_token)
run = wandb.init(
    project='Fine-tune llama-3.1-8b-it on Sentiment Analysis Dataset', 
    job_type="training", 
    anonymous="allow"
)Mogelijk gemaakt door

Vervolgens importeren we alle benodigde Python-pakketten en functies.

import numpy as np
import pandas as pd
import os
from tqdm import tqdm
import bitsandbytes as bnb
import torch
import torch.nn as nn
import transformers
from datasets import Dataset
from peft import LoraConfig, PeftConfig
from trl import SFTTrainer
from trl import setup_chat_format
from transformers import (AutoModelForCausalLM, 
                          AutoTokenizer, 
                          BitsAndBytesConfig, 
                          TrainingArguments, 
                          pipeline, 
                          logging)
from sklearn.metrics import (accuracy_score, 
                             classification_report, 
                             confusion_matrix)
from sklearn.model_selection import train_test_splitMogelijk gemaakt door

2. De dataset laden en verwerken

Tijd om de dataset te laden, de data op te schonen en drie ambigue categorieën te verwijderen. 

Om het eenvoudiger te maken, laten we de categorie "Suicidal" weg, omdat Llama 3.1 veiligheidsmechanismen heeft die bepaalde triggerwoorden blokkeren. "Stress" geldt niet als psychische stoornis en "Personality Disorder" overlapt sterk met "Bipolar". 

Daardoor houden we vier categorieën over: "Normal", "Depression", "Anxiety" en "Bipolar".

df = pd.read_csv("/kaggle/input/sentiment-analysis-for-mental-health/Combined Data.csv",index_col = "Unnamed: 0")
df.loc[:,'status'] = df.loc[:,'status'].str.replace('Bi-Polar','Bipolar')
df = df[(df.status != "Personality disorder") & (df.status != "Stress") & (df.status != "Suicidal")]
df.head()Mogelijk gemaakt door

Om traintijd te besparen, finetunen we het model op slechts 3000 samples. Daarvoor schudden we de dataset en selecteren we 3000 rijen. 

Vervolgens splitsen we de dataset in train-, eval- en test-sets voor training en testen van het model. 

We willen ook de kolom “text” in de train- en eval-sets maken met de functie generate_prompt, die de gegevens uit de kolommen “statement” en “status” samenvoegt. 

Tot slot maken we de kolom “text” in de testset met generate_test_prompt en y_true op basis van de kolom “status”. Die gebruiken we om het evaluatierapport van het model te genereren, zoals hieronder.

# Shuffle the DataFrame and select only 3000 rows
df = df.sample(frac=1, random_state=85).reset_index(drop=True).head(3000)

# Split the DataFrame
train_size = 0.8
eval_size = 0.1

# Calculate sizes
train_end = int(train_size * len(df))
eval_end = train_end + int(eval_size * len(df))

# Split the data
X_train = df[:train_end]
X_eval = df[train_end:eval_end]
X_test = df[eval_end:]

# Define the prompt generation functions
def generate_prompt(data_point):
    return f"""
            Classify the text into Normal, Depression, Anxiety, Bipolar, and return the answer as the corresponding mental health disorder label.
text: {data_point["statement"]}
label: {data_point["status"]}""".strip()

def generate_test_prompt(data_point):
    return f"""
            Classify the text into Normal, Depression, Anxiety, Bipolar, and return the answer as the corresponding mental health disorder label.
text: {data_point["statement"]}
label: """.strip()

# Generate prompts for training and evaluation data
X_train.loc[:,'text'] = X_train.apply(generate_prompt, axis=1)
X_eval.loc[:,'text'] = X_eval.apply(generate_prompt, axis=1)

# Generate test prompts and extract true labels
y_true = X_test.loc[:,'status']
X_test = pd.DataFrame(X_test.apply(generate_test_prompt, axis=1), columns=["text"])Mogelijk gemaakt door

Op dit punt willen we de verdeling van de categorieën in de trainset controleren.

X_train.status.value_counts()Mogelijk gemaakt door

Hieronder zie je dat "Normal" en "Depression" bijna gelijk verdeeld zijn. De overige labels zijn in de minderheid. Dat betekent dat onze dataset uit balans is en dat het model beter zal zijn in het voorspellen van meerderheidlabels dan van minderheidslabels. 

We zouden de dataset kunnen balanceren, maar dat is niet het doel van deze tutorial.

status
Normal        1028
Depression     938
Anxiety        258
Bipolar        176
Name: count, dtype: int64Mogelijk gemaakt door

Vervolgens willen we de train- en eval-set omzetten naar Hugging Face-datasets.

# Convert to datasets
train_data = Dataset.from_pandas(X_train[["text"]])
eval_data = Dataset.from_pandas(X_eval[["text"]])Mogelijk gemaakt door

Daarna tonen we het 4e sample uit de kolom “text”.

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

We zien dat de kolom “text” een system prompt, de “statement” en de statussen als labels bevat. 

3. Het model en de tokenizer laden

Vervolgens laden we het Llama-3.1-8b-instruct-model in 4‑bit kwantisatie om GPU-geheugen te besparen. 

Daarna laden we de tokenizer en stellen we het pad token id in. 

base_model_name = "/kaggle/input/llama-3.1/transformers/8b-instruct/1"

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

model = AutoModelForCausalLM.from_pretrained(
    base_model_name,
    device_map="auto",
    torch_dtype="float16",
    quantization_config=bnb_config, 
)

model.config.use_cache = False
model.config.pretraining_tp = 1

tokenizer = AutoTokenizer.from_pretrained(base_model_name)

tokenizer.pad_token_id = tokenizer.eos_token_idMogelijk gemaakt door

4. Modellevaluatie vóór finetunen

Hier maken we de functie predict, die de text-generation pipeline gebruikt om labels te voorspellen uit de kolom “text”. Het uitvoeren van de functie geeft een lijst met categorieën van psychische aandoeningen op basis van verschillende samples in de testset. 

def predict(test, model, tokenizer):
    y_pred = []
    categories = ["Normal", "Depression", "Anxiety", "Bipolar"]
    
    for i in tqdm(range(len(test))):
        prompt = test.iloc[i]["text"]
        pipe = pipeline(task="text-generation", 
                        model=model, 
                        tokenizer=tokenizer, 
                        max_new_tokens=2, 
                        temperature=0.1)
        
        result = pipe(prompt)
        answer = result[0]['generated_text'].split("label:")[-1].strip()
        
        # Determine the predicted category
        for category in categories:
            if category.lower() in answer.lower():
                y_pred.append(category)
                break
        else:
            y_pred.append("none")
    
    return y_pred

y_pred = predict(X_test, model, tokenizer)Mogelijk gemaakt door

100%|██████████| 300/300 [02:54<00:00,  1.72it/s]Mogelijk gemaakt door

Daarna maken we de functie evaluate, die de voorspelde labels en ware labels gebruikt om de algehele nauwkeurigheid en de nauwkeurigheid per categorie te berekenen, een classificatierapport te genereren en een confusionmatrix te printen. Het uitvoeren van de functie geeft een gedetailleerde evaluatiesamenvatting. 

def evaluate(y_true, y_pred):
    labels = ["Normal", "Depression", "Anxiety", "Bipolar"]
    mapping = {label: idx for idx, label in enumerate(labels)}
    
    def map_func(x):
        return mapping.get(x, -1)  # Map to -1 if not found, but should not occur with correct data
    
    y_true_mapped = np.vectorize(map_func)(y_true)
    y_pred_mapped = np.vectorize(map_func)(y_pred)
    
    # Calculate accuracy
    accuracy = accuracy_score(y_true=y_true_mapped, y_pred=y_pred_mapped)
    print(f'Accuracy: {accuracy:.3f}')
    
    # Generate accuracy report
    unique_labels = set(y_true_mapped)  # Get unique labels
    
    for label in unique_labels:
        label_indices = [i for i in range(len(y_true_mapped)) if y_true_mapped[i] == label]
        label_y_true = [y_true_mapped[i] for i in label_indices]
        label_y_pred = [y_pred_mapped[i] for i in label_indices]
        label_accuracy = accuracy_score(label_y_true, label_y_pred)
        print(f'Accuracy for label {labels[label]}: {label_accuracy:.3f}')
        
    # Generate classification report
    class_report = classification_report(y_true=y_true_mapped, y_pred=y_pred_mapped, target_names=labels, labels=list(range(len(labels))))
    print('\nClassification Report:')
    print(class_report)
    
    # Generate confusion matrix
    conf_matrix = confusion_matrix(y_true=y_true_mapped, y_pred=y_pred_mapped, labels=list(range(len(labels))))
    print('\nConfusion Matrix:')
    print(conf_matrix)

evaluate(y_true, y_pred)Mogelijk gemaakt door

Llama 3.1 presteert al uitstekend, zelfs zonder finetunen. 79% nauwkeurigheid is al behoorlijk. Kijken we hoe het model verbetert na finetunen op de dataset.

Accuracy: 0.790
Accuracy for label Normal: 0.741
Accuracy for label Depression: 0.939
Accuracy for label Anxiety: 0.556
Accuracy for label Bipolar: 0.533

Classification Report:
              precision    recall  f1-score   support

      Normal       0.92      0.74      0.82       143
  Depression       0.70      0.94      0.80       115
     Anxiety       0.68      0.56      0.61        27
     Bipolar       0.89      0.53      0.67        15

    accuracy                           0.79       300
   macro avg       0.80      0.69      0.73       300
weighted avg       0.81      0.79      0.79       300


Confusion Matrix:
[[106  33   4   0]
 [  3 108   3   1]
 [  4   8  15   0]
 [  2   5   0   8]]Mogelijk gemaakt door

5. Het model opzetten

Bij het opzetten van het model beginnen we met het extraheren van de namen van lineaire modules uit het model met de bits and bytes-bibliotheek. 

Daarna configureren we LoRA met de targetmodules, het taaktype en andere parameters voordat we de trainingarguments instellen. Deze trainingsparameters zijn geoptimaliseerd voor het Kaggle-notebook. Mogelijk moet je ze aanpassen als je lokaal traint. 

Vervolgens maken we de modeltrainer met trainingarguments, een model, een tokenizer, een LoRA-configuratie en een dataset. 

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

['down_proj', 'gate_proj', 'o_proj', 'v_proj', 'up_proj', 'q_proj', 'k_proj']Mogelijk gemaakt door

output_dir="llama-3.1-fine-tuned-model"

peft_config = LoraConfig(
    lora_alpha=16,
    lora_dropout=0,
    r=64,
    bias="none",
    task_type="CAUSAL_LM",
    target_modules=modules,
)

training_arguments = TrainingArguments(
    output_dir=output_dir,                    # directory to save and repository id
    num_train_epochs=1,                       # number of training epochs
    per_device_train_batch_size=1,            # batch size per device during training
    gradient_accumulation_steps=8,            # number of steps before performing a backward/update pass
    gradient_checkpointing=True,              # use gradient checkpointing to save memory
    optim="paged_adamw_32bit",
    logging_steps=1,                         
    learning_rate=2e-4,                       # learning rate, based on QLoRA paper
    weight_decay=0.001,
    fp16=True,
    bf16=False,
    max_grad_norm=0.3,                        # max gradient norm based on QLoRA paper
    max_steps=-1,
    warmup_ratio=0.03,                        # warmup ratio based on QLoRA paper
    group_by_length=False,
    lr_scheduler_type="cosine",               # use cosine learning rate scheduler
    report_to="wandb",                  # report metrics to w&b
    eval_strategy="steps",              # save checkpoint every epoch
    eval_steps = 0.2
)

trainer = SFTTrainer(
    model=model,
    args=training_arguments,
    train_dataset=train_data,
    eval_dataset=eval_data,
    peft_config=peft_config,
    dataset_text_field="text",
    tokenizer=tokenizer,
    max_seq_length=512,
    packing=False,
    dataset_kwargs={
    "add_special_tokens": False,
    "append_concat_token": False,
    }
)Mogelijk gemaakt door

6. Modeltraining

Tijd om de training van het model te starten:

trainer.train()Mogelijk gemaakt door

Het finetunen duurde 1,5 uur en het validatieverlies daalde geleidelijk. Voor nog betere prestaties kun je het model op de volledige dataset trainen voor minimaal vijf epochs.

Vervolgens sluiten we de Weights and Biases-run af.

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

We kunnen de runsamenvatting bekijken, inclusief alle benodigde prestatiestatistieken.

Voor een gedetailleerde samenvatting ga je naar je Weights and Biases-account en bekijk je de run in je browser. Je krijgt interactieve visualisaties.

Daarna slaan we zowel de modeladapter als de tokenizer lokaal op. In de volgende sectie gebruiken we dit om de adapter met het basismodel samen te voegen.

# Save trained model and tokenizer
trainer.save_model(output_dir)
tokenizer.save_pretrained(output_dir)Mogelijk gemaakt door

7. Het model testen na finetunen

Nu komt het belangrijkste: presteert ons model beter na het finetunen of juist slechter? Om dat te achterhalen draaien we de functie ‘predict’ op de testset en daarna de functie ‘evaluate’ om een evaluatierapport te genereren.

y_pred = predict(X_test, model, tokenizer)
evaluate(y_true, y_pred)Mogelijk gemaakt door

Zoals je hieronder ziet, is dit een enorme verbetering: van 79% naar 91,3% nauwkeurigheid. Ook de F1-scores zien er goed uit. 

100%|██████████| 300/300 [03:24<00:00,  1.47it/s]
Accuracy: 0.913
Accuracy for label Normal: 0.972
Accuracy for label Depression: 0.913
Accuracy for label Anxiety: 0.667
Accuracy for label Bipolar: 0.800

Classification Report:
              precision    recall  f1-score   support

      Normal       0.92      0.97      0.95       143
  Depression       0.93      0.91      0.92       115
     Anxiety       0.75      0.67      0.71        27
     Bipolar       1.00      0.80      0.89        15

    accuracy                           0.91       300
   macro avg       0.90      0.84      0.87       300
weighted avg       0.91      0.91      0.91       300


Confusion Matrix:
[[139   3   1   0]
 [  5 105   5   0]
 [  6   3  18   0]
 [  1   2   0  12]]Mogelijk gemaakt door

Sla nu het Kaggle-notebook op om de resultaten en modelfiles te bewaren. Klik op de knop “Save Version” rechtsboven, kies versie “Quick Save” en selecteer bij opslaan “Always save output when creating a Quick Save”.

Heb je moeite met finetunen, raadpleeg dan het Kaggle-notebook voor extra hulp. 

Je kunt ook leren hoe je Llama 3.0-modellen finetunet met onze gids Llama 3 finetunen en lokaal gebruiken. 

De gefinetunede Llama 3.1 samenvoegen en opslaan

In deze sectie voegen we de adapter samen met het basismodel en slaan we de volledige versie op in de Hugging Face Hub. 

We starten eerst een nieuw Kaggle-notebook met GPU-versnelling en voegen het opgeslagen notebook toe om toegang te krijgen tot de modelfiles. Je kunt ook andere Kaggle-notebooks als input opnemen, vergelijkbaar met het toevoegen van een dataset.

Daarna installeren we de benodigde Python-pakketten. 

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

Vervolgens loggen we in op de Hugging Face Hub-API met de API-sleutel om onze modelfiles naar de Hugging Face-modelrepository 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)Mogelijk gemaakt door

Daarna stellen we de map van het basismodel en het gefinetunede model in.

base_model = "/kaggle/input/llama-3.1/transformers/8b-instruct/1"
fine_tuned_model = "/kaggle/input/fine-tune-llama-3-1-for-text-classification/llama-3.1-fine-tuned-model/"Mogelijk gemaakt door

Laad vervolgens de tokenizer en het basismodel. 

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


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

We voegen het basismodel samen met de gefinetunede adapter, zoals hieronder te zien is. 

# Merge adapter with base model
model = PeftModel.from_pretrained(base_model_reload, fine_tuned_model)
model = model.merge_and_unload()Mogelijk gemaakt door

Voordat we ons model opslaan, controleren we of het goed werkt. Maak een text-generation pipeline met het model en de tokenizer en geef een voorbeeldprompt op. 

text = "I'm trapped in a storm of emotions that I can't control, and it feels like no one understands the chaos inside me"
prompt = f"""Classify the text into Normal, Depression, Anxiety, Bipolar, and return the answer as the corresponding mental health disorder label.
text: {text}
label: """.strip()

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

outputs = pipe(prompt, max_new_tokens=2, do_sample=True, temperature=0.1)
print(outputs[0]["generated_text"].split("label: ")[-1].strip())Mogelijk gemaakt door

Ons model werkt perfect.

DepressionMogelijk gemaakt door

We kunnen nu het model en de tokenizer lokaal opslaan. 

model_dir = "Llama-3.1-8B-Instruct-Mental-Health-Classification"
model.save_pretrained(model_dir)
tokenizer.save_pretrained(model_dir)Mogelijk gemaakt door

En vervolgens het model en de tokenizer naar de Hugging Face Hub pushen.

model.push_to_hub(model_dir, use_temp_dir=False)
tokenizer.push_to_hub(model_dir, use_temp_dir=False)Mogelijk gemaakt door

Dit maakt de repository op Hugging Face aan en pusht alle model- en tokenizerbestanden.

CommitInfo(commit_url='https://huggingface.co/kingabzpro/Llama-3.1-8B-Instruct-Mental-Health-Classification/commit/e1244abeaac159e0a48439095200a4190c2b493c', commit_message='Upload tokenizer', commit_description='', oid='e1244abeaac159e0a48439095200a4190c2b493c', pr_url=None, pr_revision=None, pr_num=None)Mogelijk gemaakt door

We kunnen alle modelfiles bekijken op de website van Hugging Face. 

Bron: kingabzpro/Llama-3.1-8B-Instruct-Mental-Health-Classification · Hugging Face

Loop je tegen problemen aan bij het mergen van de adapter met het basismodel, raadpleeg dan het Kaggle-notebook.

Vind je het finetunen van LLM’s lastig, volg dan de tutorial OpenAI’s GPT‑4 finetunen: een stapsgewijze gids om te leren hoe je met de OpenAI-API eenvoudiger een model op elke dataset kunt finetunen met slechts een paar regels code.

Slotgedachten

Finetunen van een model is niet beperkt tot aanpassing op basis van een dataset. We kunnen LLM’s finetunen voor verschillende NLP-taken zoals machinevertaling, clustering, classificatie, vraag-en-antwoord, embedding en meer. 

In deze tutorial hebben we geleerd hoe je het Llama 3.1-model finetunet op een classificatiedataset voor mentale gezondheid. Dit model kan worden gebruikt om patiënten en zelfs medewerkers te identificeren die uitdagingen ervaren in hun dagelijkse leven.

Wil je aan de slag met LLM’s en zelf modellen finetunen, overweeg dan de skill track Developing Large Language Models te volgen. Met deze reeks cursussen bouw je een sterke basis in LLM’s, zodat je vol vertrouwen kunt meebewegen met het nieuwe AI-landschap.