Der einzige Leitfaden, den Sie benötigen, um Llama 3 oder jedes andere Open-Source-Modell fein abzustimmen

Das Feinabstimmen großer Sprachmodelle (LLMs) wie Llama 3 beinhaltet die Anpassung eines vorgebildeten Modells an spezifische Aufgaben mithilfe eines domänen-spezifischen Datensatzes. Dieser Prozess nutzt die vorhandenen Kenntnisse des Modells, was es effizient und kostengünstig im Vergleich zum Training von Grund auf macht. In diesem Leitfaden werden wir die Schritte zum Feinabstimmen von Llama 3 mithilfe von QLoRA (Quantized LoRA) durchgehen, einer parameter-effizienten Methode, die den Speicherbedarf und die Rechenkosten minimiert.

Überblick über das Feinabstimmen

Das Feinabstimmen umfasst mehrere wichtige Schritte:

1. Auswahl eines vorgebildeten Modells: Wählen Sie ein Basis-Modell aus, das mit Ihrer gewünschten Architektur übereinstimmt.
2. Sammlung eines relevanten Datensatzes: Sammeln und verarbeiten Sie einen Datensatz, der spezifisch für Ihre Aufgabe ist.
3. Feinabstimmen: Passen Sie das Modell mithilfe des Datensatzes an, um seine Leistung auf spezifische Aufgaben zu verbessern.
4. Auswertung: Bewerten Sie das fein abgestimmte Modell mithilfe qualitativer und quantitativer Metriken.

Konzepte und Techniken

Feinabstimmen von großen Sprachmodellen

Vollständiges Feinabstimmen

Vollständiges Feinabstimmen aktualisiert alle Parameter des Modells, sodass es spezifisch für die neue Aufgabe wird. Diese Methode erfordert erhebliche Rechenressourcen und ist oft für sehr große Modelle nicht praktikabel.

Parameter-effizientes Feinabstimmen (PEFT)

PEFT aktualisiert nur einen Teil der Modellparameter, wodurch der Speicherbedarf und die Rechenkosten reduziert werden. Diese Technik verhindert katastrophales Vergessen und bewahrt die allgemeine Kenntnis des Modells.

Niedrigrangige Anpassung (LoRA) und Quantisierte LoRA (QLoRA)

LoRA feinabstimmt nur einige niedrigrangige Matrizen, während QLoRA diese Matrizen quantisiert, um den Speicherbedarf weiter zu reduzieren.

Feinabstimmungsmethoden

1. Vollständiges Feinabstimmen: Dies beinhaltet das Training aller Parameter des Modells auf dem Aufgaben-spezifischen Datensatz. Obwohl diese Methode sehr effektiv sein kann, ist sie auch rechenintensiv und erfordert erheblichen Speicher.
2. Parameter-effizientes Feinabstimmen (PEFT): PEFT aktualisiert nur einen Teil der Modellparameter, was es speicher-effizienter macht. Techniken wie Niedrigrangige Anpassung (LoRA) und Quantisierte LoRA (QLoRA) fallen in diese Kategorie.

Was ist LoRA?

Vergleich von Feinabstimmungsmethoden: QLORA verbessert LoRA mit 4-Bit-Präzisionsquantisierung und paged-Optimierern für Speicherspitzen-Management

LoRA ist eine verbesserte Feinabstimmungsmethode, bei der anstelle des Feinabstimmens aller Gewichte des vorgebildeten Modells zwei kleinere Matrizen feinabgestimmt werden, die die größere Matrix approximieren. Diese Matrizen bilden den LoRA-Adapter. Dieser feinabgestimmte Adapter wird dann in das vorgebildete Modell geladen und für die Inferenz verwendet.

Schlüsselvorteile von LoRA:

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

Was ist Quantisierte LoRA (QLoRA)?

QLoRA verbessert LoRA, indem die Gewichte der LoRA-Adapter auf niedrigere Präzision (z. B. 4-Bit anstelle von 8-Bit) quantisiert werden. Dies reduziert den Speicherbedarf und die Speicheranforderungen weiter, während ein vergleichbares Leistungsniveau beibehalten wird.

Schlüsselvorteile von QLoRA:

• Noch größere Speichereffizienz: Durch die Quantisierung der Gewichte reduziert QLoRA den Speicherbedarf und die Speicheranforderungen des Modells erheblich.
• Beibehaltung der Leistung: Trotz der reduzierten Präzision behält QLoRA ein Leistungsniveau, das nahe an dem von Modellen mit voller Präzision liegt.

