Feinabstimmung von Llama 3.1 für die Textklassifizierung

Bevor wir anfangen, noch ein Hinweis: Wenn wir uns KI-Einsatzfällen im Gesundheitswesen nähern, ist es äußerst wichtig, auf potenziell schädliche Folgen für Patienten zu achten. Das folgende Beispiel ist zwar umfassend, dient aber nur zur Veranschaulichung der Feinabstimmung an einem realen Datensatz. Wenn du KI im Gesundheitswesen oder in anderen sensiblen Bereichen einsetzt, empfehlen wir dir, unseren Leitfaden zur KI-Ethik zu lesen.

In diesem Tutorial lernen wir die Llama-3.1-Modelle kennen und nehmen eine Feinabstimmung des Llama-3.1-8b-It-Modells für die Sentiment-Analyse des Datensatzes zur psychischen Gesundheit vor. Unser Ziel ist es, das Modell so anzupassen, dass es den psychischen Gesundheitszustand des Patienten auf der Grundlage des Textes vorhersagen kann. Wir werden auch den Adapter mit dem Basismodell zusammenführen und das vollständige Modell auf dem Hugging Face Hub speichern. 

Wir lernen die Llama 3.1-Modelle kennen, wie man auf sie bei Kaggle zugreift und wie man die Transformer-Bibliothek verwendet, um die Modellinferenz durchzuführen. Außerdem werden wir das Llama-3.1-8b-It-Modell anhand des Klassifizierungsdatensatzes für psychische Gesundheit feinabstimmen. Zum Schluss fügen wir den gespeicherten Adapter mit dem Basismodell zusammen und senden das vollständige Modell an den Hugging Face Hub.

Wenn du neu auf dem Gebiet bist, kannst du dich in unserem Artikel über die Theorie des Feintunings informieren, Einleitender Leitfaden zur Feinabstimmung von LLMs.

Bild vom Autor

Wir stellen vor: Llama 3.1

Llama 3.1 ist die neueste Serie mehrsprachiger großer Sprachmodelle (LLMs), die von Meta AI entwickelt wurden und die Grenzen des Sprachverständnisses und der Spracherzeugung verschieben. Er ist in drei Größen erhältlich: 8B, 70B und 405B Parameter.

Die Llama 3.1-Modelle basieren auf einer autoregressiven Sprachmodell-Architektur mit optimierten Transformatoren und können für verschiedene Aufgaben und Datensätze der natürlichen Sprachverarbeitung fein abgestimmt werden. Sie werden auf einem vielfältigen Datensatz öffentlich zugänglicher Online-Daten trainiert, unterstützen acht Sprachen (Englisch, Deutsch, Französisch, Italienisch, Portugiesisch, Hindi, Spanisch und Thailändisch) und verfügen über eine Kontextlänge von 128k. 

Die Llama 3.1 Modelle sind für jedermann unter kommerziellen Lizenzen erhältlich und erfordern nur minimale Informationen über die Person, um die Modellgewichte herunterzuladen.

Llama 3.1 ist für mehrsprachige Dialoge optimiert und hat Gemma 2, GPT 3.5 turbo und GPT-4o in verschiedenen Benchmarks übertroffen, darunter allgemeiner Chat, Codierung, Mathematik, logisches Denken und mehr. Es ist das mit Abstand schnellste und genaueste Open-Source-Modell, das es gibt.

Quelle: Llama 3.1 (meta.com)

Mehr über das Llama 3.1 Modell erfährst du unter Was ist das Llama 3.1 405B von Meta? Funktionsweise, Anwendungsfälle und mehr.

Erste Schritte mit Llama 3.1

Für dieses Tutorial werden wir Kaggle Notebook als Entwicklungsumgebung verwenden, da es kostenlose GPUs und TPUs bietet. Um das Llama 3.1-Modell auf dem Kaggle-Notebook zu verwenden, befolge diese Schritte:

1. Fülle das Formular auf meta.com mit der gleichen E-Mail-Adresse wie dein Kaggle-Konto aus.

2. Zugriff auf die Meta | Llama 3.1 Modell-Repository auf Kaggle und klicke auf die Schaltfläche "Zugriff auf das Modell". Akzeptiere alle Bedingungen und nach ein paar Sekunden erhältst du Zugang zu dem Modell.

3. Starte das Kaggle-Notizbuch mit den Llama 3.1-Modellen, indem du auf die Schaltfläche "Code" oben rechts auf der Modellseite klickst.

