Open-Source-Tools zur Feinabstimmung Ihrer LLM-Modelle

Ein vortrainiertes Modell wird anhand eines kleineren, spezifischen Datensatzes, der auf eine bestimmte Aufgabe zugeschnitten ist, weiter trainiert oder „abgestimmt“.

Angenommen, Sie entwickeln ein Modell, das technische Handbücher für Elektronik mithilfe von GPT-3 (einem großen Sprachmodell mit 175 Milliarden Parametern) generiert, aber die generische Ausgabe von GPT-3 erfüllt nicht die erforderliche technische Genauigkeit und den erforderlichen Ton.

In diesem Fall können Sie sich vorstellen, das Modell für Ihren speziellen Anwendungsfall neu zu trainieren, aber ein Modell wie GPT-3 direkt von Grund auf neu zu trainieren, um diese Nischenaufgabe zu lösen, ist aufgrund des Rechenressourcenbedarfs und der speziellen Daten nicht praktikabel.

Hier kommt die Feinabstimmung ins Spiel.

Feinabstimmung ist, als würde man GPT-3 einen neuen Trick beibringen. Dank seiner Schulung an zahlreichen Texten, von Büchern bis hin zu Websites, weiß es bereits viel über Sprachen. Ihre Aufgabe ist es, es anhand eines bestimmten Datensatzes weiterzubilden — in diesem Fall eines Korpus vorhandener technischer Handbücher und Dokumentationen, die speziell für die Elektronik entwickelt wurden.

Einige grundlegende Methoden der Feinabstimmung:

1. Einfrieren von Ebenen: Selektives Einfrieren der Gewichte bestimmter Ebenen, während andere Ebenen während des Feinabstimmungsprozesses aktualisiert werden können.
2. Anpassung der Lernrate: Anpassung der Lernrate, mit der das Modell während des Feinabstimmungsprozesses lernt, in der Regel, um zu verhindern, dass wertvolles, bereits erlerntes Wissen überschrieben wird.
3. Hinzufügen aufgabenspezifischer Ebenen: Dazu gehört die Erweiterung der Modellarchitektur um neue Ebenen, die direkt für die Aufgabe trainiert werden.

Parametereffiziente Feinabstimmung

Die parametereffiziente Feinabstimmung (PEFT) ist eine Technik, die darauf abzielt, die Anzahl zusätzlicher Parameter zu minimieren, die bei der Feinabstimmung vortrainierter neuronaler Netzwerkmodelle erforderlich sind.

Dies hilft, den Rechenaufwand und den Speicherverbrauch zu senken und gleichzeitig die Leistung beizubehalten oder sogar zu verbessern. PEFT erreicht dies, indem es Prompt-Einbettungen als zusätzliche Modellparameter hinzufügt und nur eine kleine Anzahl zusätzlicher Parameter optimiert.

PEFT erfordert im Vergleich zur herkömmlichen Feinabstimmung auch einen viel kleineren Datensatz.

Schritte zur Durchführung von PEFT

1. Das gewählte Modell wird geladen

Laden Sie Ihr ausgewähltes Modell mithilfe eines Frameworks für maschinelles Lernen wie TensorFlow, PyTorch oder der Transformers-Bibliothek von Hugging Face. Diese Frameworks bieten APIs zum einfachen Herunterladen und Laden vortrainierter Modelle.

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. Schnelles Engineering

Vor der Feinabstimmung müssen Sie mit verschiedenen Eingabeaufforderungen experimentieren, die als Richtschnur für die Antworten des Modells dienen. Testen Sie verschiedene Eingabeaufforderungen mit dem vortrainierten Modell, um zu sehen, wie sie sich auf die Ausgabe auswirken, und wählen Sie die am besten geeignete aus. Sie können auch verschiedene Parameter wie max_length, temperature usw. ändern.

Es ist, als ob Sie herausfinden, wie Sie Ihre Frage am besten stellen können, damit das Model 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