Aufgaben-spezifische Anpassung

Während des Feinabstimmens werden die Modellparameter basierend auf dem neuen Datensatz angepasst, was es dem Modell ermöglicht, besser zu verstehen und Inhalte zu generieren, die für die spezifische Aufgabe relevant sind. Dieser Prozess bewahrt die allgemeine Sprachkenntnis, die während des Vorbildens erworben wurde, und passt das Modell an die Nuancen der Ziel-Domäne an.

Feinabstimmen in der Praxis

Vollständiges Feinabstimmen vs. PEFT

• Vollständiges Feinabstimmen: Beinhaltet das Training des gesamten Modells, was rechenintensiv und speicherintensiv ist.
• PEFT (LoRA und QLoRA): Feinabstimmt nur einen Teil der Parameter, was den Speicherbedarf reduziert und katastrophales Vergessen verhindert, was es zu einer effizienteren Alternative macht.

Implementierungsschritte

1. Umgebung einrichten: Installieren Sie die erforderlichen Bibliotheken und richten Sie die Rechenumgebung ein.
2. Datensatz laden und vorverarbeiten: Laden Sie den Datensatz und verarbeiten Sie ihn in ein Format, das für das Modell geeignet ist.
3. Vorgebildetes Modell laden: Laden Sie das Basis-Modell mit Quantisierungs-Konfigurationen, wenn Sie QLoRA verwenden.
4. Tokenisierung: Tokenisieren Sie den Datensatz, um ihn für das Training vorzubereiten.
5. Training: Feinabstimmen Sie das Modell mithilfe des vorbereiteten Datensatzes.
6. Auswertung: Bewerten Sie die Leistung des Modells auf spezifischen Aufgaben mithilfe qualitativer und quantitativer Metriken.

Schritt-für-Schritt-Anleitung zum Feinabstimmen von LLM

Umgebung einrichten

Wir verwenden ein Jupyter-Notebook für dieses Tutorial. Plattformen wie Kaggle, die kostenlose GPU-Nutzung anbieten, oder Google Colab sind ideal für das Ausführen dieser Experimente.

1. Erforderliche Bibliotheken installieren

Stellen Sie sicher, dass Sie die erforderlichen Bibliotheken installiert haben:

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

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

# Deaktivieren Sie Weights and Biases-Protokollierung
os.environ['WANDB_DISABLED'] = "true"
interpreter_login()

3. Datensatz laden

Wir verwenden den DialogSum-Datensatz für dieses Tutorial:

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

4. BitsAndBytes-Konfiguration erstellen

Um das Modell im 4-Bit-Format zu laden:

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. Vorgebildetes Modell laden

Wir verwenden Microsofts Phi-2-Modell für dieses Tutorial:

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

Feinabstimmen von Llama 3 oder anderen Modellen

Wenn Sie Modelle wie Llama 3 oder andere State-of-the-Art-Open-Source-LLMs feinabstimmen, gibt es bestimmte Überlegungen und Anpassungen, die erforderlich sind, um optimale Leistung zu erzielen. Hier sind die detaillierten Schritte und Erkenntnisse, wie Sie dies für verschiedene Modelle, einschließlich Llama 3, GPT-3 und Mistral, angehen können.

5.1 Verwendung von Llama 3

Modellauswahl:

• Stellen Sie sicher, dass Sie den richtigen Modell-Identifikator aus dem Hugging-Face-Modell-Hub haben. Zum Beispiel kann das Llama-3-Modell als meta-llama/Meta-Llama-3-8B auf Hugging Face identifiziert werden.
• Stellen Sie sicher, dass Sie Zugriff anfordern und sich in Ihrem Hugging-Face-Konto anmelden, wenn dies für Modelle wie Llama 3 erforderlich ist.

Tokenisierung:

• Verwenden Sie den geeigneten Tokenizer für Llama 3, der mit dem Modell und den erforderlichen Funktionen wie Padding und Spezialtoken kompatibel ist.

Speicher und Rechenleistung:

• Das Feinabstimmen großer Modelle wie Llama 3 erfordert erhebliche Rechenressourcen. Stellen Sie sicher, dass Ihre Umgebung, wie eine leistungsstarke GPU-Konfiguration, den Speicher- und Rechenanforderungen gerecht wird.

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