4. Wähle das Framework, die Variante und die Version aus und klicke auf die Schaltfläche "Modell hinzufügen".

5. Installiere die notwendigen Python-Pakete im Kaggle-Notebook mit dem folgenden Befehl:

%pip install -U transformers accelerate

6. Lade das Modell und den Tokenizer mit Hilfe der Transformers-Bibliothek aus dem lokalen Verzeichnis.

7. Erstelle die Textgenerierungspipeline mit dem Modell, dem Tokenizer, dem Fackeltyp und der Gerätekarte.

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

8. Schreibe die Nachricht und wandle sie mit Hilfe der Chat-Vorlage in die richtige Eingabeaufforderung um.

9. Führe die Pipeline über die Eingabeaufforderung aus und drucke die erzeugte Ausgabe aus.

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"])

Die Antwort ist genau und detailliert. 

Solltest du bei der Modellinferenz auf Schwierigkeiten stoßen, schaue bitte im Kaggle Notebook nach unter Llama 3.1 Einfache Modellinferenz.

Feinabstimmung von Llama 3.1 zur Klassifizierung psychischer Störungen 

Jetzt müssen wir den Datensatz laden, ihn verarbeiten und das Llama 3.1-Modell feinabstimmen. Wir werden auch die Leistung des Modells vor und nach der Feinabstimmung vergleichen.

Wenn du neu bei LLMs bist, empfehle ich dir den Kurs Master Large Language Models (LLMs) Konzepte zu besuchen, bevor du dich mit der Feinabstimmung des Tutorials beschäftigst.

1. Einrichten

Als erstes starten wir das neue Kaggle-Notebook und das Llama 3.1-Modell wie im vorherigen Abschnitt.

Anschließend installieren wir die notwendigen Python-Pakete wie unten beschrieben:

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

Als nächstes fügen wir die Sentiment-Analyse für psychische Gesundheit Daten in das Kaggle-Notizbuch ein.  Dazu klickst du auf die Schaltfläche "Eingabe hinzufügen" oben rechts und fügst den Link zum Modell in die Suchleiste ein. Um das Modell hinzuzufügen, klickst du einfach auf das Pluszeichen (+).

Wir werden die Leistung des Modells mithilfe der API für Gewichte und Verzerrungen verfolgen. Um auf die API zuzugreifen, brauchen wir den API-Schlüssel. Richte den API-Schlüssel in Kaggle mit Secrets ein und aktiviere ihn, wie unten gezeigt.  

Dann können wir das Projekt "Gewichte und Verzerrungen" mit dem API-Schlüssel starten.

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

Als Nächstes müssen wir alle notwendigen Python-Pakete und -Funktionen importieren.

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_split

2. Laden und Verarbeiten des Datensatzes

Jetzt ist es an der Zeit, den Datensatz zu laden, die Daten zu bereinigen und drei mehrdeutige Kategorien zu löschen. 

Um die Dinge zu vereinfachen, werden wir die Kategorie "Selbstmordgefährdet" streichen, da Llama 3.1 Sicherheitsmechanismen hat, die bestimmte auslösende Wörter verhindern. "Stress" gilt nicht als psychische Störung und "Persönlichkeitsstörung" hat viele Überschneidungen mit "bipolarer Störung". 

Es bleiben also nur vier Kategorien übrig: "Normal", "Depression", "Angstzustände" und "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()

Um Trainingszeit zu sparen, werden wir das Modell mit nur 3000 Stichproben feinabstimmen. Dazu werden wir den Datensatz mischen und 3000 Zeilen auswählen. 

Dann teilen wir den Datensatz in die Gruppen train, eval und test auf, um das Modell zu trainieren und zu testen. 

Wir wollen auch die Spalte "text" in train und eval Sets mit der Funktion generate_prompt erstellen, die die Daten aus den Spalten "statement" und "status" kombiniert. 

Schließlich erstellen wir die Spalte "Text" im Testset mit der Funktion generate_test_prompt und die y_true mit der Spalte "Status". Wir verwenden sie, um den Bericht zur Modellbewertung zu erstellen, wie unten gezeigt.

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

An dieser Stelle wollen wir die Verteilung der Kategorien in der Zuggarnitur überprüfen.

X_train.status.value_counts()

Du kannst unten sehen, dass die Kategorien "Normal" und "Depression" fast gleich verteilt sind. Der Rest der Labels ist in der Minderheit. Das bedeutet, dass unser Datensatz unausgewogen ist und das Modell die Mehrheitsbezeichnungen besser vorhersagen kann als die Minderheitsbezeichnungen. 

