Artificial Intelligence (AI)

7 Steps to Mastering Large Language Model Fine-tuning

Written by smirow

7 Schritte zur Beherrschung des Aufbaus eines großen Sprachmodells7 Schritte zur Beherrschung des Aufbaus eines großen Sprachmodells
Bild vom Autor

In den letzten anderthalb Jahren hat die Landschaft der Verarbeitung natürlicher Sprache (NLP) eine bemerkenswerte Entwicklung erlebt, die vor allem durch den Aufstieg großer Sprachmodelle (LLMs) wie der GPT-Familie von OpenAI vorangetrieben wurde.

Diese leistungsstarken Modelle haben unseren Ansatz zur Aufgabenverwaltung in natürlicher Sprache revolutioniert und bieten beispiellose Möglichkeiten für die Übersetzung, Stimmungsanalyse und automatisierte Textgenerierung. Ihre Fähigkeit, menschenähnliche Texte zu verstehen und zu erstellen, hat Möglichkeiten eröffnet, die einst für unzugänglich galten.

Doch trotz ihrer beeindruckenden Fähigkeiten ist die Ausbildung dieser Modelle mit Fallstricken behaftet, wie zum Beispiel dem erheblichen Zeit- und Finanzaufwand.

Dies bringt uns zur wesentlichen Rolle der LLM-Entwicklung.

Durch die Feinabstimmung dieser vorab trainierten Modelle, um sie besser an bestimmte Anwendungen oder Domänen anzupassen, können wir ihre Leistung bei bestimmten Aufgaben erheblich verbessern. Dieser Schritt verbessert nicht nur ihre Qualität, sondern erweitert auch ihren Nutzen auf eine Vielzahl von Branchen.

Ziel dieses Leitfadens ist es, diesen Prozess in sieben einfache Schritte zu unterteilen, um jedes LLM für eine bestimmte Aufgabe zu optimieren.

LLMs sind eine spezielle Kategorie von ML-Algorithmen, die darauf ausgelegt sind, das nächste Wort in einer Sequenz basierend auf dem Kontext vorherzusagen, der durch vorherige Wörter bereitgestellt wird. Diese Modelle basieren auf der Transformers-Architektur, einem Durchbruch in den Techniken des maschinellen Lernens, und wurden erstmals in Googles Artikel „Alles, was Sie brauchen, ist Aufmerksamkeit“ erläutert.

Modelle wie GPT (Generative Pre-trained Transformer) sind Beispiele für vortrainierte Sprachmodelle, die großen Textdatenmengen ausgesetzt wurden. Durch diese vertiefte Ausbildung lernen sie die grundlegenden Regeln des Sprachgebrauchs zu verstehen, einschließlich der Art und Weise, wie Wörter zu zusammenhängenden Sätzen kombiniert werden.

7 Schritte zur Beherrschung des Aufbaus eines großen Sprachmodells7 Schritte zur Beherrschung des Aufbaus eines großen Sprachmodells
Bild vom Autor

Eine der Hauptstärken dieser Modelle ist ihre Fähigkeit, nicht nur natürliche Sprache zu verstehen, sondern auf der Grundlage der ihnen bereitgestellten Eingaben auch Texte zu erstellen, die der menschlichen Schrift sehr nahe kommen.

Was ist also das Beste?

Dank APIs sind diese Modelle bereits für die breite Öffentlichkeit zugänglich.

Was ist Feinabstimmung und warum ist sie wichtig?

Bei der Feinabstimmung wird ein vorab trainiertes Modell ausgewählt und durch zusätzliches Training an einem domänenspezifischen Datensatz verbessert.

Die meisten LLM-Modelle verfügen über sehr gute natürliche Sprachkenntnisse und allgemeines Wissen, versagen jedoch bei spezifischen aufgabenorientierten Problemen. Der Feinabstimmungsprozess bietet einen Ansatz zur Verbesserung der Modellleistung für bestimmte Probleme und reduziert gleichzeitig den Rechenaufwand, ohne dass sie von Grund auf neu erstellt werden müssen.

7 Schritte zur Beherrschung des Aufbaus eines großen Sprachmodells7 Schritte zur Beherrschung des Aufbaus eines großen Sprachmodells
Bild vom Autor