Modellauswahl:

• Stellen Sie sicher, dass Sie den richtigen Modell-Namen und -Identifikator aus dem Hugging-Face-Modell-Hub oder anderen Quellen verwenden.

Tokenisierung:

• Ähnlich wie bei Llama 3 stellen Sie sicher, dass der Tokenizer richtig konfiguriert und mit dem Modell kompatibel ist.

Speicher und Rechenleistung:

• Jedes Modell kann unterschiedliche Speicheranforderungen haben. Passen Sie Ihre Umgebungs-Einrichtung entsprechend an.

7. Testen des Modells mit Zero-Shot-Inferenz

Bewerten Sie das Basis-Modell mit einer Beispiel-Eingabe:

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"

# Generieren Sie die Ausgabe
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. Vorverarbeiten des Datensatzes

Konvertieren Sie Dialog-Zusammenfassungs-Paare in Prompts:

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)

Hyperparameter und ihre Auswirkungen

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

1. Lernrate: Kontrolliert die Geschwindigkeit, mit der das Modell seine Parameter aktualisiert. Eine hohe Lernrate kann zu schneller Konvergenz führen, aber auch zu Überanpassung führen. Eine niedrige Lernrate gewährleistet eine stabile Konvergenz, erfordert aber möglicherweise mehr Epochen.
2. Batch-Größe: Die Anzahl der Samples, die vor dem Aktualisieren der Modellparameter verarbeitet werden. Größere Batch-Größen können die Stabilität verbessern, erfordern aber mehr Speicher. Kleinere Batch-Größen können zu mehr Rauschen im Trainingsprozess führen.
3. Schritte der Gradienten-Akkumulation: Dieser Parameter hilft bei der Simulation größerer Batch-Größen, indem die Gradienten über mehrere Schritte akkumuliert werden, bevor eine Parameter-Aktualisierung durchgeführt wird.
4. Anzahl der Epochen: Die Anzahl der Male, die der gesamte Datensatz durch das Modell verarbeitet wird. Mehr Epochen können die Leistung verbessern, können aber auch zu Überanpassung führen, wenn sie nicht richtig gehandhabt werden.
5. Gewichts-Abfall: Regularisierungstechnik, um Überanpassung zu verhindern, indem große Gewichte bestraft werden.
6. Lernrate-Planer: Passt die Lernrate während des Trainings an, um die Leistung und Konvergenz zu verbessern.

Beispiel-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 des Modells

Richten Sie den Trainer ein und starten Sie das Training:

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

Auswerten des fein abgestimmten Modells

Nach dem Training bewerten Sie die Leistung des Modells mithilfe qualitativer und quantitativer Methoden.

1. Menschliche Auswertung

Vergleichen Sie die generierten Zusammenfassungen mit von Menschen erstellten, um die Qualität zu bewerten.

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)

Häufige Herausforderungen und Lösungen

1. Speicher-Beschränkungen

Die Verwendung von QLoRA hilft, Speicher-Probleme zu mildern, indem Modell-Gewichte auf 4-Bit quantisiert werden. Stellen Sie sicher, dass Sie genügend GPU-Speicher haben, um Ihre Batch-Größe und Modell-Größe zu verarbeiten.

2. Überanpassung

Überwachen Sie die Validierungs-Metriken, um Überanpassung zu verhindern. Verwenden Sie Techniken wie frühzeitiges Stoppen und Gewichts-Abfall.

3. Langsames Training

Optimieren Sie die Trainings-Geschwindigkeit, indem Sie die Batch-Größe, Lernrate und Gradienten-Akkumulation anpassen.

4. Daten-Qualität

Stellen Sie sicher, dass Ihr Datensatz sauber und gut vorverarbeitet ist. Eine schlechte Daten-Qualität kann die Modell-Leistung erheblich beeinträchtigen.

Schlussfolgerung

Das Feinabstimmen von LLMs mithilfe von QLoRA ist eine effiziente Methode, um große vorgebildete Modelle auf spezifische Aufgaben mit reduzierten Rechenkosten anzupassen. Indem Sie diesem Leitfaden folgen, können Sie PHI, Llama 3 oder jedes andere Open-Source-Modell fein abstimmen, um hohe Leistung auf Ihren spezifischen Aufgaben zu erzielen.