Wir können den Datensatz ausgleichen, aber das ist nicht das Ziel dieses Tutorials.

status
Normal        1028
Depression     938
Anxiety        258
Bipolar        176
Name: count, dtype: int64

Als Nächstes wollen wir das Train- und Eval-Set in die Hugging Face-Datensätze umwandeln.

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

Dann zeigen wir das 4. Beispiel aus der Spalte "Text" an.

train_data['text'][3]

Wir sehen, dass die Spalte "Text" eine Systemabfrage, die Anweisung und den Status als Beschriftung hat. 

3. Laden des Modells und des Tokenizers

Als nächstes wollen wir das Llama-3.1-8b-Instruct-Modell in 4-Bit-Quantisierung laden. Quantisierung um den Speicher der GPU zu schonen.

Dann laden wir den Tokenizer und setzen die Pad-Token-ID. 

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_id

4. Modellbewertung vor der Feinabstimmung

Hier erstellen wir die Funktion predict, die die Textgenerierungspipeline nutzt, um die Beschriftungen aus der Spalte "Text" vorherzusagen. Wenn du die Funktion ausführst, erhältst du eine Liste der Kategorien für psychische Störungen, die auf den verschiedenen Stichproben in der Testgruppe basieren. 

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)

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

Anschließend erstellen wir die Funktion evaluate, die die vorhergesagten und wahren Bezeichnungen verwendet, um die Gesamtgenauigkeit des Modells und die Genauigkeit pro Kategorie zu berechnen, einen Klassifizierungsbericht zu erstellen und eine Konfusionsmatrix auszudrucken. Wenn du die Funktion ausführst, erhältst du eine detaillierte Zusammenfassung der Modellbewertung. 

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)

Llama 3.1 hat sich auch ohne Feinabstimmung hervorragend geschlagen. 79% Genauigkeit sind gut genug. Schauen wir uns an, wie sich unser Modell verbessert, wenn wir es mit dem Datensatz feinabstimmen.

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]]

5. Das Modell bauen

Bei der Erstellung des Modells beginnen wir damit, die Namen der linearen Module mit Hilfe der Bibliothek bits and bytes aus dem Modell zu extrahieren. 

Dann konfigurieren wir LoRA mit den Zielmodulen, dem Aufgabentyp und anderen Argumenten, bevor wir die Trainingsargumente festlegen. Diese Trainingsargumente sind für das Kaggle-Notebook optimiert. Möglicherweise musst du sie ändern, wenn du sie lokal verwendest. 

Anschließend erstellen wir den Modelltrainer mit Trainingsargumenten, einem Modell, einem Tokenizer, einer LoRA-Konfiguration und einem Datensatz. 

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

['down_proj', 'gate_proj', 'o_proj', 'v_proj', 'up_proj', 'q_proj', 'k_proj']

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

6. Model Ausbildung

Jetzt ist es an der Zeit, mit dem Modelltraining zu beginnen:

trainer.train()

Die Feinabstimmung des Modells hat 1,5 Stunden gedauert, und unser Validierungsverlust hat sich allmählich verringert. Um eine noch bessere Leistung zu erzielen, solltest du das Modell mindestens fünf Epochen lang mit dem gesamten Datensatz trainieren.

Als Nächstes beenden wir den Lauf mit den Gewichten und Verzerrungen.

wandb.finish()
model.config.use_cache = True

Wir können uns die Zusammenfassung des Laufs ansehen, einschließlich aller notwendigen Metriken für die Modellleistung.

Um eine detaillierte Zusammenfassung zu sehen, gehe zu deinem Konto bei Weights and Biases und schau dir den Lauf in deinem Browser an. Es enthält interaktive Visualisierungen.

Wir können dann sowohl den Model Adapter als auch den Tokenizer lokal speichern. Im nächsten Abschnitt werden wir dies nutzen, um den Adopter mit dem Basismodell zusammenzuführen.

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

7. Modell nach der Feinabstimmung testen

Jetzt kommt der wichtigste Teil. Wird unser Modell nach der Feinabstimmung besser abschneiden, oder wird es schlechter werden? Um das herauszufinden, müssen wir die Funktion "Vorhersage" auf die Testmenge anwenden und dann die Funktion "Auswerten", um einen Bericht zur Modellbewertung zu erstellen.

y_pred = predict(X_test, model, tokenizer)
evaluate(y_true, y_pred)