Einfach ausgedrückt: Durch die Feinabstimmung wird das Modell angepasst, um eine bessere Leistung für bestimmte Aufgaben zu erzielen, wodurch es in realen Anwendungen effizienter und vielseitiger wird. Dieser Prozess ist für die Verbesserung eines vorhandenen Modells für eine bestimmte Aufgabe oder Domäne von entscheidender Bedeutung.

Lassen Sie uns dieses Konzept veranschaulichen, indem wir ein reales Modell in nur 7 Schritten verfeinern.

Schritt 1: Machen Sie sich unser konkretes Ziel klar

Stellen Sie sich vor, wir möchten die Stimmung eines Textes ableiten und beschließen, GPT-2 für eine solche Aufgabe auszuprobieren.

Ich bin mir ziemlich sicher, dass es keine Überraschung ist, dass wir ziemlich früh erkennen, dass er darin ziemlich schlecht ist. Dann kommt mir natürlich die Frage in den Sinn:

Können wir etwas tun, um die Leistung zu verbessern?

Und natürlich ist die Antwort: Wir können es!

Profitieren Sie von der Feinabstimmung, indem Sie unser vorab trainiertes GPT-2-Modell vom Hugging Face Hub mit einem Datensatz trainieren, der Tweets und die entsprechenden Stimmungen enthält, sodass sich die Leistung verbessert.

Unser oberstes Ziel ist daher über ein Modell verfügen, das aus Texten Stimmungen ableiten kann.

Schritt 2: Wählen Sie ein vorab trainiertes Modell und einen Datensatz

Der zweite Schritt besteht darin, auszuwählen, welches Modell als Basismodell verwendet werden soll. In unserem Fall haben wir uns bereits für das Modell GPT-2 entschieden. Deshalb werden wir einige einfache Anpassungen vornehmen.

7 Schritte zur Beherrschung des Aufbaus eines großen Sprachmodells7 Schritte zur Beherrschung des Aufbaus eines großen Sprachmodells
Screenshot vom Hugging Face-Datensatz-Hub. Auswahl des OpenAI GPT2-Modells.

Denken Sie immer daran, ein Modell auszuwählen, das zu Ihrer Aufgabe passt.

Schritt 3: Laden Sie die zu verwendenden Daten

Da wir nun sowohl unser Modell als auch unsere Hauptaufgabe haben, benötigen wir Daten, mit denen wir arbeiten können.

Aber keine Sorge, Hugging Face ist für Sie da!

Hier kommt ihre Datensatzbibliothek ins Spiel.

In diesem Beispiel nutzen wir die Datensatzbibliothek „Hugging Face“, um einen Datensatz mit Tweets zu importieren, die mit der entsprechenden Stimmung (positiv, neutral oder negativ) gekennzeichnet sind.

from datasets import load_dataset

dataset = load_dataset("mteb/tweet_sentiment_extraction")
df = pd.DataFrame(dataset['train'])

Die Daten sehen so aus:

7 Schritte zur Beherrschung des Aufbaus eines großen Sprachmodells7 Schritte zur Beherrschung des Aufbaus eines großen Sprachmodells
Der zu verwendende Datensatz.

Schritt 4: Tokenizer

Wir haben jetzt sowohl unser Modell als auch den Datensatz, um es zu verfeinern. Der nächste natürliche Schritt besteht also darin, einen Tokenizer zu laden. Da LLMs mit Tokens (nicht Wörtern!) arbeiten, benötigen wir einen Tokenizer, um die Daten an unser Modell zu senden.

Dies können wir leicht erreichen, indem wir die Kartenmethode zur Tokenisierung des Datensatzes nutzen.

from transformers import GPT2Tokenizer

# Loading the dataset to train our model
dataset = load_dataset("mteb/tweet_sentiment_extraction")
tokenizer = GPT2Tokenizer.from_pretrained("gpt2")
tokenizer.pad_token = tokenizer.eos_token

def tokenize_function(examples):
   return tokenizer(examples["text"], padding="max_length", truncation=True)

tokenized_datasets = dataset.map(tokenize_function, batched=True)

PRIME: Um unsere Verarbeitungsleistung zu verbessern, werden zwei kleinere Teilmengen generiert:

  • Das Trainingsset: Um unser Modell zu verfeinern.
  • Das Testset: Um es zu bewerten.