Ein Datensatz für die Feinabstimmung besteht normalerweise aus zwei Teilen: Prompt (Input) und Answer (Output). Die Aufforderung ist wie eine Frage oder ein Ausgangspunkt, und die Antwort ist das, was das Modell als Antwort auf diese Frage generieren soll. Sie kann in Form von Spalten oder einer Folge von Texteinträgen (häufiger) vorliegen.

Der beste Prompt, der im letzten Schritt identifiziert wurde, wird hier verwendet und die Antwort wird genau das sein, was das Modell produzieren soll, wenn es diesen Prompt erhält.

4. Feinabstimmung des Modells

Hier bringen Sie dem Modell bei, um Ihre Aufgabe besser zu bewältigen. Sie verwenden den Datensatz, um das „Wissen“ des Modells leicht anzupassen.

Hier finden Sie eine vereinfachte Übersicht über die Einrichtung und Ausführung des Feinabstimmungsprozesses mit PyTorch:

Vorbereitung für das Training:

 
from transformers import AdamW

optimizer = AdamW(model.parameters(), lr=5e-5)  # lr is the learning rate

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 die Feinabstimmung

Bei der Erforschung von Tools für schnelles Engineering ist es hilfreich, sie in zwei Hauptbereiche zu unterteilen: Code-Plattformen und No-Code-Plattformen. Diese Unterscheidung vereinfacht das Auswahlverfahren
Codeplattformen beziehen sich auf Plattformen, die virtuelle Maschinen bereitstellen, mit denen Sie Ihr benutzerdefiniertes Python-Skript zur Feinabstimmung wie das zuvor erwähnte ausführen können. In der Zwischenzeit beziehen sich No-Code-Plattformen auf Tools, für deren Ausführung ein einfaches oder kein Python-Skript erforderlich ist. Es hat eine spezielle Benutzeroberfläche, auf der Sie mit wenigen Klicks mit dem Training beginnen können.

Code-Plattformen:

Codeplattformen sind für Benutzer mit soliden Programmierkenntnissen konzipiert. Diese Plattformen bieten virtuelle Maschinen, auf denen benutzerdefinierte Python-Skripte für Aufgaben wie die Feinabstimmung ausgeführt werden können. Diese Plattformen eignen sich perfekt für Projekte, die eine hohe Anpassungsfähigkeit und eine komplizierte Kontrolle der Schulungs- und Bereitstellungsphasen erfordern.

1. Amazon Sagemaker:

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

Amazon SageMaker verfügt nicht über eine spezielle, integrierte „Feinabstimmung“ -Funktion, die speziell als solche 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 Feinabstimmungsaufgaben zu erledigen.

Hier ist ein einfaches Beispiel dafür, wie Sie mit Hugging Face auf SageMaker eine Feinabstimmung für ein Sprachmodell starten könnten. 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 Feinabstimmungsaufgaben 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. Bereiten Sie das Fine-Tuning-Skript vor:

Normalerweise schreiben Sie ein Feinabstimmungsskript (train.py), das Sie an den Schätzer übergeben. Dieses Skript sollte die Logik für das Laden, die Feinabstimmung und das Speichern Ihres Modells beinhalten.

 
# 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 Sie einen Umarmungsgesichtsschätzer:

 
# 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. Starte den Trainingsjob:

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

Die wichtigsten Funktionen:

1. Vorgefertigte Algorithmen und Unterstützung für beliebte Frameworks: SageMaker unterstützt TensorFlow, PyTorch, Hugging Face und andere, was die Feinabstimmung von LLMs an benutzerdefinierten Datensätzen erleichtert.
2. Managed Spot Training: Es reduziert die Kosten für Trainingsmodelle durch die Verwendung von Amazon EC2 Spot-Instances.
3. Verteiltes Training: SageMaker macht es einfacher, Modelle schneller und kostengünstiger zu trainieren, indem der Trainingsjob auf mehrere GPUs oder Instanzen verteilt wird.