Wie du an den Ergebnissen unten sehen kannst, ist dies eine enorme Verbesserung der Modellleistung, von 79% auf 91,3% Genauigkeit. Sogar die F1-Ergebnisse sehen gut aus. 

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]]

Wir können jetzt das Kaggle-Notizbuch speichern, um die Ergebnisse und die Modelldateien zu speichern. Dazu klickst du oben rechts auf die Schaltfläche "Version speichern", wählst den Versionstyp "Schnellspeicherung" und wählst den Ausgabetyp "Ausgabe beim Erstellen einer Schnellspeicherung immer speichern".

Wenn du Probleme mit der Feinabstimmung des Modells hast, schaue bitte im Kaggle Notizbuch für weitere Hilfe.

Du kannst auch lernen, wie du die Llama 3.0 Modelle fein abstimmst, indem du unserem Leitfaden folgst, Feinabstimmung von Llama 3 und seine lokale Nutzung.

Zusammenführen und Speichern des feinabgestimmten Llama 3.1 Modells

In diesem Abschnitt werden wir den Adapter mit dem Basismodell zusammenführen und die Vollversion auf dem Hugging Face Hub speichern. 

Zuerst starten wir ein neues Kaggle-Notebook mit GPU-Beschleunigung und fügen das gespeicherte Notebook hinzu, um auf die Modelldateien zuzugreifen. Wir können auch andere Kaggle-Notizbücher als Eingabe einbeziehen, ähnlich wie beim Hinzufügen eines Datensatzes.

Dann können wir die notwendigen Python-Pakete installieren. 

%%capture
%pip install -U bitsandbytes
%pip install -U transformers
%pip install -U accelerate
%pip install -U peft

Als Nächstes melden wir uns mit dem API-Schlüssel bei der Hugging Face Hub API an, um unsere Modelldateien in das Hugging Face Modell-Repository zu übertragen. 

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)

Wir können dann das Verzeichnis des Basismodells und des Feinabstimmungsmodells einstellen.

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

Dann lädst du den Tokenizer und das Basismodell. 

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

Wir mischen das Basismodell mit dem Feinabstimmungsadapter, wie unten zu sehen ist. 

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

Bevor wir unser Modell speichern, lass uns überprüfen, ob es richtig funktioniert. Erstelle eine Textgenerierungspipeline mit dem Modell und dem Tokenizer und versehe sie mit dem Beispielprompt. 

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

Unser Modell funktioniert perfekt.

Depression

Jetzt können wir das Modell und den Tokenizer lokal speichern. 

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

Dann schickst du das Modell und den Tokenizer an den Hugging Face Hub.

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

Dadurch wird das Repository auf Hugging Face erstellt und alle Modell- und Tokenizer-Dateien werden übertragen.

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)

Wir können alle Modelldateien auf der Website von Hugging Face ansehen. 

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

Wenn du Probleme beim Zusammenführen des Adapters mit dem Basismodell hast, schaue bitte in das Kaggle-Notizbuch.

Wenn du die Feinabstimmung der LLMs als schwierig empfindest, kannst du dem Fine-Tuning OpenAI's GPT-4 folgen : Ein Schritt-für-Schritt-Leitfaden Tutorial, um eine einfachere Methode zu erlernen, die OpenAI API zu nutzen, um das Modell mit nur wenigen Zeilen Code auf jeden Datensatz abzustimmen.

Schlussgedanken

Die Feinabstimmung des Modells ist nicht auf die Anpassung an den Datensatz beschränkt. Wir können große Sprachmodelle für verschiedene natürlichsprachliche Aufgaben wie maschinelle Übersetzung, Clustering, Klassifizierung, Fragen und Antworten, Einbettung und mehr feinabstimmen. 

In diesem Tutorial haben wir gelernt, das Llama 3.1-Modell anhand eines Klassifizierungsdatensatzes für psychische Gesundheit zu optimieren. Dieses Modell kann genutzt werden, um Patienten und sogar Arbeitnehmer zu identifizieren, die in ihrem täglichen Leben vor Herausforderungen stehen.

Wenn du dich fragst, wie du mit LLMs einsteigen und selbst mit der Feinabstimmung von Modellen beginnen kannst, dann solltest du den Kurs Entwickeln großer Sprachmodelle Lernpfad. Mit dieser Kursreihe baust du ein starkes Fundament in LLMs auf, das dich in die neue KI-gestützte Landschaft katapultiert.