Top 6 Fine-Tuning Tools voor Model Training in 2026

Introductie

Fine-tuning is een techniek binnen machine learning, met name deep learning, waarbij een pre-trained model verder wordt getraind of "afgestemd" op een kleinere, specifieke dataset die is afgestemd op een bepaalde taak. 

Stel dat je een model ontwikkelt dat technische handleidingen voor elektronica genereert met behulp van GPT-3 (een groot taalmodel met 175 miljard parameters), maar de generieke output van GPT-3 voldoet niet aan de vereiste technische nauwkeurigheid en toon.

In dit geval kun je erover nadenken om het model opnieuw te trainen voor jouw specifieke use case. Maar een model zoals GPT-3 direct vanaf nul trainen om deze niche-taak aan te pakken is onpraktisch vanwege de benodigde rekenkracht en gespecialiseerde data. 

Dit is waar fine-tuning om de hoek komt kijken.

Fine-tuning is zoals het aanleren van een nieuw kunstje aan GPT-3. Het weet al heel veel over talen dankzij de training op talloze teksten, van boeken tot websites. Het is jouw taak om het verder te trainen op een doelgerichte dataset—in dit geval een corpus van bestaande technische handleidingen en documentatie specifiek voor elektronica.

Enkele basismethoden voor fine-tuning:

1. Layer Freezing: Het selectief bevriezen van de weights van bepaalde lagen, terwijl andere lagen tijdens het fine-tuningproces mogen updaten.
2. Learning Rate Adjustment: Het aanpassen van de snelheid waarmee het model leert tijdens het fine-tuningproces, typisch om te voorkomen dat waardevolle vooraf geleerde kennis wordt overschreven.
3. Adding Task-Specific Layers: Dit houdt in dat de modelarchitectuur wordt uitgebreid met nieuwe lagen die rechtstreeks voor de specifieke taak worden getraind.

‍

Parameter Efficient Fine Tuning

Parameter Efficient Fine-tuning (PEFT) is een techniek die erop gericht is het aantal extra parameters dat nodig is tijdens het fine-tunen van pre-trained neurale netwerkmodellen te minimaliseren.

Dit helpt de berekeningskosten en het geheugengebruik terug te dringen, terwijl de prestaties behouden blijven of zelfs verbeteren. PEFT bereikt dit door prompt embeddings toe te voegen als extra modelparameters en slechts een klein aantal extra parameters te tunen. 

PEFT vereist ook een veel kleinere dataset in vergelijking met traditionele fine-tuning.

‍

Stappen om PEFT uit te voeren

1. Het gekozen model laden

Laad het door jou gekozen model met behulp van een machine learning framework zoals TensorFlow, PyTorch of Hugging Face's Transformers-bibliotheek. Deze frameworks bieden API's om pre-trained modellen eenvoudig te downloaden en te laden.

Hier is een voorbeeldcode:

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

Vóór het fine-tunen moet je experimenteren met verschillende prompts om de reacties van het model te sturen. Test verschillende prompts met het pre-trained model om te zien hoe ze de output beïnvloeden en kies de meest geschikte. Je kunt ook verschillende parameters aanpassen, zoals max_length, temperature, enz.

Het is te vergelijken met het zoeken naar de beste manier om je vraag te stellen, zodat het model begrijpt wat je wilt.

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. Dataset

In een dataset voor fine-tuning zijn er doorgaans twee onderdelen: Prompt (Input) en Answer (Output). De Prompt is als een vraag of een startpunt, en de Answer is wat je wilt dat het model genereert als antwoord op die vraag. Dit kan de vorm hebben van kolommen of een reeks tekstinvoer (wat vaker voorkomt).

De beste prompt die in de vorige stap is geïdentificeerd, wordt hier gebruikt en de Answer zal precies zijn wat we willen dat het model produceert wanneer het die Prompt krijgt. 

4. Het model fine-tunen

Dit is waar je het model leert om beter te worden in jouw taak. Je gebruikt de dataset om de "kennis" van het model lichtjes aan te passen. 

Hier is een vereenvoudigd overzicht van het opzetten en uitvoeren van het fine-tuning process met PyTorch:

• Instellen voor training:

from transformers import AdamW

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

• Training Loop:

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 voor Fine-Tuning

Bij het verkennen van tools voor prompt engineering is het handig om ze in te delen in twee hoofddomeinen: Code Platforms en No-Code Platforms. Deze indeling vereenvoudigt het selectieproces.
Code Platforms verwijzen naar platforms die virtuele machines bieden die kunnen worden gebruikt om je eigen aangepaste Python-script voor fine-tuning uit te voeren, zoals de eerder genoemde. No-Code Platforms verwijzen daarentegen naar tools die minimale of geen Python-scripts vereisen om te draaien. Ze beschikken over een dedicated UI waar je de training met een paar kliks kunt starten.

No-Code Platforms:

No-code platforms zijn daarentegen afgestemd op eenvoud en gebruiksgemak. Ze nemen de noodzaak weg om Python-scripts te schrijven en bieden een intuïtieve UI waar de training met slechts enkele kliks kan worden gestart. Dit domein is geschikt voor gebruikers zonder programmeerkennis of voor degenen die de voorkeur geven aan een eenvoudige benadering van prompt engineering.

1. TrueFoundry

TrueFoundry is een tool die ML-teams helpt hun modellen soepel te laten draaien. Het is gebouwd op Kubernetes, wat betekent dat het kan draaien op verschillende clouds of zelfs op je eigen servers. Dit is belangrijk voor bedrijven die zich zorgen maken over databeveiliging en kostenbeheersing.

Voor Fine-tuning is het een van de beste tools die er zijn, geschikt voor zowel beginners als experts. Hier heb je twee opties: het deployen van een fine-tuning notebook voor experimenten of het starten van een dedicated fine-tuning job.

1. Notebooks: Playground voor experimenten

Notebooks bieden een ideale omgeving voor verkennende en iteratieve fine-tuning. Je kunt experimenteren op een kleine subset van data en verschillende hyperparameters uitproberen om de ideale configuratie voor de beste prestaties te bepalen.

2. Jobs: Betrouwbaar en schaalbaar

Zodra je de optimale hyperparameters en configuratie via experimenten hebt geïdentificeerd, helpt de overstap naar een deployment job je bij het fine-tunen op de volledige dataset en vergemakkelijkt het snelle en betrouwbare training.

Daarom worden notebooks sterk aanbevolen voor verkenning in een vroeg stadium en hyperparameter tuning, terwijl deployment jobs de voorkeur genieten voor grootschalige LLM finetuning, vooral wanneer de optimale configuratie is vastgesteld via eerdere experimenten.

Hier is een stapsgewijze handleiding om te fine-tunen met zowel Notebooks als Jobs:

1. Het instellen van de trainingsdata

Truefoundry ondersteunt twee verschillende dataformaten:

1. Chat: Data moet in JSONL-formaat zijn waarbij elke regel een heel gesprek bevat in het OpenAI Chat-formaat

Elke regel bevat een key genaamd messages. Elke message key bevat een lijst met berichten, waarbij elk bericht een dictionary is met role- en content-keys. De role-key kan user, assistant of system zijn en de content-key bevat de inhoud van het bericht.

2. Completion: Data moet in JSONL-formaat zijn waarbij elke regel een JSON-gecodeerde string bevat met twee keys: prompt en completion.

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

Je kunt beginnen met fine-tunen met slechts drie kliks:

1. Selecteer de workspace waarin je wilt werken
2. Kies het model:

Je kunt een model kiezen uit de uitgebreide lijst die aanwezig is of simpelweg de Hugging Face URL plakken om te beginnen met fine-tunen.

3. Klik op Next

Nadat je de gewenste GPU hebt geselecteerd, heb je twee opties: Run as notebook of Job.

3. Fine-Tuning met een Notebook

Na het kiezen van ‘Launch as Notebook’ en het selecteren van standaardwaarden voor hyperparameters, kun je je notebook bekijken:

4. Fine-Tuning als Job:

Voordat je begint, moet je eerst een ML Repo aanmaken (dit wordt gebruikt om je trainingsstatistieken en artifacts op te slaan, zoals je checkpoints en modellen) en je workspace toegang geven tot de ML Repo. Je kunt meer lezen over ML Repo's in de documentatie van TrueFoundry.