2. Google Colab:

Google Colab ist ein beliebter Cloud-basierter Jupyter-Notebook-Service, der freien Zugriff auf Computerressourcen wie GPUs und TPUs bietet und damit eine hervorragende Plattform für die Feinabstimmung großer Sprachmodelle (LLMs) ist

Es ist besonders anfängerfreundlich. Colab-Notebooks werden in der Cloud direkt von Ihrem Browser aus ausgeführt, ohne dass eine lokale Einrichtung erforderlich ist.

Hier ist der einfache Codeausschnitt zur Feinabstimmung eines Transformer-Modells mit Hugging Face Transformers und PyTorch in Google Colab

1. Einrichtung 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. Feinabstimmung des Modells: (vorausgesetzt, Sie haben einen Datensatz in die Variablen input_ids, attention_masks und labels geladen)

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. Das Modell speichern:

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

Die wichtigsten Funktionen:

1. Freier Zugriff auf GPUs/TPUs: Colab bietet kostenlosen Zugriff auf NVIDIA-GPUs und Google-TPUs, was das Training und die Feinabstimmung von Modellen für maschinelles Lernen erheblich beschleunigen kann.
2. Integration mit Google Drive: Speichern Sie Ihre Datensätze und Modelle einfach und greifen Sie direkt von Google Drive aus darauf zu, was eine nahtlose Datenverwaltung und Modellspeicherung ermöglicht.
3. Vorinstallierte Bibliotheken: In Colab sind die meisten Bibliotheken für Datenwissenschaft und maschinelles Lernen vorinstalliert, darunter TensorFlow, PyTorch, Hugging Face Transformers und viele andere, sodass Sie sofort mit der Feinabstimmung von Modellen beginnen können.
4. Interaktive Umgebung: Die Notebook-Oberfläche ermöglicht interaktive Entwicklung und Dokumentation und kombiniert Live-Code, Visualisierungen und Textanmerkungen.

3. Paperspace Gradient

Paperspace Gradient ist eine Suite von Tools, die entwickelt wurden, um den Prozess der Entwicklung, Schulung und Bereitstellung von Modellen für maschinelles Lernen in der Cloud zu vereinfachen.

Gradient ist aufgrund seiner skalierbaren Infrastruktur und der Unterstützung von Containern besonders effektiv für Aufgaben wie die Feinabstimmung großer Sprachmodelle (LLMs), was es zu einer guten Wahl für Datenwissenschaftler und ML-Praktiker macht.

Hier ist ein Beispiel für die Feinabstimmung eines Transformer-Modells mit PyTorch auf Paperspace Gradient.

1. Laden eines vortrainierten 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. Vorbereitung des Datensatzes:

from transformers import TextDatasetForNextSentencePrediction

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

3. Feinabstimmung 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. Das Modell speichern:

model.save_pretrained("./my_finetuned_model")

Die wichtigsten Funktionen:

1. Vorkonfigurierte Umgebungen: Gradient bietet vorkonfigurierte Umgebungen für TensorFlow, PyTorch, Hugging Face und andere Frameworks für maschinelles Lernen und ermöglicht so eine schnelle Einrichtung für Feinabstimmungsaufgaben.
2. Leistungsstarke GPUs: Der Zugriff auf eine Vielzahl von 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 Trainingseinheiten.
3. Gradient Notebooks: Eine interaktive Programmierumgebung, die Jupyter Notebooks ähnelt, jedoch mit dem zusätzlichen Vorteil, dass sie auf der Cloud-Infrastruktur von Paperspace läuft. Dies ist ideal für die Entwicklung, Feinabstimmung und Experimentierung direkt in der Cloud.
4. Jobs und Workflows: Automatisieren Sie Ihre Machine-Learning-Pipelines, indem Sie Jobs nacheinander oder parallel ausführen und so eine effiziente Modellschulung und -bereitstellung ermöglichen.

4. Run.ai

