Die 6 besten Fine-Tuning-Tools für das Modelltraining im Jahr 2026

Einführung

Fine-Tuning ist eine Technik im Bereich des Machine Learning, insbesondere beim Deep Learning, bei der ein vortrainiertes Modell auf einem kleineren, spezifischen Datensatz weiterverfolgt oder „feinabstimmend“ trainiert wird, der auf eine bestimmte Aufgabe zugeschnitten ist. 

Nehmen wir an, Sie entwickeln ein Modell zur Erstellung technischer Handbücher für Elektronik mit GPT-3 (einem großen Sprachmodell mit 175 Milliarden Parametern), aber die generische Ausgabe von GPT-3 erfüllt nicht die erforderliche technische Genauigkeit und den gewünschten Tonfall.

In diesem Fall könnten Sie darüber nachdenken, das Modell für Ihren spezifischen Anwendungsfall neu zu trainieren. Allerdings ist es aufgrund des immensen Bedarfs an Rechenressourcen und spezialisierten Daten unpraktisch, ein Modell wie GPT-3 für diese Nischenaufgabe direkt von Grund auf neu zu trainieren. 

Hier kommt das Fine-Tuning ins Spiel.

Fine-Tuning ist wie das Beibringen eines neuen Kunststücks für GPT-3. Es weiß dank seines Trainings mit zahlreichen Texten von Büchern bis hin zu Websites bereits sehr viel über Sprache. Ihre Aufgabe ist es, es auf einem gezielten Datensatz weiter zu trainieren – in diesem Fall einem Korpus bestehender technischer Handbücher und Dokumentationen speziell für Elektronik.

Einige grundlegende Methoden des Fine-Tunings:

1. Layer Freezing: Gezieltes Einfrieren der Gewichte bestimmter Schichten, während andere während des Fine-Tuning-Prozesses aktualisiert werden können.
2. Anpassung der Lernrate (Learning Rate Adjustment): Anpassen der Geschwindigkeit, mit der das Modell während des Fine-Tuning-Prozesses lernt, typischerweise um das Überschreiben von wertvollem, zuvor gelerntem Wissen zu verhindern.
3. Hinzufügen aufgabenspezifischer Schichten: Dies beinhaltet die Erweiterung der Modellarchitektur um neue Schichten, die direkt für die jeweilige Aufgabe trainiert werden.

‍

Parameter Efficient Fine Tuning

Parameter Efficient Fine-tuning (PEFT) ist eine Technik, die darauf abzielt, die Anzahl der zusätzlichen Parameter zu minimieren, die während des Fine-Tunings von vortrainierten neuronalen Netzmodellen erforderlich sind.

Dies hilft, die Rechenkosten und die Speicherbelegung zu reduzieren, während die Leistung beibehalten oder sogar gesteigert wird. PEFT erreicht dies, indem es Prompt-Embeddings als zusätzliche Modellparameter hinzufügt und nur eine kleine Anzahl zusätzlicher Parameter anpasst. 

PEFT erfordert im Vergleich zum traditionellen Fine-Tuning auch einen deutlich kleineren Datensatz.

‍

Schritte zur Durchführung von PEFT

1. Laden des gewählten Modells

Laden Sie das von Ihnen gewählte Modell mithilfe eines Machine-Learning-Frameworks wie TensorFlow, PyTorch oder der Transformers-Bibliothek von Hugging Face. Diese Frameworks bieten APIs, um vortrainierte Modelle einfach herunterzuladen und zu laden.

Hier ist ein Beispielcode:

from transformers import GPT2Model, GPT2Tokenizer
model_name = 'gpt2-medium'  # Choose the model variant
tokenizer = GPT2Tokenizer.from_pretrained(model_name)
model = GPT2Model.from_pretrained(model_name)

2. Prompt Engineering

Vor dem Fine-Tuning müssen Sie mit verschiedenen Prompts experimentieren, um die Antworten des Modells zu steuern. Testen Sie verschiedene Prompts mit dem vortrainierten Modell, um zu sehen, wie sie sich auf die Ausgabe auswirken, und wählen Sie den am besten geeigneten aus. Sie können auch verschiedene Parameter wie max_length, temperature usw. ändern.

Es ist so, als ob Sie herausfinden möchten, wie Sie Ihre Frage am besten stellen, damit das Modell versteht, was Sie wollen.

from transformers import pipeline

generator = pipeline('text-generation', model='gpt2')

prompt = """"""

# Generate responses
responses = generator(prompt, max_length=200, num_return_sequences=3)

for i, response in enumerate(responses):
    print(f"Response {i+1}: {response['generated_text']}")

3. Datensatz

In einem Datensatz für das Fine-Tuning gibt es typischerweise zwei Teile: Prompt (Eingabe) und Answer (Ausgabe).  Der Prompt ist wie eine Frage oder ein Startpunkt, und die Answer ist das, was das Modell als Antwort auf diese Frage generieren soll. Es kann in Form von Spalten oder als Sequenz von Texteinträgen vorliegen (was üblicher ist).

Der im letzten Schritt ermittelte beste Prompt wird hier verwendet, und die Answer entspricht genau dem, was das Modell bei Eingabe dieses Prompts erzeugen soll. 

4. Fine-Tuning des Modells

Hier bringen Sie dem Modell bei, Ihre Aufgabe besser zu erledigen. Sie nutzen den Datensatz, um das „Wissen“ des Modells leicht anzupassen. 

Hier ist eine vereinfachte Übersicht über die Einrichtung und Durchführung des Fine-Tuning-Prozesses mit PyTorch:

• Einrichtung für das Training:

from transformers import AdamW

optimizer = AdamW(model.parameters(), lr=5e-5)  # lr ist die Lernrate

• Trainingsschleife:

for epoch in range(total_epochs):
    for batch in data_loader:
        inputs, labels = batch
        outputs = model(**inputs)
        loss = outputs.loss
        loss.backward()
        optimizer.step()
        optimizer.zero_grad() 

Tools für das Fine-Tuning

Bei der Erkundung von Tools für das Prompt Engineering ist es hilfreich, sie in zwei Hauptbereiche zu unterteilen: Code-Plattformen und No-Code-Plattformen. Diese Unterscheidung vereinfacht den Auswahlprozess.
Code-Plattformen beziehen sich auf Plattformen, die virtuelle Maschinen bereitstellen, mit denen Sie Ihr benutzerdefiniertes Python-Skript für das Fine-Tuning (wie das zuvor erwähnte) ausführen können. No-Code-Plattformen hingegen beziehen sich auf Tools, die wenig bis gar kein Python-Skript erfordern. Sie verfügen über eine dedizierte Benutzeroberfläche, auf der Sie das Training mit wenigen Klicks starten können.

No-Code-Plattformen:

No-Code-Plattformen sind auf Einfachheit und Benutzerfreundlichkeit ausgelegt. Sie machen das Schreiben von Python-Skripten überflüssig und bieten eine intuitive Benutzeroberfläche, auf der das Training mit nur wenigen Klicks gestartet werden kann. dieser Bereich eignet sich für Benutzer ohne Programmierkenntnisse oder für diejenigen, die einen unkomplizierten Ansatz für das Prompt Engineering bevorzugen.

1. TrueFoundry

TrueFoundry ist ein Tool, das ML-Teams dabei hilft, ihre Modelle reibungslos in Betrieb zu nehmen. Es basiert auf Kubernetes, was bedeutet, dass es auf verschiedenen Clouds oder sogar auf Ihren eigenen Servern ausgeführt werden kann. Dies ist wichtig für Unternehmen, die auf Datensicherheit und Kostenkontrolle bedacht sind.

Für das Fine-Tuning ist es eines der besten Tools auf dem Markt und richtet sich sowohl an Einsteiger als auch an Experten. Hier haben Sie zwei Optionen: Die Bereitstellung eines Fine-Tuning-Notebooks zum Experimentieren oder das Starten eines dedizierten Fine-Tuning-Jobs.

1. Notebooks: Die Experimentierumgebung

Notebooks bieten das ideale Setup für exploratives und iteratives Fine-Tuning. Sie können mit einer kleinen Teilmenge von Daten experimentieren und verschiedene Hyperparameter ausprobieren, um die ideale Konfiguration für die beste Leistung zu ermitteln.

2. Jobs: Zuverlässig und skalierbar

Sobald Sie durch Experimentieren die optimalen Hyperparameter und die beste Konfiguration ermittelt haben, hilft Ihnen der Übergang zu einem Deployment Job dabei, das Fine-Tuning auf dem gesamten Datensatz durchzuführen, und ermöglicht ein schnelles und zuverlässiges Training.

Daher werden Notebooks dringend für die Erkundung in der Frühphase und das Hyperparameter-Tuning empfohlen, während Deployment Jobs die bevorzugte Wahl für groß angelegtes LLM-Fine-Tuning sind, insbesondere wenn die optimale Konfiguration durch vorherige Experimente festgelegt wurde.

Hier ist eine Schritt-für-Schritt-Anleitung zum Fine-Tuning mit Notebooks und Jobs:

1. Einrichten der Trainingsdaten

TrueFoundry unterstützt zwei verschiedene Datenformate:

1. Chat: Die Daten müssen im JSONL-Format vorliegen, wobei jede Zeile eine gesamte Konversation im OpenAI-Chat-Format enthält.

Jede Zeile enthält einen Schlüssel namens messages. Jeder messages-Schlüssel enthält eine Liste von Nachrichten, wobei jede Nachricht ein Dictionary mit den Schlüsseln role und content ist. Der Schlüssel role kann entweder user, assistant oder system sein, und der Schlüssel content enthält den Nachrichteninhalt.

2. Completion: Die Daten müssen im JSONL-Format vorliegen, wobei jede Zeile einen JSON-codierten String enthält, der die zwei Schlüssel prompt und completion beinhaltet.

{"prompt": "What is 2 + 2?", "completion": "The answer to 2 + 2 is 4"}
{"prompt": "Flip a coin", "completion": "I flipped a coin and the result is heads!"}
{"prompt": "", "completion": ""}

2. Fine-Tuning

Sie können mit dem Fine-Tuning mit nur drei Klicks beginnen:

1. Wählen Sie den Workspace aus, in dem Sie arbeiten möchten
2. Modell auswählen:

Sie können ein Modell aus der umfangreichen Liste auswählen oder einfach die Hugging Face-URL einfügen, um mit dem Fine-Tuning zu beginnen.

3. Klicken Sie auf Weiter (Next)

Nachdem Sie die gewünschte GPU ausgewählt haben, haben Sie zwei Optionen: Als Notebook ausführen oder als Job.

3. Fine-Tuning mit einem Notebook

Nachdem Sie „Launch as Notebook“ gewählt und die Standardwerte für die Hyperparameter ausgewählt haben, können Sie Ihr Notebook sehen:

4. Fine-Tuning als Job:

Bevor Sie beginnen, müssen Sie zuerst ein ML Repo erstellen (dieses wird zum Speichern Ihrer Trainingsmetriken und Artefakte wie Checkpoints und Modelle verwendet) und Ihrem Workspace Zugriff auf das ML Repo gewähren. Mehr über ML Repos erfahren Sie in der Dokumentation von TrueFoundry.

Jetzt müssen Sie „Launch as Job“ wählen und die Standardwerte der Hyperparameter auswählen, um das Fine-Tuning zu starten.

Unter Deployments sehen Sie den aufgelisteten Job und können auf „Run Job“ klicken.

Hauptmerkmale:

• Unterstützung beliebter LLMs: Ermöglicht das Fine-Tuning weit verbreiteter Open-Source-LLMs wie Llama 2, Mistral, Zephyr und Mixtral.
• Flexibilität beim Fine-Tuning-Ansatz: Bietet die Option, LLMs entweder mithilfe von Jobs für Skalierbarkeit und Zuverlässigkeit oder mit Notebooks für Experimente und iteratives Tuning feinabstimmend zu trainieren.
• QLoRA-Technik: Nutzt die QLoRA-Fine-Tuning-Technik, die Effizienz und Leistung in Einklang bringt und Fine-Tuning auf weniger leistungsfähiger Hardware ohne Qualitätseinbußen ermöglicht.
• Unterstützung von Datenformaten: Unterstützt Daten im jsonl-Format für Datensätze vom Typ Chat und Completion, was eine Vielzahl von LLM-Anwendungen ermöglicht.
• Einfache Datenintegration: Bietet Optionen zum Hochladen von Trainingsdaten als TrueFoundry-Artefakt, in Cloud-Speicherdienste oder lokal, was Flexibilität bei der Datenverwaltung bietet.
• Bereitstellungsunterstützung: Nach dem Fine-Tuning stehen Anleitungen zur Bereitstellung des feinabgestimmten Modells für den praktischen Einsatz zur Verfügung, was den Nutzen des Modells erhöht.
• ML-Repository-Integration: Ermöglicht die Verfolgung des Fine-Tuning-Fortschritts und die Verwaltung von Trainingsmetriken/Artefakten über ML Repositories, wodurch eine organisierte und zugängliche Modellentwicklung gewährleistet wird.

2. OpenAI API

Die OpenAI API bietet Zugriff auf fortschrittliche Modelle für künstliche Intelligenz, die von OpenAI entwickelt wurden, einschließlich der neuesten Versionen von GPT (Generative Pre-trained Transformer). Eine der herausragenden Funktionen der OpenAI API ist die Möglichkeit, Modelle auf benutzerdefinierten Datensätzen feinabzustimmen.

So können Sie das Verhalten von Modellen wie GPT-3 oder neueren Versionen an spezifische Anwendungen anpassen oder an bestimmte Inhaltsstile und Präferenzen angleichen.

Da ich mich hier auf die API beziehe, ist es nicht ganz „No-Code“, aber dennoch lässt es sich im Vergleich zu anderen Tools im vorherigen Abschnitt leicht für das Training einrichten.

Beispielcode für Fine-Tuning:

‍

1. Vorbereiten Ihres Datensatzes

Um ein Modell feinabzustimmen, müssen Sie Ihren Datensatz zunächst in einem Format vorbereiten, das die OpenAI API verstehen kann. Typischerweise müssten Sie eine JSON-Datei erstellen, die so aussieht:

{"prompt": "The capital of France is", "completion": " Paris"}
{"prompt": "The largest planet in the solar system is", "completion": " Jupiter"}

2. Hochladen Ihres Datensatzes zu OpenAI

Sie können den Datensatz ganz einfach über die OpenAI CLI (Command Line Interface) hochladen. 

openai tools fine_tunes.prepare_data -f your_dataset.jsonl

3. Fine-Tuning des Modells

Sobald Ihr Datensatz vorbereitet und hochgeladen ist, können Sie den Fine-Tuning-Prozess starten. Das folgende Beispiel verwendet die Python-Bibliothek von OpenAI:

import openai

openai.api_key = "your-api-key"

response = openai.FineTune.create(
  training_file="file-YourFileIDHere",
  model="gpt-3.5-turbo",
  n_epochs=4,
  learning_rate_multiplier=0.1,
  batch_size=4
)

4. Verwendung Ihres feinabgestimmten Modells

Nachdem der Fine-Tuning-Prozess abgeschlossen ist, können Sie Ihr feinabgestimmtes Modell zur Generierung von Text oder für andere Aufgaben verwenden, indem Sie die ID des feinabgestimmten Modells angeben:

response = openai.Completion.create(
  model="YOUR_FINE_TUNED_MODEL_ID",
  prompt="The capital of Italy is",
  max_tokens=50
)
print(response.choices[0].text.strip())

Sie können Ihr feinabgestimmtes Modell auch bereitstellen.

Hauptmerkmale:

• Benutzerfreundlichkeit: Die API vereinfacht die Interaktion mit leistungsstarken KI-Modellen und nimmt dem Nutzer die Komplexität der direkten Verwaltung oder des Trainings großer neuronaler Netze ab.
• Skalierbarkeit: OpenAI kümmert sich um die Infrastruktur und Skalierung und bietet eine gleichbleibende Leistung unabhängig von der Arbeitslast.
• Kontinuierliche Updates: OpenAI aktualisiert seine API und Modelle regelmäßig, sodass Benutzer Zugriff auf die neuesten Fortschritte in der KI-Forschung haben.

3. Microsoft Azure

Microsoft Azure ist eine Cloud-Computing-Plattform, die ein breites Spektrum an Diensten bietet, darunter Rechenleistung, Speicher, Analysen und mehr. Sie bietet Benutzern die Werkzeuge, um Anwendungen effizient zu erstellen, bereitzustellen und zu verwalten. 

Ein bemerkenswertes Merkmal ist die intuitive Benutzeroberfläche, die Anfängern die Navigation ohne umfangreiche Programmierkenntnisse erleichtert. Mit einfachen Klicks statt komplexem Code können Benutzer ihre Anwendungen anpassen, was Azure zu einem zugänglichen Tool für eine stressfreie Entwicklung macht.

Hier ist eine einfache Anleitung zur Einrichtung eines Fine-Tuning-„Jobs“ in Azure:

1. Vorbereiten Ihrer Daten:

Dies ist selbstverständlich die grundlegende Anforderung für alle Tools. Die Trainingsdaten können im Format JSON Lines (JSONL), CSV oder TSV vorliegen. Die Anforderungen an Ihre Daten variieren je nach der spezifischen Aufgabe, für die Sie Ihr Modell feinabstimmen möchten.

Für Textklassifizierung:
Zwei Spalten: Sentence (string) und Label (integer/string)

2. Wählen Sie ein Foundation Model

3. Konfigurieren Sie einen Fine-Tuning-Job: 

Nachdem Sie den Fine-Tuning-Job übermittelt haben, wird ein Pipeline-Job erstellt, um Ihr Modell zu trainieren. Sie können alle Eingaben überprüfen und das Modell aus den Job-Ausgaben abrufen.

4. Bewerten Sie Ihr feinabgestimmtes Modell

Um zu entscheiden, ob Ihr feinabgestimmtes Modell wie erwartet funktioniert, können Sie die Trainings- und Evaluierungsmetriken überprüfen.

Hauptmerkmale:

• Benutzerfreundliche Oberfläche: Die einfach zu bedienende Oberfläche von Azure vereinfacht Anfängern die Navigation.
• No-Code-Optionen: Fine-Tuning erfordert keine umfangreiche Programmierung; Benutzer können Aufgaben mit einfachen Klicks erledigen.
• Skalierbarkeit: Anwendungen können einfach hoch- oder herunterskaliert werden, um sich ändernden Anforderungen gerecht zu werden.
• Umfassende Dienste: Azure bietet eine Reihe von Tools für das Fine-Tuning, einschließlich Analyse- und Überwachungsfunktionen.
• Integration: Lässt sich nahtlos mit Tools von Microsoft und Drittanbietern integrieren, was Flexibilität in den Workflows bietet.

4. Replicate

Replicate ist ein vielseitiges Tool, das für das Fine-Tuning verschiedener Aspekte von Softwareanwendungen entwickelt wurde. Die Anwendungen von Replicate als Fine-Tuning-Tool umfassen die Optimierung der Leistung, das Anpassen von Konfigurationen und die Erweiterung der Funktionalität mit minimalem Aufwand. Es vereinfacht den Prozess, indem es das GPU-Setup übernimmt. Ähnlich wie die OpenAI API ist es nicht genau „No-Code“ wie andere Tools in der Liste, dennoch lässt es sich im Vergleich zu anderen Tools im vorherigen Abschnitt leicht für das Training einrichten.

Schritte zum Fine-Tuning von Llama-2b:

1. Bereiten Sie Ihre Trainingsdaten vor

Ihre Trainingsdaten müssen im JSONL-Format vorliegen. Nachfolgend finden Sie ein Beispiel dafür, wie Sie diese Datei strukturieren können:

{"prompt": "What's the weather like?", "completion": "The weather is sunny."}
{"prompt": "Tell me a joke.", "completion": "Why don't scientists trust atoms? Because they make up everything!"}

2. Authentifizierung bei Replicate

Sie müssen Ihren Replicate-API-Token als Umgebungsvariable in Ihrem Terminal festlegen:

export REPLICATE_API_TOKEN=<your-token-here>

3. Laden Sie Ihre Trainingsdaten hoch

Sie können Ihre Daten in einen S3-Bucket oder direkt bei Replicate mithilfe von curl-Befehlen hochladen:

4. Erstellen Sie ein Modell auf Replicate

Sie müssen ein leeres Modell auf Replicate für Ihr trainiertes Modell erstellen. Wenn Ihr Training beendet ist, wird es als neue Version in dieses Modell hochgeladen.

5. Erstellen Sie einen Trainingsjob

Sie müssen einen Trainingsjob in Ihrer IDE erstellen, wie unten gezeigt:

import replicate

training = replicate.trainings.create(
  version="meta/llama-2-7b:version-id", # Replace "version-id" with the actual version ID of the model you chose
  input={
    "train_data": "https://yourdata.com/data.jsonl", # Use your actual data URL here
    "num_train_epochs": 3
  },
  destination="your-username/your-model-name" # Use your actual username and model name here
)

print(training)

6. Überwachen Sie den Trainingsfortschritt

Um den Fortschritt programmgesteuert zu überwachen, können Sie Folgendes verwenden:

training.reload()
print(training.status)

7. Führen Sie Ihr feinabgestimmtes Modell aus

Nachdem das Training abgeschlossen ist, können Sie Ihr Modell mit der API ausführen:

output = replicate.predictions.create(
  version=training.output["version"], # Use the version output from your training
  input={"prompt": "Your prompt here"}
)

print(output)

Hauptmerkmale:

• Benutzerfreundlichkeit: Vereinfacht den Fine-Tuning-Prozess mit einer benutzerfreundlichen Oberfläche und einer unkomplizierten API, sodass es sowohl für Anfänger als auch für erfahrene Anwender zugänglich ist.
• Cloud-basiertes Training: Beseitigt die Notwendigkeit lokaler GPU-Ressourcen durch cloudbasiertes Training, sodass Benutzer Modelle unabhängig von ihrer Hardware trainieren können.
• Flexible Dateneingabe: Unterstützt das JSONL-Format für Trainingsdaten, was eine flexible und strukturierte Eingabe für eine Vielzahl von Aufgaben ermöglicht.
• Modell-Hosting: Hostet feinabgestimmte Modelle automatisch, was eine einfache Integration und Bereitstellung von KI-Modellen in Anwendungen ermöglicht.
• Versionskontrolle: Verfolgt verschiedene Trainingsversionen, was das Verwalten, Vergleichen und Zurückkehren zu vorherigen Versionen eines Modells vereinfacht.

‍

5. Google Gen AI Studio

Im Gen AI Studio haben Sie beide Optionen zum Einrichten von Fine-Tuning-Jobs: über die API oder die Website. Hier werde ich nur auf die API-Methode eingehen. Es bietet den am stärksten rationalisierten Prozess im Vergleich zu den oben besprochenen Tools.

