Der einzige Leitfaden, den Sie zur Feinabstimmung von Llama 3 oder jedem anderen Open-Source-Modell benötigen

Die Feinabstimmung großer Sprachmodelle (LLMs) wie Llama 3 umfasst die Anpassung eines vortrainierten Modells an spezifische Aufgaben mithilfe eines domänenspezifischen Datensatzes. Dieser Prozess nutzt das vorhandene Wissen des Modells und ist dadurch im Vergleich zum Training von Grund auf effizient und kostengünstig. In dieser Anleitung führen wir Sie durch die Schritte zur Feinabstimmung von Llama 3 mit QLoRA (Quantized LoRA), einer parametereffizienten Methode, die Speichernutzung und Rechenkosten minimiert.

Übersicht zur Feinabstimmung

Die Feinabstimmung umfasst mehrere wichtige Schritte:

1. Auswählen eines vorab trainierten Modells: Wählen Sie ein Basismodell, das zu Ihrer gewünschten Architektur passt.
2. Einen relevanten Datensatz sammeln: Sammeln und verarbeiten Sie einen Datensatz speziell für Ihre Aufgabe vor.
3. Feintuning: Passen Sie das Modell mithilfe des Datensatzes an, um seine Leistung bei bestimmten Aufgaben zu verbessern.
4. Evaluierung: Bewerten Sie das fein abgestimmte Modell anhand qualitativer und quantitativer Kennzahlen.

Konzepte und Techniken

Feinabstimmung großer Sprachmodelle

Vollständige Feinabstimmung

Vollständige Feinabstimmung aktualisiert alle Parameter des Modells und macht es so spezifisch für die neue Aufgabe. Diese Methode erfordert erhebliche Rechenressourcen und ist bei sehr großen Modellen oft unpraktisch.

Parametereffiziente Feinabstimmung (PEFT)

PEFT aktualisiert nur eine Teilmenge der Modellparameter und reduziert dadurch Speicherbedarf und Rechenaufwand. Diese Technik verhindert katastrophales Vergessen und bewahrt das allgemeine Wissen über das Modell.

Low-Rank Adaptation (LoRA) und Quantized LoRA (QLoRA)

LoRA optimiert nur einige Matrizen mit niedrigem Rang, während QLoRA diese Matrizen quantisiert, um den Speicherbedarf weiter zu reduzieren.

Feinabstimmungsmethoden

1. Vollständige Feinabstimmung: Dabei werden alle Parameter des Modells anhand des aufgabenspezifischen Datensatzes trainiert. Diese Methode kann zwar sehr effektiv sein, ist aber auch rechenintensiv und erfordert viel Speicher.
2. Parametereffiziente Feinabstimmung (PEFT): PEFT aktualisiert nur eine Teilmenge der Modellparameter und ist dadurch speichereffizienter. Techniken wie Low-Rank Adaptation (LoRA) und Quantized LoRA (QLoRA) fallen in diese Kategorie.

Was ist LoRA?

Vergleich von Feinabstimmungsmethoden: QLORA erweitert LoRA mit 4-Bit-Präzisionsquantisierung und ausgelagerten Optimierern für die Verwaltung von Speicherspitzen

LoRA ist eine verbesserte Feinabstimmungsmethode, bei der nicht alle Gewichte des vorab trainierten Modells feinabgestimmt werden, sondern zwei kleinere Matrizen, die die größere Matrix approximieren. Diese Matrizen bilden den LoRA-Adapter. Dieser feinabgestimmte Adapter wird dann in das vorab trainierte Modell geladen und zur Inferenz verwendet.

Hauptvorteile von LoRA:

• Speichereffizienz: LoRA reduziert den Speicherbedarf, indem nur kleine Matrizen statt des gesamten Modells feinabgestimmt werden.
• Wiederverwendbarkeit: Das ursprüngliche Modell bleibt unverändert und es können mehrere LoRA-Adapter damit verwendet werden, was die Handhabung mehrerer Aufgaben mit geringerem Speicherbedarf erleichtert.

Was ist Quantized LoRA (QLoRA)?