Run.AI ist eine Plattform, die entwickelt wurde, um GPU-Ressourcen für maschinelles Lernen zu optimieren und es Datenwissenschaftlern und KI-Forschern zu erleichtern, komplexe KI-Modelle auszuführen und zu verwalten, einschließlich der Feinabstimmung großer Sprachmodelle (LLMs).

Es basiert auf Kubernetes, einem Tool, das Computerressourcen effizient organisiert. Es erleichtert also die Durchführung komplexer KI-Projekte und ermöglicht Teams, ihre Projekte reibungslos auszubauen.

Detaillierte Einblicke finden Sie in der Dokumentation zu Run.AI. Hier ist ein vereinfachtes Beispiel, das auf dem allgemeinen Arbeitsablauf zur Feinabstimmung eines Modells wie LLama-2 auf der Plattform Run.AI basiert.

1. Vorbereitung Ihrer Umgebung

2. Einrichten Ihrer Projekt- und GPU-Anfragen

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

3. Das Feinabstimmungsskript schreiben

Ihr train.py Skript sollte die Logik für das Laden von LLama-2 (oder das von Ihnen gewählte Modell), Ihren Datensatz und die Ausführung des Feinabstimmungsprozesses enthalten. Dies könnte die Verwendung von Bibliotheken wie Hugging Face Transformers zum Laden von Modellen und TensorFlow oder PyTorch für die Trainingsschleife beinhalten.

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. Überwachung und Verwaltung des Schulungsauftrags

Run.AI bietet Tools, mit denen Sie die GPU-Nutzung und den Fortschritt Ihrer Trainingsjobs überwachen und Rechenressourcen effektiv verwalten können. Verwenden Sie das Dashboard oder die CLI von Run.AI, um den Status und die Leistung Ihres Jobs im Auge zu behalten.

Runai listet Jobs auf

Dieser Befehl listet alle aktuellen Jobs auf, sodass Sie den Fortschritt und den Ressourcenverbrauch Ihrer Feinabstimmungsaufgabe überwachen können.

Die wichtigsten Funktionen:

1. GPU-Optimierung und elastische GPU-Zuweisung: Optimiert automatisch die GPU-Nutzung, verbessert die Effizienz und weist GPU-Ressourcen dynamisch auf der Grundlage der Workload-Anforderungen zu, wodurch die Kosten erheblich gesenkt werden.
2. Vereinfachtes Ressourcenmanagement: Bietet ein intuitives Dashboard und eine CLI für die Verwaltung von KI-Workloads, sodass die Ressourcennutzung einfach in Echtzeit überwacht und angepasst werden kann.
3. Integration mit beliebten Frameworks: Unterstützt beliebte Frameworks für maschinelles Lernen wie TensorFlow, PyTorch und Hugging Face Transformers und ermöglicht so eine nahtlose Integration in bestehende Workflows.

Plattformen ohne Code:

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

1. Öffnen Sie die AI-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 ihre Fähigkeit, Modelle anhand benutzerdefinierter Datensätze zu optimieren.

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

Da ich mich auf die API beziehe, handelt es sich nicht gerade um „No-Code“, dennoch kann man sie im Vergleich zu anderen Tools im vorherigen Abschnitt problemlos für das Training einrichten.

Beispielcode für die Feinabstimmung:

1. Vorbereitung Ihres Datensatzes

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

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

2. Laden Sie Ihren Datensatz auf OpenAI hoch

Sie können den Datensatz einfach mit Open AI CLI (Command Line Interface) hochladen.

openai tools fine_tunes.prepare_data -f your_dataset.jsonl

3. Feinabstimmung des Modells

Sobald Ihr Datensatz vorbereitet und hochgeladen ist, können Sie einen Feinabstimmungsprozess einleiten. Das Folgende ist ein Beispiel, das die Python-Bibliothek von OpenAI verwendet:

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. Verwenden Sie Ihr fein abgestimmtes Modell