Hier ist eine Schritt-für-Schritt-Anleitung:

1. Vorbereiten Ihres Datensatzes

Ihr Datensatz sollte im JSONL-Format vorliegen, wobei jede Zeile ein JSON-Objekt mit den Schlüsseln "input_text" und "output_text" sein muss. Es kann bereits mit nur 10 Beispielen mit dem Training begonnen werden, es werden jedoch mindestens 100 Beispiele empfohlen.

2. Hochladen Ihres Datensatzes

Sie müssen Ihren Datensatz in einen Google Cloud Storage (GCS) Bucket hochladen. Wenn Sie keinen haben, können Sie einen in Google Drive erstellen.

3. Authentifizierung und Initialisierung

Jetzt müssen Sie Ihre Anmeldedaten angeben, um die Verbindung herzustellen:

from google.auth import default
from google.cloud import aiplatform
from vertexai import init

credentials, _ = default(scopes=["https://www.googleapis.com/auth/cloud-platform"])
project_id = "your-project-id"
location = "your-project-location" # e.g., "us-central1"
init(project=project_id, location=location, credentials=credentials)

4. Vorbereiten der Tuning-Funktion

Sie müssen eine Funktion für das Tuning mit den erforderlichen Parametern definieren.

from vertexai.language_models import TextGenerationModel
from vertexai.preview.language_models import TuningEvaluationSpec

def tuning(project_id, location, model_display_name, training_data, train_steps=10, evaluation_dataset=None, tensorboard_instance_name=None):
    eval_spec = TuningEvaluationSpec(evaluation_data=evaluation_dataset)
    if tensorboard_instance_name:
        eval_spec.tensorboard = aiplatform.Tensorboard(tensorboard_name=tensorboard_instance_name)
    model = TextGenerationModel.from_pretrained("text-bison@002")

    model.tune_model(
        training_data=training_data,
        model_display_name=model_display_name,
        train_steps=train_steps,
        tuning_job_location="europe-west4",
        tuned_model_location=location,
        tuning_evaluation_spec=eval_spec,
    )
    print(model._job.status)
    return model

5. Modell-Tuning ausführen

Rufen Sie die zuvor angegebene Tuning-Funktion mit Ihren spezifischen Parametern auf. Der Parameter training_data kann eine GCS-URI oder ein Pandas DataFrame sein.

Hauptmerkmale:

1. Bereitstellung von API-Zugriff und Benutzeroberfläche: Für diejenigen, die einen grafischen Ansatz bevorzugen, bietet Gen AI Studio eine intuitive Benutzeroberfläche.
2. Skalierbare Infrastruktur: Nutzen Sie die skalierbare Infrastruktur von Google Cloud, um große Datensätze und rechenintensive Tuning-Jobs effizient zu bewältigen.
3. Integration mit Google Cloud Services: Nahtlose Integration mit anderen Google Cloud-Diensten wie Cloud Storage für das Datensatzmanagement und Vertex AI für die Bereitstellung von Modellen.
4. Breite Palette vortrainierter Modelle: Zugriff auf eine Vielzahl vortrainierter Modelle, die für verschiedene Aufgaben und Sprachen geeignet sind und einen soliden Ausgangspunkt für das Fine-Tuning bieten.
5. Zusammenarbeit und Versionskontrolle: Funktionen zur Zusammenarbeit mit Teammitgliedern, zum Teilen von Fine-Tuning-Projekten und zur Aufrechterhaltung der Versionskontrolle über feinabgestimmte Modelle.

6. Predibase

Predibase ist eine spezialisierte Plattform, die entwickelt wurde, um das Fine-Tuning großer Sprachmodelle (LLMs) wie GPT-4 für spezifische Aufgaben oder Anwendungen zu erleichtern. Sie bietet Zugriff auf die fortschrittlichen Fähigkeiten von LLMs, indem sie eine optimierte, benutzerfreundliche Umgebung zur Anpassung dieser Modelle an individuelle Bedürfnisse bereitstellt.

Predibase bietet Ihnen sowohl das Python SDK als auch die Benutzeroberfläche zur Durchführung von Fine-Tuning-Jobs.

Hier ist eine Schritt-für-Schritt-Anleitung zum Fine-Tuning von Mistral-7b-instruct:

1. Grundlegendes Setup

Registrieren Sie sich zuerst für ein Konto bei Predibase und tätigen Sie eine Einzahlung, um Guthaben hinzuzufügen. Generieren Sie anschließend Ihren API-Schlüssel.

2. Erstellen eines Model Repositorys

Gehen Sie zu „Models“ und klicken Sie dann wie unten gezeigt auf „New Model Repository“:

Benennen Sie nun Ihr Repository und fügen Sie eine Beschreibung hinzu.

3. Fine-Tuning starten:

Füllen Sie die hervorgehobenen Bereiche aus und drücken Sie dann auf „Train“. Dadurch wird Ihre Anfrage in eine Warteschlange gestellt, bis Rechenleistung verfügbar ist.

Code-Plattformen:

Code-Plattformen sind für Benutzer mit fundierten Programmierkenntnissen konzipiert. Diese Plattformen stellen virtuelle Maschinen bereit, die das Ausführen benutzerdefinierter Python-Skripte für Aufgaben wie das Fine-Tuning ermöglichen. Sie sind perfekt für Projekte geeignet, die eine hohe Anpassung und eine präzise Kontrolle über die Trainings- und Bereitstellungsphasen erfordern.

1. Amazon SageMaker:

Amazon SageMaker ist ein vollständig verwalteter Dienst, der Entwicklern und Data Scientists die Möglichkeit bietet, Modelle für maschinelles Lernen schnell zu erstellen, zu trainieren und bereitzustellen.