small_train_dataset = tokenized_datasets["train"].shuffle(seed=42).select(range(1000))
small_eval_dataset = tokenized_datasets["test"].shuffle(seed=42).select(range(1000))

Schritt 5: Initialisieren Sie unser Basismodell

Sobald wir den zu verwendenden Datensatz haben, laden wir unser Modell und geben die Anzahl der erwarteten Beschriftungen an. Aus dem Sentiment-Datensatz des Tweets können Sie erkennen, dass es drei mögliche Bezeichnungen gibt:

  • 0 oder negativ
  • 1 oder Neutral
  • 2 oder Positiv
from transformers import GPT2ForSequenceClassification

model = GPT2ForSequenceClassification.from_pretrained("gpt2", num_labels=3)

Schritt 6: Bewerten Sie die Methode

Die Transformers-Bibliothek bietet eine Klasse namens „Trainer“, die sowohl das Training als auch die Auswertung unseres Modells optimiert. Daher müssen wir vor Beginn des eigentlichen Trainings eine Funktion definieren, um das fein abgestimmte Modell auszuwerten.

import evaluate

metric = evaluate.load("accuracy")

def compute_metrics(eval_pred):
   logits, labels = eval_pred
   predictions = np.argmax(logits, axis=-1)
   return metric.compute(predictions=predictions, references=labels)

Schritt 7: Mit der Trainer-Methode verfeinern

Der letzte Schritt besteht darin, das Modell zu verfeinern. Dazu richten wir die Trainingsargumente mit der Bewertungsstrategie ein und führen das Trainer-Objekt aus.

Um das Trainer-Objekt auszuführen, verwenden wir einfach den Befehl train().

from transformers import TrainingArguments, Trainer

training_args = TrainingArguments(
   output_dir="test_trainer",
   #evaluation_strategy="epoch",
   per_device_train_batch_size=1,  # Reduce batch size here
   per_device_eval_batch_size=1,    # Optionally, reduce for evaluation as well
   gradient_accumulation_steps=4
   )


trainer = Trainer(
   model=model,
   args=training_args,
   train_dataset=small_train_dataset,
   eval_dataset=small_eval_dataset,
   compute_metrics=compute_metrics,

)

trainer.train()

Sobald unser Modell verfeinert ist, verwenden wir den Testsatz, um seine Leistung zu bewerten. Das Trainerobjekt enthält bereits eine optimierte „evaluate()“-Methode.

import evaluate

trainer.evaluate()

Dies ist ein grundlegender Prozess zur Feinabstimmung eines beliebigen LLM.

Denken Sie auch daran, dass der Prozess der Feinabstimmung eines LLM sehr rechenintensiv ist, sodass Ihr lokaler Computer möglicherweise nicht über genügend Leistung verfügt, um ihn auszuführen.

Heutzutage ist es von entscheidender Bedeutung, große vorab trainierte Sprachmodelle wie GPT für bestimmte Aufgaben zu optimieren, um die Leistung von LLMs in bestimmten Domänen zu verbessern. Dadurch können wir die Leistungsfähigkeit ihrer natürlichen Sprache nutzen und gleichzeitig ihre Effizienz und ihr Personalisierungspotenzial verbessern, wodurch der Prozess zugänglich und kostengünstig wird.

Indem wir diese 7 einfachen Schritte befolgen (von der Auswahl des richtigen Modells und Datensatzes bis hin zum Training und der Bewertung des fein abgestimmten Modells), können wir in bestimmten Bereichen eine überlegene Modellleistung erzielen.

Für diejenigen, die sich den vollständigen Code ansehen möchten, ist er in meinem GitHub-Repository für große Sprachmodelle verfügbar.

Joseph Ferrer ist ein Analyseingenieur aus Barcelona. Er hat einen Abschluss in technischer Physik und arbeitet derzeit im Bereich der Datenwissenschaft für die menschliche Mobilität. Er ist nebenberuflich als Content-Ersteller tätig und konzentriert sich auf Datenwissenschaft und -technologie. Josep schreibt über alles, was mit KI zu tun hat, und behandelt die Anwendung der anhaltenden Explosion in diesem Bereich.

About the author

smirow

Leave a Comment