Nach Abschluss des Feinabstimmungsprozesses können Sie Ihr fein abgestimmtes Modell zum Generieren von Text oder für andere Aufgaben verwenden, indem Sie die ID des fein abgestimmten 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 fein abgestimmtes Modell auch bereitstellen.

Die wichtigsten Funktionen:

• Benutzerfreundlichkeit: Die API vereinfacht die Interaktion mit leistungsstarken KI-Modellen und macht die Komplexität der direkten Verwaltung oder des Trainings großer neuronaler Netzwerke überflüssig.
• Skalierbarkeit: OpenAI kümmert sich um die Infrastruktur und Skalierung und bietet unabhängig von der Arbeitslast eine konsistente Leistung.
• Kontinuierliche Updates: OpenAI aktualisiert regelmäßig seine API und Modelle, sodass Benutzer auf die neuesten Fortschritte in der KI-Forschung zugreifen können.

2. Microsoft Azure

Microsoft Azure ist eine Cloud-Computing-Plattform, die eine breite Palette von Diensten anbietet, darunter Computer, Speicher, Analysen und mehr. Es bietet Benutzern die Tools, mit denen sie Anwendungen effizient erstellen, bereitstellen und verwalten können.

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

Hier finden Sie eine einfache Anleitung zum Einrichten eines „Jobs“ zur Feinabstimmung in Azure:

1. Vorbereitung Ihrer Daten:

Offensichtlich ist dies die Grundvoraussetzung 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 optimieren möchten.

Für die Textklassifizierung:
Zwei Spalten: Satz (Zeichenfolge) und Label (Ganzzahl/Zeichenfolge)

2. Wählen Sie ein Fundamentmodell

3. Konfigurieren Sie einen Feinabstimmungsjob:

Nachdem Sie den Feinabstimmungsauftrag eingereicht haben, wird ein Pipeline-Job erstellt, um Ihr Modell zu trainieren. Sie können alle Eingaben überprüfen und das Modell anhand der Job-Ausgaben zusammenstellen.

4. Evaluieren Sie Ihr fein abgestimmtes Modell

Um zu entscheiden, ob Ihr fein abgestimmtes Modell die erwartete Leistung erbringt, können Sie die Trainings- und Bewertungsmetriken überprüfen.

Die wichtigsten Funktionen:

• Benutzerfreundliche Oberfläche: Die benutzerfreundliche Oberfläche von Azure vereinfacht die Navigation für Anfänger.
• No-Code-Optionen: Für die Feinabstimmung ist kein umfangreiches Programmieren erforderlich; Benutzer können Aufgaben mit einfachen Klicks erledigen.
• Skalierbarkeit: Anwendungen können einfach nach oben oder unten skaliert werden, um wechselnden Anforderungen gerecht zu werden.
• Umfassende Dienste: Azure bietet eine Reihe von Tools zur Feinabstimmung, darunter Analyse- und Überwachungsfunktionen.
• Integration: Lässt sich nahtlos in Tools von Microsoft und Drittanbietern integrieren, um flexible Arbeitsabläufe zu gewährleisten.

3. Replizieren

Replicate ist ein vielseitiges Tool, das für die Feinabstimmung verschiedener Aspekte von Softwareanwendungen entwickelt wurde. Zu den Anwendungen von Replicate als Tool zur Feinabstimmung gehören die Optimierung der Leistung, die Anpassung von Konfigurationen und die Erweiterung der Funktionalität mit minimalem Aufwand. Es vereinfacht den Prozess, indem es die GPU-Setup übernimmt. Ähnlich wie bei der Open AI API ist es nicht gerade „No-Code“ wie andere Tools in der Liste, dennoch kann man es im Vergleich zu anderen Tools im vorherigen Abschnitt leicht für das Training einrichten.

Schritte zur Feinabstimmung von llama-2b:

1. Bereite deine Trainingsdaten vor