Amazon SageMaker verfügt über keine spezielle, integrierte „Fine-Tuning“-Funktion, die ausdrücklich so für große Sprachmodelle gekennzeichnet ist. Stattdessen bietet es eine leistungsstarke und flexible Plattform, auf der Sie benutzerdefinierte Python-Skripte ausführen können, um Fine-Tuning-Aufgaben zu erledigen.

Hier ist ein einfaches Beispiel dafür, wie Sie einen Fine-Tuning-Job für ein Sprachmodell mit Hugging Face auf SageMaker starten können. Dies setzt voraus, dass Sie bereits ein AWS-Konto eingerichtet und die AWS CLI konfiguriert haben. (Sie können TensorFlow oder PyTorch direkt auf Amazon SageMaker für Fine-Tuning-Aufgaben verwenden)

1. SageMaker-Sitzung einrichten und initialisieren:

import sagemaker
from sagemaker.huggingface import HuggingFace

# Initialize a sagemaker session
sagemaker_session = sagemaker.Session()

# Set up the role for SageMaker
role = sagemaker.get_execution_role()

2. Vorbereiten des Fine-Tuning-Skripts:

Typischerweise schreiben Sie ein Fine-Tuning-Skript (train.py), das Sie an den Estimator übergeben. Dieses Skript sollte Ihre Logik zum Laden des Modells, zum Fine-Tuning und zum Speichern enthalten.

# Define hyperparameters (if any), model name, and fine-tuning script
hyperparameters = {'epochs': 3, 'train_batch_size': 16, 'model_name': 'distilbert-base-uncased'}

huggingface_estimator = HuggingFace(
    entry_point='train.py',          # Your script name
    instance_type='ml.p3.2xlarge',   # Training instance type
    instance_count=1,                # Number of instances
    role=role,                       # IAM role with permissions
    transformers_version='4.6.1',    # Transformers library version
    pytorch_version='1.7.1',         # PyTorch library version
    py_version='py36',               # Python version
    hyperparameters=hyperparameters)

3. Erstellen eines Hugging Face Estimators:

# Define hyperparameters (if any), model name, and fine-tuning script
hyperparameters = {'epochs': 3, 'train_batch_size': 16, 'model_name': 'distilbert-base-uncased'}

huggingface_estimator = HuggingFace(
    entry_point='train.py',          # Your script name
    instance_type='ml.p3.2xlarge',   # Training instance type
    instance_count=1,                # Number of instances
    role=role,                       # IAM role with permissions
    transformers_version='4.6.1',    # Transformers library version
    pytorch_version='1.7.1',         # PyTorch library version
    py_version='py36',               # Python version
    hyperparameters=hyperparameters
)

4. Starten des Trainingsjobs:

# Assuming you have your training data in an S3 bucket
data = {'train': 's3://your-bucket/train-dataset/', 'test': 's3://your-bucket/test-dataset/'}

# Fit the model
huggingface_estimator.fit(data)

Hauptmerkmale:

1. Vorgefertigte Algorithmen und Unterstützung gängiger Frameworks: SageMaker unterstützt TensorFlow, PyTorch, Hugging Face und andere, was das Fine-Tuning von LLMs auf benutzerdefinierten Datensätzen erleichtert.
2. Managed Spot Training: Es reduziert die Kosten für das Training von Modellen durch die Nutzung von Amazon EC2 Spot Instances.
3. Verteiltes Training: SageMaker vereinfacht es, Modelle schneller und kostengünstiger zu trainieren, indem der Trainingsjob über mehrere GPUs oder Instanzen verteilt wird.

2. Google Colab:

Google Colab ist ein beliebter cloudbasierter Jupyter-Notebook-Dienst, der kostenlosen Zugriff auf Rechenressourcen wie GPUs und TPUs bietet, was ihn zu einer hervorragenden Plattform für das Fine-Tuning großer Sprachmodelle (LLMs) macht.

Es ist besonders anfängerfreundlich. Colab-Notebooks laufen in der Cloud direkt über Ihren Browser, ohne dass eine lokale Einrichtung erforderlich ist.

Hier ist der einfache Code-Ausschnitt für das Fine-Tuning eines Transformer-Modells mit Hugging Face Transformers und PyTorch in Google Colab

1. Einrichten der Umgebung:

!pip install torch torchvision transformers

2. Laden eines vortrainierten Modells und Tokenizers:

from transformers import BertTokenizer, BertForSequenceClassification
from transformers import AdamW

tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForSequenceClassification.from_pretrained('bert-base-uncased')

# Prepare the model for training
model.train()

3. Fine-Tuning des Modells:  (unter der Annahme, dass Sie einen Datensatz in die Variablen input_ids, attention_masks und labels geladen haben)

from torch.utils.data import DataLoader, RandomSampler, TensorDataset

# Create a data loader
dataset = TensorDataset(input_ids, attention_masks, labels)
dataloader = DataLoader(dataset, sampler=RandomSampler(dataset), batch_size=32)

optimizer = AdamW(model.parameters(), lr=2e-5)

# Example training loop
for epoch in range(4):  # loop over the dataset multiple times
    for step, batch in enumerate(dataloader):
        batch = [r.to('cuda') for r in batch]  # Move batch to GPU
        b_input_ids, b_input_mask, b_labels = batch

        # Forward + backward + optimize
        outputs = model(b_input_ids, token_type_ids=None, attention_mask=b_input_mask, labels=b_labels)
        loss = outputs[0]
        loss.backward()
        optimizer.step()
        optimizer.zero_grad()

4. Speichern des Modells:

model.save_pretrained("/content/drive/My Drive/Colab Models/my_finetuned_model")

Hauptmerkmale:

1. Kostenloser Zugriff auf GPUs/TPUs: Colab bietet kostenlosen Zugriff auf NVIDIA-GPUs und Google-TPUs, was das Training und Fine-Tuning von Machine-Learning-Modellen erheblich beschleunigen kann.
2. Integration mit Google Drive: Speichern und greifen Sie ganz einfach direkt von Google Drive auf Ihre Datensätze und Modelle zu, was eine nahtlose Datenverarbeitung und Modellspeicherung ermöglicht.
3. Vorinstallierte Bibliotheken: Colab ist mit den meisten Data-Science- und Machine-Learning-Bibliotheken vorinstalliert, darunter TensorFlow, PyTorch, Hugging Face Transformers und viele andere, was den sofortigen Start des Fine-Tunings von Modellen erleichtert.
4. Interaktive Umgebung: Die Notebook-Schnittstelle ermöglicht eine interaktive Entwicklung und Dokumentation und kombiniert Live-Code, Visualisierungen und Textanmerkungen.

3. Paperspace Gradient

Paperspace Gradient ist eine Suite von Tools, die entwickelt wurde, um den Prozess der Entwicklung, des Trainings und der Bereitstellung von Machine-Learning-Modellen in der Cloud zu vereinfachen.

Gradient ist besonders effektiv für Aufgaben wie das Fine-Tuning großer Sprachmodelle (LLMs), da es über eine skalierbare Infrastruktur und Unterstützung für Container verfügt, was es zu einer hervorragenden Wahl für Data Scientists und ML-Experten macht.

Hier ist ein Beispiel für das Fine-Tuning eines Transformer-Modells mit PyTorch auf Paperspace Gradient.

1. Laden eines vorgefertigten Modells und Tokenizers:

from transformers import BertTokenizer, BertForSequenceClassification
import torch

tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForSequenceClassification.from_pretrained('bert-base-uncased')

2. Vorbereiten des Datensatzes:

from transformers import TextDatasetForNextSentencePrediction

dataset = TextDatasetForNextSentencePrediction(
    tokenizer=tokenizer,
    file_path="./my_dataset.txt",
    block_size=128
)

3. Fine-Tuning des Modells:

from torch.utils.data import DataLoader
from transformers import AdamW

dataloader = DataLoader(dataset, shuffle=True, batch_size=8)
optimizer = AdamW(model.parameters(), lr=1e-5)

model.train()
for epoch in range(3):  # Loop over the dataset multiple times
    for batch in dataloader:
        optimizer.zero_grad()
        inputs, labels = batch['input_ids'], batch['labels']
        outputs = model(inputs, labels=labels)
        loss = outputs.loss
        loss.backward()
        optimizer.step()

4. Speichern des Modells:

model.save_pretrained("./my_finetuned_model")

Hauptmerkmale:

1. Vorkonfigurierte Umgebungen: Gradient bietet vorkonfigurierte Umgebungen für TensorFlow, PyTorch, Hugging Face und andere Machine-Learning-Frameworks, was eine schnelle Einrichtung für Fine-Tuning-Aufgaben ermöglicht.
2. Leistungsstarke GPUs: Der Zugriff auf eine breite Palette an GPU-Optionen stellt sicher, dass Sie Ihre Rechenleistung an die Anforderungen Ihres Projekts anpassen können – von kostengünstigeren Optionen für erste Experimente bis hin zu High-End-GPUs für intensive Trainingssitzungen.
3. Gradient-Notebooks: Eine interaktive Programmierumgebung ähnlich wie Jupyter Notebooks, jedoch mit dem zusätzlichen Vorteil, auf der Cloud-Infrastruktur von Paperspace zu laufen. Dies ist ideal zum Entwickeln, Fine-Tunen und Experimentieren direkt in der Cloud.
4. Jobs und Workflows: Automatisieren Sie Ihre Machine-Learning-Pipelines, indem Sie Jobs nacheinander oder parallel ausführen, was ein effizientes Modelltraining und eine schnelle Bereitstellung ermöglicht.

4. Run.ai

Run.AI ist eine Plattform zur Optimierung von GPU-Ressourcen für Machine-Learning-Workloads, die es Data Scientists und AI-Forschern erleichtert, komplexe AI-Modelle auszuführen und zu verwalten, einschließlich des Fine-Tunings großer Sprachmodelle (LLMs). 

Sie basiert auf Kubernetes, einem Tool, das Computerressourcen effizient organisiert. Dadurch wird die Ausführung komplexer AI-Projekte vereinfacht und Teams können ihre Projekte problemlos skalieren.

Sie können die Run.AI-Dokumentation für detaillierte Einblicke konsultieren. Hier ist ein vereinfachtes Beispiel, das auf dem allgemeinen Workflow für das Fine-Tuning eines Modells wie LLaMA-2 auf der Run.AI-Plattform basiert.

1.  Vorbereiten Ihrer Umgebung

2. Einrichten Ihres Projekts und der GPU-Anforderungen

runai submit my-fine-tuning-job -p my-project --gpu 2 --image my-llama2-fine-tuning-image train.py

3. Schreiben des Fine-Tuning-Skripts

Ihr train.py-Skript sollte die Logik zum Laden von LLaMA-2 (oder Ihres gewählten Modells), Ihres Datensatzes und zur Ausführung des Fine-Tuning-Prozesses enthalten. Dies kann die Verwendung von Bibliotheken wie Hugging Face Transformers für das Laden des Modells und TensorFlow oder PyTorch für die Trainingsschleife umfassen.

from transformers import LlamaForConditionalGeneration, LlamaTokenizer

# Load model and tokenizer
model = LlamaForConditionalGeneration.from_pretrained('Llama-2-model-name')
tokenizer = LlamaTokenizer.from_pretrained('Llama-2-tokenizer-name')

# Load your dataset, prepare data loaders, define your training loop here #
model.train()


for epoch in range(num_epochs):
    for batch in dataloader:
        # Training loop logic
        pass