Nu kies je ‘Launch as Job’ en selecteer je de standaardwaarden voor hyperparameters om het fine-tunen te starten.

Onder deployments zie je de job vermeld staan en kun je op run job klikken.

Belangrijkste functies:

• Ondersteuning voor populaire LLM's: Maakt fine-tuning mogelijk van veelgebruikte open-source LLM's zoals Llama 2, Mistral, Zephyr en Mixtral.
• Flexibiliteit in Fine-Tuning aanpak: Biedt de optie om LLM's te fine-tunen met behulp van Jobs voor schaalbaarheid en betrouwbaarheid, of Notebooks voor experimenten en iteratieve tuning.
• QLoRA-techniek: Maakt gebruik van de QLoRA fine-tuning techniek, die efficiëntie balanceert met prestaties, waardoor fine-tuning op minder krachtige hardware mogelijk is zonder in te boeten aan kwaliteit.
• Dataformaat ondersteuning: Ondersteunt data in jsonl-formaat voor zowel chat- als completion-type datasets, wat een scala aan LLM-toepassingen vergemakkelijkt.
• Eenvoudige data-integratie: Biedt opties om trainingsdata te uploaden als een TrueFoundry artifact, naar cloudopslagdiensten of lokaal, wat flexibiliteit biedt in databeheer.
• Deployment ondersteuning: Biedt na de fine-tuning handleidingen voor het deployen van het gefine-tunede model voor praktische toepassingen, wat het nut van het model vergroot.
• ML Repository integratie: Maakt het mogelijk om de voortgang van fine-tuning te volgen en trainingsstatistieken/artifacts te beheren via ML Repositories, wat zorgt voor een georganiseerde en toegankelijke modelontwikkeling.

2. OpenAI API

De OpenAI API biedt toegang tot geavanceerde kunstmatige intelligentiemodellen ontwikkeld door OpenAI, waaronder de nieuwste versies van GPT (Generative Pre-trained Transformer). Een van de opvallendste functies van de OpenAI API is de mogelijkheid om modellen te fine-tunen op aangepaste datasets.

Zo kun je het gedrag van modellen zoals GPT-3 of nieuwere versies afstemmen op specifieke toepassingen of laten voldoen aan specifieke inhoudsstijlen en -voorkeuren.

Omdat ik verwijs naar de API, is het niet helemaal ‘No-Code’, maar men kan het nog steeds eenvoudig instellen voor training in vergelijking met andere tools uit de vorige sectie.

Voorbeeldcode voor Fine-Tuning:

‍

1. Je dataset voorbereiden

Om een model te fine-tunen, moet je eerst je dataset voorbereiden in een formaat dat de OpenAI API begrijpt. In de regel moet je een JSON-bestand maken dat er als volgt uitziet:

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

2. Je dataset uploaden naar OpenAI

Je kunt de dataset eenvoudig uploaden met behulp van de OpenAI CLI (Command Line Interface). 

openai tools fine_tunes.prepare_data -f your_dataset.jsonl

3. Het model fine-tunen

Zodra je dataset is voorbereid en geüpload, kun je een fine-tuningproces starten. Het volgende is een voorbeeld met behulp van de Python-bibliotheek van 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. Je gefine-tunede model gebruiken

Nadat het fine-tuningproces is voltooid, kun je je gefine-tunede model gebruiken voor het genereren van tekst of andere taken door het ID van het gefine-tunede model op te geven:

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

Je kunt je gefine-tunede model ook deployen.

Belangrijkste functies:

• Gebruiksgemak: De API vereenvoudigt de interactie met krachtige AI-modellen en neemt de complexiteit van het rechtstreeks beheren of trainen van grote neurale netwerken weg.
• Schaalbaarheid: OpenAI beheert de infrastructuur en het schalen, wat zorgt voor consistente prestaties ongeacht de werklast.
• Voortdurende updates: OpenAI update regelmatig de API en modellen, waardoor gebruikers toegang krijgen tot de nieuwste vorderingen in AI-onderzoek.

