In diesem Leitfaden zur überwachten Feinabstimmung von LLMs erfahren Sie mehr:
- Was ist überwachte Feinabstimmung im Zusammenhang mit LLMs
- Was ist das Ziel dieser Praxis?
- Die Ressourcen, die Sie für die Umsetzung benötigen
- Der Arbeitsablauf für die überwachte Feinabstimmung von LLMs
- Technische Herausforderungen und Überlegungen bei der SFT-Implementierung
- Eine Schritt-für-Schritt-Anleitung zur Nachbildung der überwachten Feinabstimmung auf einem LLM
Lasst uns eintauchen!
Definition der überwachten Feinabstimmung (SFT) im LLM-Kontext
Die überwachte Feinabstimmung (SFT) ist eine Form des Transferlernens, das auf LLM angewendet wird. Transferlernen ist eine Methode des maschinellen Lernens, bei der das bei der Lösung eines Problems gewonnene Wissen zur Lösung eines anderen, aber verwandten Problems eingesetzt wird.
Im Zusammenhang mit LLMS beinhaltet die überwachte Feinabstimmung, dass ein bereits trainiertes Modell weiter trainiert wird. Dies geschieht durch die Anpassung seiner Parameter unter Verwendung eines kuratierten Datensatzes mit beschrifteten Beispielen, die für eine bestimmte Aufgabe relevant sind.
Der “überwachte” Charakter ist der Schlüssel zu diesem Prozess, da Ingenieure hinter dem gesamten Prozess stehen:
- Sie bereiten den Feinabstimmungsdatensatz mit expliziten Eingabe-Ausgabe-Paaren vor. Dieser Datensatz enthält die “richtigen Antworten”, die das Lernen des Modells für bestimmte Aufforderungen lenken.
- Sie kümmern sich um den gesamten Feinabstimmungsprozess von der Einrichtung bis zur Überwachung und Validierung.
Im Vergleich zu RAG(Retrieval-Augmented Generation) wird beim Fine-Tuning das Modell selbst verändert. RAG lässt das Modell unangetastet und füttert es lediglich mit neuen relevanten Informationen. Stattdessen beinhaltet die Feinabstimmung einen neuen Trainingsprozess.
Was ist das Ziel der überwachten Feinabstimmung bei LLMs?
Das Hauptziel der überwachten Feinabstimmung ist die Verbesserung der Leistung eines LLM bei bestimmten Aufgaben, die über seine allgemeinen vortrainierten Fähigkeiten hinausgehen. Dies beinhaltet:
- Aufgabenspezialisierung: Machen Sie das Modell fit für Aufgaben wie Textzusammenfassung, Codegenerierung für eine bestimmte Sprache, Stimmungsanalyse und mehr.
- Anpassung an den Bereich: Durchdringung des Modells mit Wissen und Terminologie, die für Nischenbereiche spezifisch sind. Gängige Beispiele sind die Analyse juristischer Dokumente, die Erstellung medizinischer Berichte und Finanzprognosen.
- Anpassung des Tons: Trainieren Sie das Modell, um eine konsistente Markenstimme, ein bestimmtes Maß an Förmlichkeit oder eine bestimmte Gesprächspersona anzunehmen, die für Anwendungen wie Chatbots erforderlich ist.
Was Sie für die Umsetzung des Fine-Tuning benötigen
An dieser Stelle fragen Sie sich vielleicht: Warum sollte ein LLM nicht von Anfang an dafür ausgebildet werden? Der Grund ist einfach. Die Ausbildung eines LLM umfasst:
- Eine riesige Datenmenge, die oft in mehreren Rechenzentren gespeichert ist.
- Eine Menge Hardware.
- Es wird viel Geld und Zeit investiert.
Um eine Vorstellung davon zu bekommen, benötigen Sie Modelle wie ChatGPT, Gemini und ähnliche:
- Mehrere Monate – wenn nicht sogar Jahre.
- Eine Menge GPUs, die jeweils Tausende von Dollar kosten und über mehrere Rechenzentren verteilt sind.
Für die Feinabstimmung benötigen Sie hingegen nur drei Dinge:
- Ein vortrainiertes Modell.
- Ein Computer.
- Ein kleiner, beschrifteter Datensatz.
Jetzt dürfte klarer sein, warum die Feinabstimmung so praktisch ist.
Die Mechanik hinter dem Arbeitsablauf der überwachten Feinabstimmung
Die Durchführung eines überwachten Feinabstimmungsprozesses umfasst mehrere technische Schritte. Es ist an der Zeit, den gesamten Prozess aufzuschlüsseln!
Schritt 1: Kuratieren Sie den hochwertigen SFT-Datensatz
Die Wirksamkeit des Verfahrens hängt in hohem Maße von der Qualität und der Relevanz des Datensatzes für die Feinabstimmung ab. Dies beinhaltet:
- Datenbeschaffung: Beschaffung von Rohdaten, die für die Zielaufgabe relevant sind, mit einer der vielen Datenbeschaffungstechniken. Der Umfang kann von Hunderten bis Zehntausenden von Zeilen reichen. Dies hängt von der Komplexität der Aufgabe und dem vorab trainierten Modell ab.
- Strukturierung der Daten: Umwandlung der Rohdaten in ein strukturiertes Format, das für den SFT-Prozess geeignet ist. Eines der typischen Formate ist JSON Lines (JSONL), wobei jede Zeile ein JSON-Objekt ist, das unterschiedliche Felder für die Eingabe und die gewünschte Ausgabe enthält.
- Qualitätssicherung: Sicherstellen, dass die Daten genau, konsistent, vielfältig und frei von Verzerrungen sind, die sich negativ auf das Verhalten des Modells auswirken könnten.
Schritt Nr. 2: Auswahl eines geeigneten vortrainierten Modells
Es sind mehrere vortrainierte Modelle verfügbar. Zu den wichtigsten Überlegungen bei der Auswahl des besten Modells für Ihren Fall gehören:
- Größe des Modells: Sie wird durch die Anzahl der Parameter angegeben (z. B. 7B, 13B, 70B) und steht in Zusammenhang mit der Fähigkeit des Modells, komplexe Muster und Nuancen zu lernen. Größere Modelle bieten in der Regel eine höhere Leistung, erfordern aber auch mehr Hardware-Ressourcen für die Feinabstimmung.
- Architektur: Die spezifische Architektur kann für bestimmte Aufgaben geeignet sein. Zum Beispiel
: Polylang-Platzhalter nicht ändern
- Basisfähigkeiten: Bewerten Sie die Leistung des vortrainierten Modells bei akademischen Benchmarks, die für Ihre Zielaufgabe relevant sind, bevor Sie sich an die Feinabstimmung machen. Dies liefert eine Grundlage und zeigt die Eignung des Modells an. Zum Beispiel
:Polylang Platzhalter nicht ändern
- Lizenzierung: Die Lizenz, unter der ein Modell veröffentlicht wird, bestimmt, wie es verwendet, verändert und verbreitet werden kann. Einige Modelle haben Open-Source-Berechtigungen, andere nicht.
- Vorhandene Feinabstimmungen: Manchmal kann es effizienter sein, von einem Modell auszugehen, das bereits für eine verwandte Aufgabe feinabgestimmt wurde, als von einem unbearbeiteten Basismodell. Dies ist eine Form der Zwischen-Feinabstimmung.
Schritt Nr. 3: Implementierung der Schulungsschleife
Der Kern des Prozesses besteht darin, den beschrifteten Datensatz zu durchlaufen und die Gewichte des Modells wie folgt anzupassen:
- Vorwärtsdurchlauf: Das Modell verarbeitet eine Eingabe (den Prompt) aus dem SFT-Datensatz und erzeugt eine Ausgabe.
- Verlustberechnung: Eine Verlustfunktion vergleicht die vom Modell generierte Ausgabe, Token für Token, mit der im Datensatz angegebenen Zielausgabe. Dies ist nützlich, um den Fehler zu quantifizieren.
- Rückwärtsdurchlauf (Backpropagation): Der berechnete Verlust wird zur Berechnung von Gradienten verwendet, die angeben, wie viel jedes Modellgewicht zum Fehler beigetragen hat.
- Aktualisierung der Gewichte: Ein Optimierungsalgorithmus verwendet die Gradienten und eine bestimmte Lernrate, um die Gewichte des Modells anzupassen. Ziel ist es, die Fehler in den nachfolgenden Iterationen zu minimieren.
- Abstimmung von Hyperparametern: Die Parameter, die den Trainingsprozess steuern, werden abgestimmt, um die Leistung des Modells zu verbessern.
Schritt Nr. 4: Auswertung der Ergebnisse
In einem letzten Schritt müssen Sie die Leistung des fein abgestimmten Modells bewerten. Dies beinhaltet:
- Validierungssatz: Ein Teil des beschrifteten Datensatzes muss verwendet werden, um den Fortschritt zu überwachen und eine Überanpassung zu verhindern.
- Testsatz: Sie benötigen einen Datensatz mit Daten, die neu sind und vom Modell nicht gesehen werden, was eine Teilmenge des Feinabstimmungsdatensatzes sein kann. Dieser Schritt wird für die endgültige Bewertung nach Abschluss der Feinabstimmung durchgeführt.
- Metriken: Definieren Sie quantitative Metriken, die für die Aufgabe relevant sind, um die Leistung zu bewerten.
- Qualitative Analyse: Überprüfung der Modellergebnisse zur Bewertung von Kohärenz, Relevanz, Stilechtheit und Sicherheit.
Technische Herausforderungen und Überlegungen bei der SFT-Implementierung
Die Umsetzung von SFT bringt mehrere technische Herausforderungen mit sich, wie z. B.:
- Qualität und Umfang des Datensatzes: Die größte Herausforderung besteht darin, einen ausreichend großen, hochwertigen und repräsentativen markierten Datensatz zu erstellen oder zu beschaffen. Eine schlechte Datenqualität schlägt sich direkt in einer schlechten Modellleistung nieder. Datenextraktion, -bereinigung, -beschriftung, -aggregation und -formatierung erfordern erheblichen Aufwand und Fachwissen.
- Abschwächung des katastrophalen Vergessens: Eine intensive Feinabstimmung für eine bestimmte Aufgabe kann dazu führen, dass das Modell einige seiner allgemeinen Fähigkeiten, die es beim Vortraining gelernt hat, “vergisst”. Strategien wie die Verwendung niedrigerer Lernraten, die Feinabstimmung für weniger Epochen oder die Einbeziehung verschiedener Daten können helfen, dieses Phänomen abzuschwächen.
- Strategien zur Optimierung von Hyperparametern: Die Suche nach dem optimalen Satz von Hyperparametern ist ein empirischer Prozess. Dies erfordert mehrere Experimente und eine sorgfältige Überwachung der Validierungsmetriken. Automatisierte Hyperparameter-Tuning-Frameworks können helfen, erhöhen aber die Komplexität.
Überwachtes Fine-Tuning LLMs: Schritt-für-Schritt-Anleitung
Zeit, die Theorie in die Praxis umzusetzen. Dieser Abschnitt des Tutorials wird Sie durch die Feinabstimmung eines leichtgewichtigen LLM führen, so dass Sie Ihren Computer ohne zusätzliche Hardware verwenden können. Das Ziel ist die Feinabstimmung eines LLM zur Erstellung von Produktbeschreibungen für den elektronischen Handel anhand einer Liste von Merkmalen.
Sie werden DistilGPT2 als LLM verwenden, eine destillierte Version von GPT-2 mit geringerem Umfang und geringerer Effizienz.
Lassen Sie uns das gewählte Modell feinabstimmen!
Voraussetzungen
Um dieses Tutorial zur überwachten Feinabstimmung von LLMs zu wiederholen, müssen Sie mindestens Python 3.10+ auf Ihrem Rechner installiert haben.
Sie benötigen außerdem einen CSV-Datensatz für die Feinabstimmung. Hier verwenden wir einen benutzerdefinierten Datensatz, der Daten für E-Commerce-Produkte enthält. Das Dataset enthält die folgenden Felder für jedes Produkt:
- Kategorie: Elektronik, Bücher, Küche und Ähnliches.
- Name: Der Name des Produkts.
- Merkmale: Die wichtigsten Merkmale des Produkts.
- Farbe: Die Farbe des Produkts.
- Beschreibung: Text, der beschreibt, was das Produkt ist oder tut.
Das folgende Bild zeigt ein Beispiel für die verwendeten Daten:
Schritt Nr. 1: Beginnen Sie
Angenommen, Sie nennen den Hauptordner Ihres Projekts fine_tuning/. Am Ende dieses Schritts wird der Ordner die folgende Struktur haben:
fine_tuning/
├── data/
| └── data.csv
├── results_distilgpt2/
├── tuning.py
└── venv/Wo:
data.csventhält die beschrifteten Daten für die Feinabstimmung des zuvor vorgestellten LLM.results_distilgpts/ist der Ordner, der die Ergebnisse enthalten wird. Er wird während des Prozesses automatisch erstellt.tuning.pyist die Python-Datei, die die gesamte Logik enthält.venv/enthält die virtuelle Umgebung.
Sie können das Verzeichnis venv/ virtuelle Umgebung wie folgt erstellen:
python -m venv venvUm es zu aktivieren, führen Sie unter Windows aus:
venv\Scripts\activateUnter macOS/Linux führen Sie entsprechend aus:
source venv/bin/activateInstallieren Sie in der aktivierten virtuellen Umgebung die für dieses Lernprogramm benötigten Bibliotheken:
pip install transformers datasets torch trl Die in diesem Projekt verwendeten Bibliotheken sind:
transformers: Hugging Face’s Bibliothek für moderne maschinelle Lernmodelle.Datensätze: Hugging Face’s Bibliothek für den Zugriff auf und die Verarbeitung von Datensätzen.Fackel: PyTorch, ein Open-Source-Framework für maschinelles Lernen.trl: Hugging Face’s Transformer Reinforcement Learning Bibliothek, die Werkzeuge für SFT wieSFTTrainerenthält.
Perfekt! Ihre Python-Umgebung für die LLM-Feinabstimmung ist korrekt eingerichtet.
Schritt Nr. 2: Ersteinrichtung, Laden von Daten und Textformatierung
Als ersten Schritt müssen Sie in tuning.py den gesamten Prozess einrichten:
import os
from datasets import load_dataset
from transformers import AutoTokenizer, AutoModelForCausalLM, TrainingArguments, pipeline
from trl import SFTTrainer
# Configure parameters
base_model_name = "distilgpt2" # Pre-trained model to be fine-tuned
data_file_path = "data/data.csv" # Path to your CSV data file
output_model_dir = "./results_distilgpt2" # Directory to save training results and checkpoints
final_model_path = os.path.join(output_model_dir, "final_model") # Path to save the final fine-tuned model
max_seq_length_for_tokenization = 512 # Maximum sequence length for tokenizing inputs
# Load dataset
raw_dataset = load_dataset("csv", data_files=data_file_path)
# Define a function to format entries into a prompt-completion pair
def format_dataset_entry(data_item):
prompt_template = "Generate a product description for the following item:\nFeatures: {features_data}\n\nDescription:"
data_item["text"] = prompt_template.format(features_data=data_item["features"]) + " " + data_item["description"]
return data_item
# Apply the formatting function to the train split of the dataset
text_formatted_dataset = raw_dataset["train"].map(format_dataset_entry)Dieser Ausschnitt:
- Legt den Namen des LLM fest, der mit
base_model_namezu verwenden ist. - Definiert den Pfad, in dem sich die CSV-Datei befindet, und öffnet sie mit der Methode
load_dataset(). - Erstellt einen Ordner, in dem die Ergebnisse gespeichert werden
(results_distilgpt2/). - Erzeugt die Funktion
format_dataset_entry(), die jede Zeile vonraw_datasetin ein Textformat für die Feinabstimmung umwandelt. Außerdem wird der geänderte Inhalt an die Spalte “description” in der CSV-Datei angehängt, wobei die aktuelle Spalte überschrieben wird. Dadurch wird das Modell mit bereinigten Textbeschreibungen versehen. - Wendet die Funktion
format_dataset_entry()auf jedes Element im geteilten Trainingsdatensatz mit der Methodemap()an.
Gut gemacht! Sie haben die Ersteinrichtung des Prozesses abgeschlossen.
Schritt #3: Tokenisierung des Datensatzes
Sprachmodelle verstehen keinen Rohtext. Sie arbeiten mit numerischen Repräsentationen, die Token genannt werden. In diesem Schritt wird der vortrainierte Tokenizer geladen und verwendet, um die formatierten Texteinträge in Sequenzen von Token-IDs umzuwandeln:
# Load the tokenizer associated with the base model
tokenizer = AutoTokenizer.from_pretrained(base_model_name)
tokenizer.pad_token = tokenizer.eos_token # Padding token
# Define a function to tokenize the "text" field of the dataset
def tokenize_function(data_items_batch):
return tokenizer(
data_items_batch["text"],
truncation=True,
padding="max_length",
max_length=max_seq_length_for_tokenization,
)
# Apply the tokenization function to the formatted dataset
tokenized_dataset = text_formatted_dataset.map(
tokenize_function,
batched=True,
remove_columns=text_formatted_dataset.column_names
)Der obige Code bewirkt Folgendes:
- Lädt den mit
base_model_nameverbundenen Tokenizer mit der MethodeAutoTokenizer.from_pretrained(). - Definiert ein Auffüllungszeichen, um alle Eingabesequenzen bei der Eingabe in das Modell auf die gleiche Länge zu bringen.
- Tokenisierung des Datensatzes mit der benutzerdefinierten Funktion
tokenize_function()und Anwendung der Tokenisierung auf den Datensatz.
Wunderbar! Der Datensatz ist tokenisiert.
Schritt Nr. 4: Konfigurieren und Ausführen des Feinabstimmungsprozesses
Der Datensatz ist vorbereitet und tokenisiert, so dass Sie nun zum Kern der Feinabstimmung übergehen können:
# Load the pre-trained language model
model = AutoModelForCausalLM.from_pretrained(base_model_name)
# Define training arguments for the SFTTrainer
training_args = TrainingArguments(
output_dir=output_model_dir,
num_train_epochs=3,
per_device_train_batch_size=1,
learning_rate=2e-5,
logging_steps=10,
save_steps=50,
report_to="none",
)
# Initialize the SFTTrainer
trainer = SFTTrainer(
model=model,
args=training_args,
train_dataset=tokenized_dataset,
)
# Begin the training process
trainer.train()
# Save the fine-tuned model and tokenizer to the specified path
trainer.save_model(final_model_path)
tokenizer.save_pretrained(final_model_path)Dieser Code:
- Lädt das Basismodell mit der Methode
AutoModelForCausalLM.from_pretrained(). - Definiert die Einstellungen für den Prozess, wie z. B. die Anzahl der Epochen, die Stapelgröße und die Lernrate, mithilfe der Methode
TrainingArguments(). - Initialisiert und führt
SFTTrainer()aus und versorgt das Modell mit dem tokenisierten Datensatz und den Trainingsargumenten. Dies verwaltet die eigentliche Feinabstimmungsschleife. - Trainiert das Modell und speichert die Ergebnisse in dem dafür vorgesehenen Ordner.
Fantastisch! Sie haben den Prozess der Feinabstimmung eingeleitet.
Schritt Nr. 5: Bewerten und testen Sie das fein abgestimmte Modell
Sie müssen nun die Leistung bewerten und sehen, wie gut das Modell Beschreibungen für neue, noch nicht gesehene Produktmerkmale erzeugt:
# Load the fine-tuned model and tokenizer for testing
fine_tuned_model_for_testing = AutoModelForCausalLM.from_pretrained(final_model_path)
fine_tuned_tokenizer_for_testing = AutoTokenizer.from_pretrained(final_model_path)
# Create a text-generation pipeline with the fine-tuned model
generator_fine_tuned = pipeline("text-generation", model=fine_tuned_model_for_testing, tokenizer=fine_tuned_tokenizer_for_testing)
# Define example product features for testing
test_product_features = [
"Category: Kitchen, Name: Electric Kettle, Features: 1.7L capacity, Stainless steel, Auto shut-off, Boil-dry protection, Color: Silver",
"Category: Office, Name: Ergonomic Office Chair, Features: Lumbar support, Adjustable height, Mesh back, Swivel, Color: Black"
]
# Define the prompt template
prompt_template_inference = "Generate a product description for the following item:\nFeatures: {features}\n\nDescription:"
# Generate descriptions for each test item
for features_item in test_product_features:
full_prompt = prompt_template_inference.format(features=features_item)
print(f"\nPROMPT:\n{full_prompt}")
generated_outputs = generator_fine_tuned(
full_prompt,
max_new_tokens=70,
num_return_sequences=1,
pad_token_id=fine_tuned_tokenizer_for_testing.eos_token_id,
eos_token_id=fine_tuned_tokenizer_for_testing.eos_token_id
)
print(f"GENERATED (Fine-tuned):\n{generated_outputs[0]['generated_text']}")Dieses Snippet macht folgendes:
- Lädt das feinabgestimmte Modell und den Tokenizer.
- Erstellt eine Textgenerierungspipeline mit dem fein abgestimmten Modell unter Verwendung der Methode
pipeline(). - Definiert eine Liste, die neue, ungesehene Produktbeschreibungen enthält, um die Feinabstimmung des Modells mit
test_product_featureszu füttern und zu bewerten. - Erzeugt die Beschreibungen für jeden Prüfling in der
for-Schleife. - Druckt die mit dem Feinabstimmungsmodell erstellten Beschreibungen aus.
Prima! Sie haben eine Pipeline für die Prüfung und Bewertung der Leistung des Modells eingerichtet.
Schritt #6: Alles zusammenfügen
Ihre tuning.py-Datei sollte nun enthalten:
import os
from datasets import load_dataset
from transformers import AutoTokenizer, AutoModelForCausalLM, TrainingArguments, pipeline
from trl import SFTTrainer
# Configure parameters
base_model_name = "distilgpt2" # Pre-trained model
data_file_path = "data/data.csv" # Path to data
output_model_dir = "./results_distilgpt2" # Directory to save results and checkpoints
final_model_path = os.path.join(output_model_dir, "final_model") # Path to save the final fine-tuned model
max_seq_length_for_tokenization = 512 # Maximum length for tokenizing inputs
# Load dataset
raw_dataset = load_dataset("csv", data_files=data_file_path)
# Define a function to format entries into a prompt-completion pair
def format_dataset_entry(data_item):
prompt_template = "Generate a product description for the following item:\nFeatures: {features_data}\n\nDescription:"
data_item["text"] = prompt_template.format(features_data=data_item["features"]) + " " + data_item["description"]
return data_item
# Apply the formatting function to the train split of the dataset
text_formatted_dataset = raw_dataset["train"].map(format_dataset_entry)
# Load the tokenizer associated with the base model
tokenizer = AutoTokenizer.from_pretrained(base_model_name)
tokenizer.pad_token = tokenizer.eos_token
# Define a function to tokenize the "text" field of the dataset
def tokenize_function(data_items_batch):
return tokenizer(
data_items_batch["text"],
truncation=True,
padding="max_length",
max_length=max_seq_length_for_tokenization,
)
# Apply the tokenization function to the formatted dataset
tokenized_dataset = text_formatted_dataset.map(
tokenize_function,
batched=True,
remove_columns=text_formatted_dataset.column_names
)
# Load the pre-trained language model
model = AutoModelForCausalLM.from_pretrained(base_model_name)
# Define training arguments for the SFTTrainer
training_args = TrainingArguments(
output_dir=output_model_dir,
num_train_epochs=3,
per_device_train_batch_size=1,
learning_rate=2e-5,
logging_steps=10,
save_steps=50,
report_to="none",
)
# Initialize the SFTTrainer
trainer = SFTTrainer(
model=model,
args=training_args,
train_dataset=tokenized_dataset,
)
# Begin the training process
trainer.train()
# Save the fine-tuned model and tokenizer to the specified path
trainer.save_model(final_model_path)
tokenizer.save_pretrained(final_model_path)
# Load the fine-tuned model and tokenizer for testing
fine_tuned_model_for_testing = AutoModelForCausalLM.from_pretrained(final_model_path)
fine_tuned_tokenizer_for_testing = AutoTokenizer.from_pretrained(final_model_path)
# Create a text-generation pipeline with the fine-tuned model
generator_fine_tuned = pipeline("text-generation", model=fine_tuned_model_for_testing, tokenizer=fine_tuned_tokenizer_for_testing)
# Define example product features for testing
test_product_features = [
"Category: Kitchen, Name: Electric Kettle, Features: 1.7L capacity, Stainless steel, Auto shut-off, Boil-dry protection, Color: Silver",
"Category: Office, Name: Ergonomic Office Chair, Features: Lumbar support, Adjustable height, Mesh back, Swivel, Color: Black"
]
# Define the prompt template
prompt_template_inference = "Generate a product description for the following item:\nFeatures: {features}\n\nDescription:"
# Generate descriptions for each test item
for features_item in test_product_features:
full_prompt = prompt_template_inference.format(features=features_item)
print(f"\nPROMPT:\n{full_prompt}")
generated_outputs = generator_fine_tuned(
full_prompt,
max_new_tokens=70,
num_return_sequences=1,
pad_token_id=fine_tuned_tokenizer_for_testing.eos_token_id,
eos_token_id=fine_tuned_tokenizer_for_testing.eos_token_id
)
print(f"GENERATED (Fine-tuned):\n{generated_outputs[0]['generated_text']}")Führen Sie Ihren Code mit aus:
python tuning.pyDas erwartete Ergebnis sieht folgendermaßen aus:
Wie gezeigt, wird das Modell aufgefordert, eine Beschreibung für einen Wasserkocher zu erstellen und die erforderlichen Informationen bereitzustellen. Das Modell erstellt die Beschreibung, wie erwartet. Wenn Sie dieses Ergebnis aufschlüsseln, können Sie sehen:
- Generierter Produktname: Er generiert den Produktnamen “ProChef Luxury Living Hood Series X”, der für einen Küchenartikel plausibel klingt, und die Beschreibung.
- Widersprüchliches Detail: Es schließt mit “Erhältlich in einem atemberaubenden Pure White Finish”, was im Widerspruch zur “Farbe: Silber” steht, die in den Merkmalen der Aufforderung angegeben ist. Auch wenn die Feinabstimmung das Modell leitet, garantiert sie keine perfekte Konsistenz. Dies ist vor allem bei kleineren Modellen und begrenztem Training der Fall.
Unvollkommenheiten und Widersprüche sind typisch für generative Modelle, insbesondere für kleinere Modelle wie distilgpt2. Sie können auch von der Größe und Qualität des Feinabstimmungsdatensatzes sowie von der Anzahl der Trainingsepochen abhängen. In diesem Fall hat der verwendete Datensatz nur 300 Zeilen. Ein größerer Datensatz hätte zu einer besseren Beschreibung des Wasserkochers geführt.
Um den Qualitätsverlust zu verdeutlichen, sehen Sie unten das erwartete Ergebnis mit einer CSV-Datei, die nur 5 Zeilen enthält:
Wie Sie sehen können, ist das Ergebnis eine totale Halluzination. Um es aufzuschlüsseln:
- Generierter Produktname: ****It benennt das Produkt in der ersten Phrase “Bürostuhl” statt “Ergonomischer Bürostuhl”.
- Widersprüchliches Detail: ****Im zweiten Satz wird der Name zu “Lumbal”. Das Modell verwechselt also den Namen mit dem Merkmal (“Lendenwirbelstütze”).
- Inkonsistente Grammatik: Beide Sätze haben eine inkonsistente und falsche Grammatik.
- Fehlende Eigenschaften: Die Farbe und die Eigenschaften (“Lendenwirbelstütze”, “Höhenverstellbar”, “Drehbar”) werden in der Beschreibung nicht erwähnt.
Wenn Sie jedoch dem Modell distilgpt2 die gleiche Eingabeaufforderung ohne den Feinabstimmungsprozess geben würden, wäre die Ausgabe deutlich schlechter. Dies ist darauf zurückzuführen, dass dieses Modell nicht auf so spezifische Daten trainiert wurde. Es könnte zum Beispiel nicht in der Lage sein, die Beschreibung für den Wasserkocher zu liefern.
Beachten Sie, dass der Code nach Abschluss des Prozesses automatisch einen Ordner mit der Bezeichnung results_distilgpt2/ erstellt, in dem die Ergebnisse gespeichert werden. Darin finden Sie Unterordner mit den Ergebnissen, die das Modell zu verschiedenen Epochen gespeichert hat:
Dies ist nützlich, wenn Sie einen dieser Punkte als Kontrollpunkte erhalten und nach Belieben verwenden möchten.
Et voilà! LLM-Feinabstimmung abgeschlossen.
Schlussfolgerung
In diesem Artikel haben Sie gelernt, was überwachte Feinabstimmung im Zusammenhang mit LLMs ist. Sie haben auch einen Schritt-für-Schritt-Prozess durchlaufen, um den Feinabstimmungsprozess zu replizieren.
Der Kern von SFT beruht auf hochwertigen Datensätzen für die Feinabstimmung Ihrer Modelle. Glücklicherweise bietet Bright Data zahlreiche Dienstleistungen für den Erwerb oder die Erstellung von Datensätzen an:
- Scraping-Browser: Ein Playwright-, Selenium-, Puppeter-kompatibler Browser mit eingebauten Freischaltfunktionen.
- Web Scraper APIs: Vorkonfigurierte APIs zum Extrahieren strukturierter Daten aus über 100 wichtigen Domains.
- Web Unlocker: Eine All-in-One-API, die die Freischaltung von Websites mit Anti-Bot-Schutz ermöglicht.
- SERP-API: Eine spezielle API, die Suchmaschinenergebnisse freischaltet und vollständige SERP-Daten extrahiert.
- Grundlegende Modelle: Greifen Sie auf konforme, webbasierte Datensätze zu, um Pre-Training, Bewertung und Feinabstimmung zu unterstützen.
- Datenanbieter: Verbinden Sie sich mit vertrauenswürdigen Anbietern, um hochwertige, KI-fähige Datensätze in großem Umfang zu beziehen.
- Datenpakete: Erhalten Sie kuratierte, gebrauchsfertige Datensätze – strukturiert, angereichert und mit Anmerkungen versehen.
Erstellen Sie ein kostenloses Bright Data-Konto, um unsere Datenextraktionsdienste zu testen und unseren Marktplatz für Datensätze zu erkunden!
Keine Kreditkarte erforderlich