QLoRA geht einen Schritt weiter als LoRA, indem es die Gewichte der LoRA-Adapter auf eine geringere Genauigkeit quantisiert (z. B. 4 Bit statt 8 Bit). Dies reduziert den Speicherverbrauch und die Speicheranforderungen weiter, während ein vergleichbares Maß an Effektivität erhalten bleibt.

Hauptvorteile von QLoRA:

• Noch höhere Speichereffizienz: Durch die Quantisierung der Gewichte reduziert QLoRA den Speicher- und Speicherplatzbedarf des Modells erheblich.
• Behält die Leistung bei: Trotz der reduzierten Präzision hält QLoRA ein Leistungsniveau aufrecht, das dem von Modellen mit voller Präzision nahe kommt.

Aufgabenspezifische Anpassung

Beim Feintuning werden die Parameter des Modells auf Grundlage des neuen Datensatzes angepasst, damit es die jeweilige Aufgabe besser versteht und relevante Inhalte generiert. Bei diesem Prozess bleiben die während des Vortrainings erworbenen allgemeinen Sprachkenntnisse erhalten, während das Modell an die Nuancen der Zieldomäne angepasst wird.

Feinabstimmung in der Praxis

Vollständige Feinabstimmung vs. PEFT

• Vollständige Feinabstimmung: Umfasst das Trainieren des gesamten Modells, was rechenintensiv sein kann und viel Speicher erfordert.
• PEFT (LoRA und QLoRA): Optimiert nur eine Teilmenge der Parameter, reduziert den Speicherbedarf und verhindert katastrophales Vergessen, was es zu einer effizienteren Alternative macht.

Implementierungsschritte

1. Einrichtungsumgebung: Installieren Sie die erforderlichen Bibliotheken und richten Sie die Computerumgebung ein.
2. Dataset laden und vorverarbeiten: Laden Sie den Datensatz und verarbeiten Sie ihn vorab in ein für das Modell geeignetes Format.
3. Vorab trainiertes Modell laden: Laden Sie das Basismodell mit Quantisierungskonfigurationen, wenn Sie QLoRA verwenden.
4. Tokenisierung: Tokenisieren Sie den Datensatz, um ihn für das Training vorzubereiten.
5. Training: Optimieren Sie das Modell mithilfe des vorbereiteten Datensatzes.
6. Evaluierung: Bewerten Sie die Leistung des Modells bei bestimmten Aufgaben anhand qualitativer und quantitativer Kennzahlen.

Schritt-für-Schritt-Anleitung zur Feinabstimmung von LLM

Einrichten der Umgebung

Für dieses Tutorial verwenden wir ein Jupyter-Notebook. Plattformen wie Kaggle, die kostenlose GPU-Nutzung bieten, oder Google Colab eignen sich ideal für die Durchführung dieser Experimente.

1. Erforderliche Bibliotheken installieren

Stellen Sie zunächst sicher, dass Sie die erforderlichen Bibliotheken installiert haben:

!pip install -qqq -U bitsandbytes transformers peft accelerate datasets scipy einops evaluate trl rouge_score</div>

2. Bibliotheken importieren und Umgebung einrichten

import os
import torch
from datasets import load_dataset
from transformers import (
    AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, TrainingArguments, 
    pipeline, HfArgumentParser
)
from trl import ORPOConfig, ORPOTrainer, setup_chat_format, SFTTrainer
from tqdm import tqdm
import gc
import pandas as pd
import numpy as np
from huggingface_hub import interpreter_login

# Disable Weights and Biases logging
os.environ['WANDB_DISABLED'] = "true"
interpreter_login()

3. Laden Sie den Datensatz

Für dieses Tutorial verwenden wir den DialogSum-Datensatz:

Verarbeiten Sie den Datensatz entsprechend den Anforderungen des Modells vor. Wenden Sie dazu geeignete Vorlagen an und stellen Sie sicher, dass das Datenformat für die Feinabstimmung geeignet ist. (Gesicht umarmen)â € <â € < (DataCamp).

dataset_name = "neil-code/dialogsum-test"
dataset = load_dataset(dataset_name)

Überprüfen Sie die Datensatzstruktur:

print(dataset['test'][0])

4. BitsAndBytes-Konfiguration erstellen

So laden Sie das Modell im 4-Bit-Format:

compute_dtype = getattr(torch, "float16")
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type='nf4',
    bnb_4bit_compute_dtype=compute_dtype,
    bnb_4bit_use_double_quant=False,
)

5. Laden Sie das vortrainierte Modell

Für dieses Tutorial wird das Phi-2-Modell von Microsoft verwendet:

model_name = 'microsoft/phi-2'
device_map = {"": 0}
original_model = AutoModelForCausalLM.from_pretrained(
    model_name, 
    device_map=device_map,
    quantization_config=bnb_config,
    trust_remote_code=True,
    use_auth_token=True
)

6. Tokenisierung

Konfigurieren Sie den Tokenizer:

tokenizer = AutoTokenizer.from_pretrained(
    model_name, 
    trust_remote_code=True, 
    padding_side="left", 
    add_eos_token=True, 
    add_bos_token=True, 
    use_fast=False
)
tokenizer.pad_token = tokenizer.eos_token

Feinabstimmung von Llama 3 oder anderen Modellen

Beim Feintuning von Modellen wie Llama 3 oder anderen modernen Open-Source-LLMs sind bestimmte Überlegungen und Anpassungen erforderlich, um eine optimale Leistung sicherzustellen. Hier finden Sie die detaillierten Schritte und Einblicke, wie Sie dies für verschiedene Modelle, einschließlich Llama 3, GPT-3 und Mistral, angehen können.

5.1 Verwenden von Llama 3

Modellauswahl:

• Stellen Sie sicher, dass Sie die richtige Modellkennung vom Hugging Face-Modell-Hub haben. Beispielsweise könnte das Modell Llama 3 als meta-llama/Meta-Llama-3-8B auf Hugging Face.
• Stellen Sie sicher, dass Sie Zugriff anfordern und sich bei Ihrem Hugging Face-Konto anmelden, falls dies für Modelle wie Llama 3 erforderlich ist. (Gesicht umarmen)â € <â € <

Tokenisierung:

• Verwenden Sie den entsprechenden Tokenizer für Llama 3. Stellen Sie sicher, dass er mit dem Modell kompatibel ist und erforderliche Funktionen wie Auffüllung und spezielle Token unterstützt.

Speicher und Berechnung:

• Die Feinabstimmung großer Modelle wie Llama 3 erfordert erhebliche Rechenressourcen. Stellen Sie sicher, dass Ihre Umgebung, z. B. ein leistungsstarkes GPU-Setup, die Speicher- und Verarbeitungsanforderungen bewältigen kann. Stellen Sie sicher, dass die Umgebung die Speicheranforderungen bewältigen kann. Diese können durch den Einsatz von Techniken wie QLoRA gemindert werden, um den Speicherbedarf zu reduzieren. (Umarmungsgesichtsforen)

Ejemplo:

model_name = 'meta-llama/Meta-Llama-3-8B'
device_map = {"": 0}
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_use_double_quant=True,
)
original_model = AutoModelForCausalLM.from_pretrained(
    model_name, 
    device_map=device_map,
    quantization_config=bnb_config,
    trust_remote_code=True,
    use_auth_token=True
)

Tokenisierung:

Stellen Sie je nach Anwendungsfall und Modellanforderungen eine korrekte Tokenizer-Konfiguration ohne redundante Einstellungen sicher. Beispiel: use_fast=True wird für eine bessere Leistung empfohlen​ (Gesicht umarmen)â € <â € < (Gewichte & Vorurteile).

tokenizer = AutoTokenizer.from_pretrained(
    model_name, 
    trust_remote_code=True, 
    padding_side="left", 
    add_eos_token=True, 
    add_bos_token=True, 
    use_fast=False
)
tokenizer.pad_token = tokenizer.eos_token

5.2 Verwendung anderer beliebter Modelle (z. B. GPT-3, Mistral)

Modellauswahl:

• Stellen Sie bei Modellen wie GPT-3 und Mistral sicher, dass Sie den richtigen Modellnamen und die richtige Kennung aus dem Hugging Face-Modell-Hub oder anderen Quellen verwenden.

Tokenisierung:

• Stellen Sie ähnlich wie bei Llama 3 sicher, dass der Tokenizer richtig eingerichtet und mit dem Modell kompatibel ist.

Speicher und Berechnung:

• Die Speicheranforderungen der einzelnen Modelle können unterschiedlich sein. Passen Sie Ihre Umgebungskonfiguration entsprechend an.

Beispiel für GPT-3:

model_name = 'openai/gpt-3'
device_map = {"": 0}
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_use_double_quant=True,
)
original_model = AutoModelForCausalLM.from_pretrained(
    model_name, 
    device_map=device_map,
    quantization_config=bnb_config,
    trust_remote_code=True,
    use_auth_token=True
)

Beispiel für Mistral:

model_name = 'mistral-7B'
device_map = {"": 0}
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_use_double_quant=True,
)
original_model = AutoModelForCausalLM.from_pretrained(
    model_name, 
    device_map=device_map,
    quantization_config=bnb_config,
    trust_remote_code=True,
    use_auth_token=True
)

Überlegungen zur Tokenisierung: Jedes Modell kann einzigartige Tokenisierungsanforderungen haben. Stellen Sie sicher, dass der Tokenizer zum Modell passt und richtig konfiguriert ist.

Beispiel für einen Llama 3-Tokenizer:

tokenizer = AutoTokenizer.from_pretrained(
    model_name, 
    trust_remote_code=True, 
    padding_side="left", 
    add_eos_token=True, 
    add_bos_token=True, 
    use_fast=False
)
tokenizer.pad_token = tokenizer.eos_token

Beispiel für GPT-3 und Mistral Tokenizer:

tokenizer = AutoTokenizer.from_pretrained(
    model_name, 
    use_fast=True
)

7. Testen Sie das Modell mit Zero-Shot-Inferencing

Bewerten Sie das Basismodell mit einer Beispieleingabe:

from transformers import set_seed

set_seed(42)
index = 10
prompt = dataset['test'][index]['dialogue']
formatted_prompt = f"Instruct: Summarize the following conversation.\n{prompt}\nOutput:\n"

# Generate output
def gen(model, prompt, max_length):
    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
    outputs = model.generate(**inputs, max_length=max_length)
    return tokenizer.batch_decode(outputs, skip_special_tokens=True)

res = gen(original_model, formatted_prompt, 100)
output = res[0].split('Output:\n')[1]

print(f'INPUT PROMPT:\n{formatted_prompt}')
print(f'MODEL GENERATION - ZERO SHOT:\n{output}')

8. Den Datensatz vorverarbeiten

Wandeln Sie Dialog-Zusammenfassungs-Paare in Eingabeaufforderungen um:

def create_prompt_formats(sample):
    blurb = "Below is an instruction that describes a task. Write a response that appropriately completes the request."
    instruction = "### Instruct: Summarize the below conversation."
    input_context = sample['dialogue']
    response = f"### Output:\n{sample['summary']}"
    end = "### End"
    
    parts = [blurb, instruction, input_context, response, end]
    formatted_prompt = "\n\n".join(parts)
    sample["text"] = formatted_prompt
    return sample

dataset = dataset.map(create_prompt_formats)

Tokenisieren Sie den formatierten Datensatz:

def preprocess_batch(batch, tokenizer, max_length):
    return tokenizer(batch["text"], max_length=max_length, truncation=True)

max_length = 1024
train_dataset = dataset["train"].map(lambda batch: preprocess_batch(batch, tokenizer, max_length), batched=True)
eval_dataset = dataset["validation"].map(lambda batch: preprocess_batch(batch, tokenizer, max_length), batched=True)

Bereiten Sie das Modell für eine parametereffiziente Feinabstimmung vor:

original_model = prepare_model_for_kbit_training(original_model)

Hyperparameter spielen eine entscheidende Rolle bei der Optimierung der Leistung Ihres Modells. Hier sind einige wichtige Hyperparameter, die Sie berücksichtigen sollten:

1. Lernrate: Steuert die Geschwindigkeit, mit der das Modell seine Parameter aktualisiert. Eine hohe Lernrate kann zu einer schnelleren Konvergenz führen, kann aber die optimale Lösung verfehlen. Eine niedrige Lernrate stellt eine stetige Konvergenz sicher, kann aber mehr Epochen erfordern.
2. Batch-Größe: Die Anzahl der verarbeiteten Beispiele, bevor das Modell seine Parameter aktualisiert. Größere Batchgrößen können die Stabilität verbessern, erfordern aber mehr Speicher. Kleinere Batchgrößen können zu mehr Rauschen im Trainingsprozess führen.
3. Schritte zur Gradientenakkumulation: Dieser Parameter hilft bei der Simulation größerer Batchgrößen, indem Gradienten über mehrere Schritte hinweg akkumuliert werden, bevor eine Parameteraktualisierung durchgeführt wird.
4. Anzahl der Epochen: Die Häufigkeit, mit der der gesamte Datensatz durch das Modell geleitet wird. Mehr Epochen können die Leistung verbessern, können aber zu Überanpassung führen, wenn sie nicht richtig verwaltet werden.
5. Gewichtsverlust: Regularisierungstechnik zur Vermeidung von Überanpassung durch Bestrafung großer Gewichte.
6. Lernratenplaner: Passt die Lernrate während des Trainings an, um Leistung und Konvergenz zu verbessern.

Passen Sie die Trainingskonfiguration an, indem Sie Hyperparameter wie Lernrate, Batchgröße und Gradientenakkumulationsschritte basierend auf den spezifischen Modell- und Aufgabenanforderungen anpassen. Beispielsweise können Llama 3-Modelle andere Lernraten erfordern als kleinere Modelle. (Gewichte & Vorurteile)â € <â € < (GitHub)​

Beispiel einer Trainingskonfiguration

orpo_args = ORPOConfig(
learning_rate=8e-6,
lr_scheduler_type="linear",max_length=1024,max_prompt_length=512,
beta=0.1,per_device_train_batch_size=2,per_device_eval_batch_size=2,
gradient_accumulation_steps=4,optim="paged_adamw_8bit",num_train_epochs=1,
evaluation_strategy="steps",eval_steps=0.2,logging_steps=1,warmup_steps=10,
report_to="wandb",output_dir="./results/",)

10. Trainieren Sie das Modell

Trainer einrichten und mit dem Training beginnen:

trainer = ORPOTrainer(
model=original_model,
args=orpo_args,
train_dataset=train_dataset,
eval_dataset=eval_dataset,
tokenizer=tokenizer,)
trainer.train()
trainer.save_model("fine-tuned-llama-3")

Auswertung des fein abgestimmten Modells

Bewerten Sie nach dem Training die Leistung des Modells mithilfe qualitativer und quantitativer Methoden.

1. Menschliche Bewertung

Vergleichen Sie die generierten Zusammenfassungen mit den von Menschen verfassten, um die Qualität zu beurteilen.

2. Quantitative Auswertung

Verwenden Sie Metriken wie ROUGE, um die Leistung zu bewerten:

from rouge_score import rouge_scorer

scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)
scores = scorer.score(reference_summary, generated_summary)
print(scores)

Herausforderungen und Lösungen

1. Speicherbeschränkungen

Durch die Verwendung von QLoRA können Speicherprobleme durch die Quantisierung der Modellgewichte auf 4 Bit verringert werden. Stellen Sie sicher, dass Sie über genügend GPU-Speicher verfügen, um Ihre Batch- und Modellgröße zu verarbeiten.

2. Überanpassung

Überwachen Sie die Validierungsmetriken, um Überanpassung zu vermeiden. Verwenden Sie Techniken wie frühzeitiges Stoppen und Gewichtsabnahme.

3. Langsames Training

Optimieren Sie die Trainingsgeschwindigkeit, indem Sie die Batchgröße und Lernrate anpassen und die Gradientenakkumulation verwenden.

4. Datenqualität

Stellen Sie sicher, dass Ihr Datensatz sauber und gut vorverarbeitet ist. Eine schlechte Datenqualität kann die Modellleistung erheblich beeinträchtigen.

Fazit

Die Feinabstimmung von LLMs mit QLoRA ist eine effiziente Möglichkeit, große vorab trainierte Modelle mit reduziertem Rechenaufwand an bestimmte Aufgaben anzupassen. Wenn Sie dieser Anleitung folgen, können Sie PHI, Llama 3 oder jedes andere Open-Source-Modell feinabstimmen, um bei Ihren spezifischen Aufgaben eine hohe Leistung zu erzielen.