# Save your fine-tuned model
model.save_pretrained('./fine-tuned-model')

4. Überwachen und Verwalten des Trainings-Jobs

Run.AI bietet Tools zur Überwachung der GPU-Auslastung und des Fortschritts Ihrer Trainings-Jobs sowie zur effektiven Verwaltung der Rechenressourcen. Verwenden Sie das Run.AI-Dashboard oder die CLI, um den Status und die Leistung Ihres Jobs zu verfolgen.

runai list jobs

Dieser Befehl listet alle aktuellen Jobs auf, sodass Sie den Fortschritt und die Ressourcennutzung Ihrer Fine-Tuning-Aufgabe überwachen können.

Hauptmerkmale:

1. GPU-Optimierung und elastische GPU-Zuweisung: Optimiert automatisch die GPU-Nutzung, verbessert die Effizienz und weist GPU-Ressourcen dynamisch basierend auf den Workload-Anforderungen zu, was die Kosten erheblich senkt.
2. Vereinfachtes Ressourcenmanagement: Bietet ein intuitives Dashboard und eine CLI zur Verwaltung von AI-Workloads, was eine einfache Überwachung und Anpassung der Ressourcennutzung in Echtzeit ermöglicht.
3. Integration mit beliebten Frameworks: Unterstützt gängige Machine-Learning-Frameworks wie TensorFlow, PyTorch und Hugging Face Transformers und erleichtert so die nahtlose Integration in bestehende Workflows.

Auswahl des richtigen Tools für Sie:

Benutzerfreundlichkeit: Wählen Sie Tools, die einfach zu bedienen sind, insbesondere wenn Sie nicht viel programmieren möchten. Einige Tools erfordern nicht einmal das Schreiben von Code!

Skalierbarkeit: Stellen Sie sicher, dass das Tool mit Ihrem Projekt wachsen kann und größere Datensätze sowie komplexere Modelle reibungslos verarbeitet.

Modell- und Datensatzunterstützung: Wählen Sie Tools, die gut mit den spezifischen Daten- und Modelltypen funktionieren, die Sie verwenden.

Rechenressourcen: Achten Sie auf den Zugriff auf GPUs oder TPUs, wenn Ihr Projekt hohe Rechenleistung benötigt.

Kosten: Bedenken Sie, wie viel Sie ausgeben möchten. Einige Tools sind kostenlos; andere berechnen Kosten basierend auf den genutzten Ressourcen.

Anpassbarkeit und Kontrolle: Wenn Sie sich mit Code auskennen, bevorzugen Sie möglicherweise Tools, mit denen Sie alles feineinstellen können.

Integration: Es ist einfacher, wenn sich das Tool nahtlos in Ihren bestehenden Workflow und Ihre Tools einfügt.

Community und Support: Eine unterstützende Community und eine gute Dokumentation können Ihnen viel Ärger ersparen.

Häufig gestellte Fragen (FAQ)

Was sind die besten Fine-Tuning-Tools für LLMs?

Zu den führenden Fine-Tuning-Tools gehören Hugging Face für den Modellzugriff, SiliconFlow für cloudbasiertes Training und TrueFoundry für Orchestrierung auf Enterprise-Niveau. Open-Source-Bibliotheken wie Axolotl und LLaMA-Factory unterstützen zudem fortgeschrittene Techniken wie LoRA. TrueFoundry vereint auf einzigartige Weise Modellzugriff, Experiment-Tracking und Deployment-Governance auf einer einzigen sicheren Plattform.

Wie hoch sind die Kosten für die Nutzung von Fine-Tuning-Tools in der Cloud?

Die Kosten für Cloud-Fine-Tuning hängen von den GPU-Rechenstunden, der Modellgröße und den Speicheranforderungen ab. Das Training eines Modells mit 7B Parametern kostet typischerweise zwischen 100 $ und 400 $, während Modelle mit 70B Parametern 10.000 $ übersteigen können. Die Verwendung parametereffizienter Methoden wie QLoRA reduziert diese Ausgaben erheblich auf etwa 50–300 $ pro Trainingsdurchlauf.

Was sind Tools für parametereffizientes Fine-Tuning (PEFT)?

PEFT-Fine-Tuning-Tools nutzen Techniken wie LoRA, um nur einen winzigen Bruchteil der Parameter eines Modells anzupassen. Dies reduziert den GPU-Speicherbedarf und ermöglicht es Teams, riesige Modelle auf Consumer-Hardware oder einer einzelnen GPU zu trainieren. Diese Tools beschleunigen die Trainingsgeschwindigkeit und liefern gleichzeitig eine Genauigkeit, die mit dem vollständigen Nachtrainieren des Modells vergleichbar ist.

Wie unterscheiden sich Fine-Tuning-Tools von Prompt Engineering?

Fine-Tuning-Tools trainieren Modelle auf spezialisierten Datensätzen nach und passen Parameter an, um die Leistung bei domänenspezifischen Aufgaben zu verbessern. Prompt Engineering modifiziert den Eingabetext, um Ausgaben zu steuern, ohne die internen Modellgewichte zu ändern. Während Prompt Engineering schneller ist, bietet Fine-Tuning eine tiefere Kontrolle und überlegene Genauigkeit für komplexe Enterprise-Anwendungsfälle.

Wie funktioniert TrueFoundry als Fine-Tuning-Tool?

TrueFoundry vereinfacht das Fine-Tuning durch die Bereitstellung einer einheitlichen Schnittstelle für Datenintegration, Experiment-Tracking und Modellbereitstellung. Benutzer laden proprietäre Daten hoch und starten Fine-Tuning-Jobs auf optimierter Infrastruktur unter Verwendung von Hochleistungs-Backends. Sobald das Training abgeschlossen ist, können Teams aktualisierte Checkpoints mit einem einzigen Klick direkt in die Produktion deployen.