3. Microsoft Azure

Microsoft Azure is een cloud computing-platform dat een breed scala aan diensten biedt, waaronder computing, opslag, analytics en meer. Het biedt gebruikers de tools om toepassingen efficiënt te bouwen, deployen en beheren. 

Een opmerkelijke functie is de intuïtieve interface, waardoor beginners er gemakkelijk doorheen kunnen navigeren zonder diepgaande kennis van coderen. Met eenvoudige kliks in plaats van complexe code kunnen gebruikers hun toepassingen fine-tunen, wat Azure een toegankelijke tool maakt voor zorgeloze ontwikkeling.

Hier is een eenvoudige handleiding voor het instellen van een fine-tuning ‘job’ in Azure:

1. Je data voorbereiden:

Uiteraard is dit de basisvereiste voor alle tools. De trainingsdata kan de indeling JSON Lines (JSONL), CSV of TSV hebben. De vereisten voor je data variëren afhankelijk van de specifieke taak waarvoor je het model wilt fine-tunen.

Voor tekstclassificatie:
Twee kolommen: Sentence (string) en Label (integer/string)

2. Kies een foundation model

3. Configureer een fine-tuning job: 

Nadat je de fine-tuning job hebt ingediend, wordt er een pipeline job aangemaakt om je model te trainen. Je kunt alle inputs controleren en het model ophalen uit de job-outputs.

4. Evalueer je gefine-tunede model

Om te bepalen of je gefine-tunede model naar behoren presteert, kun je de trainings- en evaluatiestatistieken bekijken.

Belangrijkste functies:

• Gebruikersvriendelijke interface: De eenvoudig te gebruiken interface van Azure vereenvoudigt de navigatie voor beginners.
• No-Code opties: Fine-tuning vereist geen uitgebreide code; gebruikers kunnen taken voltooien met eenvoudige kliks.
• Schaalbaarheid: Toepassingen kunnen eenvoudig worden opgeschaald of afgeschaald om aan veranderende eisen te voldoen.
• Uitgebreide diensten: Azure biedt een reeks tools voor fine-tuning, waaronder functies voor analytics en monitoring.
• Integratie: Integreert naadloos met Microsoft- en third-party tools voor flexibiliteit in workflows.

4. Replicate

Replicate is een veelzijdige tool ontworpen voor het fine-tunen van verschillende aspecten van softwaretoepassingen. De toepassingen van Replicate als fine-tuning tool omvatten het optimaliseren van prestaties, het aanpassen van configuraties en het verbeteren van functionaliteit met minimale inspanning. Het vereenvoudigt het proces door de GPU-setup af te handelen. Net als bij de OpenAI API is het niet precies ‘No-Code’ zoals andere tools in de lijst, maar toch kan men het gemakkelijk instellen voor training in vergelijking met andere tools in de vorige sectie.

Stappen om llama-2b te fine-tunen:

1. Bereid je trainingsdata voor

Je trainingsdata moet in JSONL-formaat zijn. Hieronder staat een voorbeeld van hoe je dit bestand kunt structureren:

{"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. Authenticeren bij Replicate

Je moet je Replicate API-token instellen als een omgevingsvariabele in je terminal:

export REPLICATE_API_TOKEN=<your-token-here>

3. Upload je trainingsdata

Je kunt je data uploaden naar een S3 bucket of rechtstreeks bij Replicate met behulp van curl-opdrachten:

4. Maak een model aan op Replicate

Je moet een leeg model aanmaken op Replicate voor je getrainde model. Wanneer je training is voltooid, wordt deze als een nieuwe versie naar dit model gepusht.

5. Maak een training job aan

Je moet een training job aanmaken in je IDE, zoals hieronder weergegeven:

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. Monitor de trainingsvoortgang

Om de voortgang programmatisch te monitoren, kun je het volgende gebruiken:

training.reload()
print(training.status)

7. Voer je gefine-tunede model uit

Nadat de training is voltooid, kun je je model uitvoeren met de API:

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

print(output)

Belangrijkste functies:

• Gebruiksgemak: Vereenvoudigt het fine-tuningproces met een gebruikersvriendelijke interface en eenvoudige API, waardoor het toegankelijk is voor zowel beginners als ervaren gebruikers.
• Cloud-based training: Neemt de noodzaak voor lokale GPU-resources weg door cloud-based training aan te bieden, waardoor gebruikers modellen kunnen trainen ongeacht hun hardware.
• Flexibele datainvoer: Ondersteunt het JSONL-formaat voor trainingsdata, wat zorgt voor flexibele en gestructureerde invoer voor uiteenlopende taken.
• Model Hosting: Host gefine-tunede modellen automatisch, wat een eenvoudige integratie en deployment van AI-modellen in toepassingen mogelijk maakt.
• Versiebeheer: Houdt verschillende trainingsversies bij, waardoor het eenvoudig is om eerdere versies van een model te beheren, te vergelijken en te herstellen.

‍

5. Google Gen AI Studio

Bij Gen AI Studio heb je beide opties voor het instellen van fine-tuning jobs: via de API of de website. Hier zal ik het alleen over de API-methode hebben. Het heeft het meest gestroomlijnde proces in vergelijking met de hierboven besproken tools.

Hier is een stapsgewijze handleiding:

1. Bereid je dataset voor

Je dataset moet in JSONL-formaat zijn, waarbij elke regel een JSON-object is met de keys "input_text" en "output_text". De training kan al beginnen met slechts 10 voorbeelden, maar minstens 100 voorbeelden worden aanbevolen.

2. Upload je dataset

Je moet je dataset uploaden naar een Google Cloud Storage (GCS) bucket; als je er geen hebt, kun je er een aanmaken in Google Drive.

3. Authenticatie en initialisatie

Nu moet je je credentials opgeven om de verbinding tot stand te brengen:

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. Bereid de tuning-functie voor

Je moet een functie voor tuning definiëren met de benodigde parameters.

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. Voer de model tuning uit

Roep de eerder opgegeven tuning-functie aan met jouw specifieke parameters. De parameter training_data kan een GCS URI of een pandas DataFrame zijn.

Belangrijkste functies:

1. Voorziening voor zowel API-toegang als gebruikersinterface: Voor degenen die de voorkeur geven aan een grafische benadering biedt Gen AI Studio een intuïtieve gebruikersinterface.
2. Schaalbare infrastructuur: Maak gebruik van de schaalbare infrastructuur van Google Cloud om grote datasets en rekenintensieve tuning jobs efficiënt af te handelen.
3. Integratie met Google Cloud Services: Naadloze integratie met andere Google Cloud-diensten, zoals Cloud Storage voor databeheer en Vertex AI voor het deployen van modellen.
4. Breed scala aan pre-trained modellen: Toegang tot een verscheidenheid aan pre-trained modellen die geschikt zijn voor verschillende taken en talen, wat een stevig startpunt biedt voor fine-tuning.
5. Samenwerking en versiebeheer: Mogelijkheden om samen te werken met teamleden, fine-tuning projecten te delen en versiebeheer te behouden over gefine-tunede modellen.

6. Predibase

Predibase is een gespecialiseerd platform ontworpen om het fine-tunen van grote taalmodellen (LLM's), zoals GPT-4, te vergemakkelijken voor specifieke taken of toepassingen. Het biedt toegang tot de geavanceerde mogelijkheden van LLM's door een gestroomlijnde, gebruikersvriendelijke omgeving te bieden voor het aanpassen van deze modellen aan individuele behoeften.

Predibase geeft je de optie van zowel de Python SDK als een UI voor het uitvoeren van fine-tuning jobs.

Hier is een stapsgewijze handleiding om mistral-7b-instruct te fine-tunen:

1. Basisinstelling

Meld je eerst aan voor een account op Predibase en stort geld om credits toe te voegen. Genereer vervolgens je API Key.

2. Aanmaken van een Model Repository

Ga naar Models en klik vervolgens op “New Model Repository” zoals hieronder weergegeven:

Geef je repository nu een naam en voeg een beschrijving toe.

3. Start met fine-tunen:

Vul de gemarkeerde gebieden in en druk vervolgens op train. Dit zet je verzoek in de wachtrij totdat er rekenkracht beschikbaar is.

Code Platforms:

Code Platforms zijn ontworpen voor gebruikers met een solide achtergrond in programmeren. Deze platforms bieden virtuele machines waarmee aangepaste Python-scripts kunnen worden uitgevoerd voor taken zoals fine-tuning. Deze platforms zijn perfect voor projecten die hoge mate van maatwerk en ingewikkelde controle over de trainings- en deploymentfasen vereisen.

1. Amazon SageMaker:

Amazon SageMaker is een volledig beheerde dienst die ontwikkelaars en data scientists de mogelijkheid biedt om snel machine learning-modellen te bouwen, trainen en deployen.

Amazon SageMaker heeft geen dedicated, ingebouwde "fine-tuning" functie die specifiek zo is gelabeld voor grote taalmodellen. In plaats daarvan biedt het een krachtig en flexibel platform waarmee je aangepaste Python-scripts kunt uitvoeren om fine-tuning taken te volbrengen.

Hier is een eenvoudig voorbeeld van hoe je een fine-tuning job voor een taalmodel zou kunnen starten met Hugging Face op SageMaker. Dit gaat ervan uit dat je al een AWS-account hebt ingesteld en de AWS CLI hebt geconfigureerd. (je kunt TensorFlow of PyTorch rechtstreeks op Amazon SageMaker gebruiken voor fine-tuning taken)

1. Instellen en initialiseren van de SageMaker-sessie:

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. Het fine-tuning script voorbereiden:

Normaal gesproken schrijf je een fine-tuning script (train.py) dat je doorgeeft aan de estimator. Dit script moet de logica bevatten voor het laden van je model, fine-tuning en opslaan.

# 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. Een Hugging Face Estimator aanmaken:

# 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. Start de Training Job:

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

Belangrijkste functies:

1. Vooraf gebouwde algoritmen en ondersteuning voor populaire frameworks: SageMaker ondersteunt TensorFlow, PyTorch, Hugging Face en andere, waardoor het eenvoudiger wordt om LLM's te fine-tunen op aangepaste datasets.
2. Managed Spot Training: Het verlaagt de kosten van het trainen van modellen door gebruik te maken van Amazon EC2 Spot Instances.
3. Distributed Training: SageMaker maakt het eenvoudiger om modellen sneller en kosteneffectiever te trainen door de training job te verdelen over meerdere GPU's of instances.

2. Google Colab:

Google Colab is een populaire cloud-based Jupyter notebook-dienst die gratis toegang biedt tot rekenresources, waaronder GPU's en TPU's, waardoor het een uitstekend platform is voor het fine-tunen van grote taalmodellen (LLM's).

Het is bijzonder beginnersvriendelijk. Colab-notebooks draaien in de cloud, rechtstreeks vanuit je browser, zonder dat er een lokale installatie vereist is.

Hier is het eenvoudige codefragment voor het fine-tunen van een Transformer Model met Hugging Face Transformers en PyTorch in Google Colab

1. De omgeving instellen:

!pip install torch torchvision transformers

2. Een Pre-trained Model en Tokenizer laden:

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. Het model fine-tunen:  (ervan uitgaande dat je een dataset hebt geladen in de variabelen input_ids, attention_masks en labels)

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. Het model opslaan:

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

Belangrijkste functies:

1. Gratis toegang tot GPU's/TPU's: Colab biedt gratis toegang tot NVIDIA GPU's en Google TPU's, wat het trainen en fine-tunen van machine learning-modellen aanzienlijk kan versnellen.
2. Integratie met Google Drive: Sla je datasets en modellen eenvoudig op en open ze rechtstreeks vanuit Google Drive, wat naadloos databeheer en het opslaan van modellen vergemakkelijkt.
3. Pre-installed Libraries: Colab wordt geleverd met de meeste data science- en machine learning-bibliotheken vooraf geïnstalleerd, waaronder TensorFlow, PyTorch, Hugging Face Transformers en vele anderen, waardoor het eenvoudig is om direct te starten met het fine-tunen van modellen.
4. Interactive Environment: De notebook-interface maakt interactieve ontwikkeling en documentatie mogelijk door live code, visualisaties en tekstannotaties te combineren.

3. Paperspace Gradient

Paperspace Gradient is een reeks tools die is ontworpen om het proces van het ontwikkelen, trainen en implementeren van machine learning-modellen in de cloud te vereenvoudigen.

Gradient is bijzonder effectief voor taken zoals het fine-tunen van large language models (LLMs) vanwege de schaalbare infrastructuur en ondersteuning voor containers, wat het een sterke keuze maakt voor data scientists en ML-professionals.

Hier is een voorbeeld van het fine-tunen van een Transformer Model met PyTorch op Paperspace Gradient.

1. Laden van een Pre-trained Model en Tokenizer:

from transformers import BertTokenizer, BertForSequenceClassification
import torch

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

2. Voorbereiden van de Dataset:

from transformers import TextDatasetForNextSentencePrediction

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

3. Fine-Tunen van het Model:

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. Opslaan van het Model:

model.save_pretrained("./my_finetuned_model")

Belangrijkste kenmerken:

1. Pre-configured Environments: Gradient biedt vooraf geconfigureerde omgevingen voor TensorFlow, PyTorch, Hugging Face en andere machine learning-frameworks, wat een snelle opzet voor fine-tuningtaken mogelijk maakt.
2. Krachtige GPUs: Toegang tot een breed scala aan GPU-opties zorgt ervoor dat u uw rekenkracht kunt schalen volgens de behoeften van uw project, van meer kosteneffectieve opties voor initiële experimenten tot high-end GPUs voor intensieve trainingssessies.
3. Gradient Notebooks: Een interactieve coderingsomgeving vergelijkbaar met Jupyter Notebooks, maar met het extra voordeel dat deze draait op de cloudinfrastructuur van Paperspace. Dit is ideaal voor het direct ontwikkelen, fine-tunen en experimenteren in de cloud.
4. Jobs en Workflows: Automatiseer uw machine learning-pipelines door jobs opeenvolgend of parallel uit te voeren, wat een efficiënte modeltraining en -implementatie mogelijk maakt.

4. Run.ai

Run.AI is een platform dat is ontworpen om GPU-resources te optimaliseren voor machine learning-workloads, waardoor het voor data scientists en AI-onderzoekers eenvoudiger wordt om complexe AI-modellen uit te voeren en te beheren, inclusief het fine-tunen van large language models (LLMs). 

Het is gebaseerd op Kubernetes, een tool die computerresources efficiënt organiseert. Zo maakt het het uitvoeren van complexe AI-projecten eenvoudiger en kunnen teams hun projecten soepel laten groeien.

U kunt de documentatie van Run.AI raadplegen voor gedetailleerde inzichten; hier is een vereenvoudigd voorbeeld gebaseerd op de algemene workflow voor het fine-tunen van een model zoals LLaMA-2 op het Run.AI-platform.

1.  Voorbereiden van uw omgeving

2. Instellen van uw project en GPU-verzoeken

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

3. Schrijven van het fine-tuningscript

Uw train.py-script moet de logica bevatten voor het laden van LLaMA-2 (of het door u gekozen model), uw dataset, en het uitvoeren van het fine-tuningproces. Dit kan het gebruik omvatten van bibliotheken zoals Hugging Face Transformers voor het laden van het model en TensorFlow of PyTorch voor de trainingsloop.

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. Monitoren en beheren van de trainingsjob

Run.AI biedt tools om het GPU-gebruik en de voortgang van uw trainingsjobs te monitoren en computationele resources effectief te beheren. Gebruik het Run.AI-dashboard of de CLI om de status en prestaties van uw job bij te houden.

runai list jobs

Dit commando geeft een overzicht van alle huidige jobs, zodat u de voortgang en het resourcegebruik van uw fine-tuningtaak kunt monitoren.

Belangrijkste kenmerken:

1. GPU Optimization en Elastic GPU Allocation: Optimaliseert automatisch GPU-gebruik, verbetert de efficiëntie en wijst dynamisch GPU-resources toe op basis van workloadvereisten, waardoor de kosten aanzienlijk worden verlaagd.
2. Vereenvoudigd resourcebeheer: Biedt een intuïtief dashboard en CLI voor het beheren van AI-workloads, waardoor het eenvoudig is om het resourcegebruik in real-time te monitoren en aan te passen.
3. Integratie met populaire frameworks: Ondersteunt populaire machine learning-frameworks zoals TensorFlow, PyTorch en Hugging Face Transformers, wat een naadloze integratie in bestaande workflows vergemakkelijkt.

De juiste tool voor u kiezen:

Gebruiksgemak: Kies tools die eenvoudig zijn, vooral als u niet veel ervaring hebt met coderen. Voor sommige tools hoeft u niet eens code te schrijven!

Schaalbaarheid: Zorg ervoor dat de tool kan meegroeien met uw project en grotere datasets en complexere modellen soepel kan verwerken.

Ondersteuning voor modellen en datasets: Kies tools die goed werken met de specifieke typen data en modellen die u gebruikt.

Computationele resources: Zoek naar toegang tot GPUs of TPUs als uw project zware rekenkracht nodig heeft.

Kosten: Bedenk hoeveel u bereid bent uit te geven. Sommige tools zijn gratis; andere rekenen kosten op basis van de resources die u gebruikt.

Aanpasbaarheid en controle: Als u goed de weg weet in code, geeft u misschien de voorkeur aan tools waarmee u alles kunt aanpassen.

Integratie: Het is eenvoudiger als de tool naadloos past in uw bestaande workflow en tools.

Community en ondersteuning: Een ondersteunende community en goede documentatie kunnen u veel hoofdpijn besparen.

Veelgestelde vragen

Wat zijn de beste fine-tuning tools voor LLMs?

Führende fine-tuning tools zijn onder meer Hugging Face voor modeltoegang, SiliconFlow voor cloudgebaseerde training en TrueFoundry voor orchestratie op enterprise-niveau. Open-source bibliotheken zoals Axolotl en LLaMA-Factory ondersteunen ook geavanceerde technieken zoals LoRA. TrueFoundry verenigt op unieke wijze modeltoegang, experiment tracking en deployment governance in één enkel beveiligd platform.

Wat zijn de kosten van het gebruik van fine-tuning tools in de cloud?

Cloud fine-tuningkosten zijn afhankelijk van GPU-rekenuren, modelgrootte en opslagvereisten. Het trainen van een model met 7B parameters kost doorgaans tussen $ 100 en $ 400, terwijl 70B-modellen de $ 10.000 kunnen overschrijden. Het gebruik van parameter-efficiënte methoden zoals QLoRA verlaagt deze kosten aanzienlijk tot ongeveer $ 50–$ 300 per trainingsrun.

Wat zijn parameter-efficient fine-tuning (PEFT) tools?

PEFT fine-tuning tools maken gebruik van technieken zoals LoRA om slechts een minuscuul fractie van de parameters van een model aan te passen. Dit vermindert de GPU-geheugenvereisten, waardoor teams enorme modellen kunnen trainen op consumentenhardware of een enkele GPU. Deze tools versnellen de trainingssnelheid en leveren tegelijkertijd een nauwkeurigheid die vergelijkbaar is met het volledig hertrainen van het model.

Hoe verschillen fine-tuning tools van prompt engineering?

Fine-tuning tools hertrainen modellen op gespecialiseerde datasets, waarbij parameters worden aangepast om de prestaties op domeinspecifieke taken te verbeteren. Prompt engineering past invoertekst aan om de uitvoer te sturen zonder de interne modelgewichten te wijzigen. Hoewel prompt engineering sneller is, biedt fine-tuning diepere controle en superieure nauwkeurigheid voor complexe enterprise use cases.

Hoe werkt TrueFoundry als een fine-tuning tool?

TrueFoundry vereenvoudigt fine-tuning door een geünificeerde interface te bieden voor dataintegratie, experiment tracking en modelimplementatie. Gebruikers uploaden eigen data en starten fine-tuningjobs op geoptimaliseerde infrastructuur met behulp van hoogwaardige backends. Zodra de training is voltooid, kunnen teams bijgewerkte checkpoints met één klik direct naar productie implementeren.