Deine Trainingsdaten müssen in einem JSONL-Format vorliegen. Im Folgenden finden Sie ein Beispiel dafür, wie Sie diese Datei strukturieren könnten:

{"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. Authentifizieren Sie sich mit Replicate

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

export REPLICATE_API_TOKEN=

3. Lade deine Trainingsdaten hoch

Sie können Ihre Daten mit curl-Befehlen in einen s3-Bucket oder direkt bei Replicate hochladen:

RESPONSE=$(curl -s -X POST -H "Authorization: Bearer $REPLICATE_API_TOKEN" https://dreambooth-api-experimental.replicate.com/v1/upload/data.jsonl)

curl -X PUT -H "Content-Type: application/jsonl" --upload-file data.jsonl "$(jq -r ".upload_url" <<< "$RESPONSE")"

SERVING_URL=$(jq -r ".serving_url" <<< $RESPONSE)
echo $SERVING_URL

4. Erstellen Sie ein Modell beim Replizieren

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

5. Einen Trainingsjob erstellen

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 fein abgestimmtes Modell aus

Nach Abschluss des Trainings 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)

Die wichtigsten Funktionen:

• Benutzerfreundlichkeit: Vereinfacht den Feinabstimmungsprozess mit einer benutzerfreundlichen Oberfläche und einer unkomplizierten API, sodass er sowohl Anfängern als auch erfahrenen Praktikern zugänglich ist.
• Cloud-basiertes Training: Es macht lokale GPU-Ressourcen überflüssig, da Cloud-basierte Schulungen angeboten werden, sodass Benutzer Modelle unabhängig von ihrer Hardware trainieren können.
• Flexible Dateneingabe: Unterstützt das JSONL-Format für Trainingsdaten und ermöglicht so eine flexible und strukturierte Eingabe für eine Vielzahl von Aufgaben.
• Modellhosting: Hostet automatisch fein abgestimmte Modelle und ermöglicht so die einfache Integration und Bereitstellung von KI-Modellen in Anwendungen.
• Versionskontrolle: Behält den Überblick über verschiedene Trainingsversionen und erleichtert so die Verwaltung, den Vergleich und die Wiederherstellung früherer Versionen eines Modells.

4. Google Gen AI Studio

Bei Gen AI Studio haben Sie beide Möglichkeiten, Feinabstimmungsjobs über die API oder die Website einzurichten. Hier werde ich nur auf die API-Methode eingehen. Im Vergleich zu den oben beschriebenen Tools hat es den optimalsten Prozess.

Hier ist eine schrittweise Anleitung:

1. Bereite deinen Datensatz vor

Ihr Datensatz sollte im JSONL-Format vorliegen, wobei jede Zeile ein JSON-Objekt mit den Schlüsseln „input_text“ und „output_text“ ist. Das Training kann mit nur 10 Beispielen beginnen, es werden jedoch mindestens 100 Beispiele empfohlen.

2. Laden Sie Ihren Datensatz hoch

Sie müssen Ihren Datensatz in den 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 Anmeldeinformationen 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. Bereite die Tuning-Funktion vor

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. Model-Tuning durchführen

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

model_display_name = "your-model-name"
training_data = "gs://your-bucket/your-dataset.jsonl" # or your DataFrame
train_steps = 300 # Number of training steps

# Call the tuning function
tuned_model = tuning(project_id, location, model_display_name, training_data, train_steps)

Die wichtigsten Funktionen:

1. Bereitstellung sowohl für den API-Zugriff als auch für die 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 verarbeiten.
3. Integration mit Google Cloud-Diensten: Nahtlose Integration mit anderen Google Cloud-Diensten wie Cloud Storage für die Datensatzverwaltung und Vertex AI für die Bereitstellung von Modellen.
4. Große Auswahl an vortrainierten Modellen: Greifen Sie auf eine Vielzahl von vortrainierten Modellen zu, die für verschiedene Aufgaben und Sprachen geeignet sind und einen soliden Ausgangspunkt für die Feinabstimmung bieten.
5. Zusammenarbeit und Versionskontrolle: Funktionen zur Zusammenarbeit mit Teammitgliedern, zur gemeinsamen Nutzung von Feinabstimmungsprojekten und zur Aufrechterhaltung der Versionskontrolle für fein abgestimmte Modelle.

5. Präbasis

Predibase ist eine spezialisierte Plattform, die entwickelt wurde, um die Feinabstimmung großer Sprachmodelle (LLMs) wie GPT-4 für bestimmte Aufgaben oder Anwendungen zu erleichtern. Sie bietet Zugriff auf die erweiterten Funktionen von LLMs, indem sie eine optimierte, benutzerfreundliche Umgebung für die Anpassung dieser Modelle an individuelle Bedürfnisse bietet.

Predibase bietet Ihnen die Möglichkeit, sowohl das Python-SDK als auch die Benutzeroberfläche für die Durchführung von Feinabstimmungsaufgaben zu verwenden.

Hier ist eine schrittweise Anleitung zur Feinabstimmung von mistral-7b-instruct:

1. Grundlegende Einrichtung

Eröffnen Sie zunächst ein Konto bei Predibase und zahlen Sie ein, um Guthaben hinzuzufügen. Generieren Sie anschließend Ihren API-Schlüssel.

2. Modell-Repository erstellen

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

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

3. Fangen Sie mit der Feinabstimmung an:

Füllen Sie die markierten Bereiche aus und drücken Sie dann Zug. Dadurch wird Ihre Anfrage in eine Warteschlange gestellt, bis ein Rechenleistung verfügbar ist.

6. Wahre Gießerei

TrueFoundry ist ein Tool, das ML-Teams dabei hilft, ihre Modelle reibungslos zum Laufen zu bringen. Es basiert auf Kubernetes, was bedeutet, dass es in verschiedenen Clouds oder sogar auf Ihren eigenen Servern ausgeführt werden kann. Dies ist wichtig für Unternehmen, die sich Sorgen um die Sicherheit ihrer Daten und die Kostenkontrolle machen

Für die Feinabstimmung ist es eines der besten Tools auf dem Markt und richtet sich sowohl an Anfänger als auch an Experten. Hier haben Sie zwei Möglichkeiten: Sie können ein Notizbuch zur Feinabstimmung zum Experimentieren bereitstellen oder eine spezielle Feinabstimmungsaufgabe starten.

1. Notizbücher: Experimentierspielplatz

Notebooks bieten ein ideales Setup für explorative und iterative Feinabstimmungen. 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 die optimalen Hyperparameter und Konfigurationen durch Experimente identifiziert haben, hilft Ihnen der Übergang zu einem Bereitstellungsjob bei der Feinabstimmung des gesamten Datensatzes und ermöglicht ein schnelles und zuverlässiges Training.

Daher werden Notebooks für Explorationsarbeiten in der Anfangsphase dringend empfohlen, und Hyperparameter-Tuning- und Bereitstellungsaufgaben sind die bevorzugte Wahl für groß angelegte LLM-Feinabstimmungen, insbesondere wenn die optimale Konfiguration durch vorherige Experimente ermittelt wurde.

Hier finden Sie eine schrittweise Anleitung zur Feinabstimmung mit Notebook und Jobs:

1. Einrichtung der Trainingsdaten

Truefoundry unterstützt zwei verschiedene Datenformate:

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

Jede Zeile enthält einen Schlüssel namens Nachrichten. Jeder Nachrichtenschlüssel enthält eine Liste von Nachrichten, wobei jede Nachricht ein Wörterbuch mit Rollen- und Inhaltsschlüsseln ist. Der Rollenschlüssel kann entweder Benutzer, Assistent oder System sein, und der Inhaltsschlüssel enthält den Nachrichteninhalt.

2. Vervollständigung: Die Daten müssen im JSONL-Format vorliegen, wobei jede Zeile eine JSON-kodierte Zeichenfolge enthält, die zwei Schlüssel prompt und completion enthält.

{"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. Feinabstimmung

Mit nur drei Klicks können Sie mit der Feinabstimmung beginnen:

1. Wähle den Workspace aus, in dem du arbeiten möchtest
2. Wählen Sie ein Modell:

Sie können das Modell aus der umfangreichen Liste auswählen oder einfach die Huggingface-URL einfügen, um mit der Feinabstimmung zu beginnen.

3. Klicken Sie auf Weiter

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

3. Feinabstimmung mit einem Notizbuch

Nachdem Sie 'Als Notizbuch starten' ausgewählt und Standardwerte für Hyperparameter ausgewählt haben, können Sie Ihr Notizbuch sehen:

4. Feinabstimmung als Beruf:

Bevor Sie beginnen, müssen Sie zunächst ein ML-Repo erstellen (dieses wird verwendet, um Ihre Trainingsmetriken und Artefakte wie Ihre Checkpoints und Modelle zu speichern) und Ihrem Workspace Zugriff auf das ML-Repo gewähren. Weitere Informationen zu ML Repos finden Sie in der Dokumentation von Truefoundry.

Jetzt müssen Sie 'Launch as Job' wählen und Standardwerte für Hyperparameter auswählen, um die Feinabstimmung zu initiieren.

In den Bereitstellungen können Sie den Job in der Liste sehen und auf Job ausführen klicken.

Die wichtigsten Funktionen:

• Unterstützung für beliebte LLMs: Ermöglicht die Feinabstimmung von weit verbreiteten Open-Source-LLMs wie Llama 2, Mistral, Zephyr und Mixtral.
• Flexibler Feinabstimmungsansatz: Bietet die Möglichkeit, LLMs mithilfe von Jobs für Skalierbarkeit und Zuverlässigkeit oder Notebooks für Experimente und iteratives Tuning zu verfeinern.
• QLORA-Technik: Nutzt die QLORA-Feinabstimmungstechnik, die Effizienz und Leistung in Einklang bringt und die Feinabstimmung auf weniger leistungsfähiger Hardware ermöglicht, ohne die Qualität zu beeinträchtigen.
• Unterstützung von Datenformaten: Unterstützt Daten im JSONL-Format und berücksichtigt sowohl Datensätze vom Typ Chat als auch Abschluss und ermöglicht so eine Reihe von LLM-Anwendungen.
• Einfache Datenintegration: Bietet Optionen zum Hochladen von Trainingsdaten als TrueFoundry-Artefakt, auf Cloud-Speicherdienste oder lokal, was Flexibilität bei der Datenverwaltung bietet.
• Unterstützung bei der Implementierung: Nach der Feinabstimmung sind Anleitungen zur Bereitstellung des fein abgestimmten Modells für die praktische Anwendung verfügbar, wodurch der Nutzen des Modells verbessert wird.
• ML-Repository-Integration: Ermöglicht die Verfolgung des Fortschritts bei der Feinabstimmung und die Verwaltung von Trainingsmetriken/Artefakten über ML-Repositorys, wodurch eine organisierte und zugängliche Modellentwicklung gewährleistet wird.

Wählen Sie das richtige Tool für Sie:

Einfache Bedienung: Wählen Sie Tools aus, die einfach zu handhaben sind, insbesondere wenn Sie sich nicht mit Programmieren auskennen. Bei einigen Tools müssen Sie nicht einmal Code schreiben!

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

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

Rechenressourcen: Suchen Sie nach Zugriff auf GPUs oder TPUs, wenn Ihr Projekt viel Rechenleistung benötigt.

Kosten: Überlegen Sie, wie viel Sie bereit sind auszugeben. Einige Tools sind kostenlos, andere richten sich nach den von Ihnen verwendeten Ressourcen.

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

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

Community und Support: Eine unterstützende Community und eine gute Dokumentation können Ihnen viele Kopfschmerzen ersparen.