Article

Een praktijkgids voor de fijnafstemming van LLM's met Azure AI Projects op serverloze GPU

Een praktijkgerichte gids voor cloudarchitecten over de fijnafstemming van LLM's met Azure AI Projects en serverloze GPU-computing. Leer hoe u modelaanpassing kunt stroomlijnen, van datavoorbereiding tot API-implementatie, zonder de overhead van infrastructuur.

TL;DR

Een praktijkgerichte gids voor cloudarchitecten over de fijnafstemming van LLM's met Azure AI Projects en serverloze GPU-computing. Leer hoe u modelaanpassing kunt stroomlijnen, van datavoorbereiding tot API-implementatie, zonder de overhead van infrastructuur.

De bottleneck in enterprise AI: de complexiteit van fijnafstemming

Een van de meest voorkomende knelpunten in AI-projecten is de enorme complexiteit en kosten van het fijnafstemmen van grote taalmodellen (LLM's). Het provisioneren van GPU-clusters, het beheren van gedistribueerde training en het optimaliseren van geheugen met tools zoals DeepSpeed zijn geen triviale taken. De belofte van AI loopt vaak spaak in dit implementatiestadium, wat leidt tot langere ontwikkelcycli, hogere operationele kosten en onderbenutte hardware.

Dit is precies het probleem dat Azure AI Projects en zijn serverloze GPU-fijnafstemmingsmogelijkheden moeten oplossen. Het gaat niet alleen om het offloaden van rekenkracht; het gaat om het transformeren van de gehele fijnafstemmingsworkflow in een gestroomlijnd, API-gestuurd proces. Door gebruik te maken van de beheerde services van Azure krijgen we toegang tot krachtige GPU-bronnen zonder ons zorgen te hoeven maken over hun provisionering, schaling of onderhoud. Deze paradigmaverschuiving betekent minder tijd besteden aan kubectl-opdrachten of Terraform-configuraties voor GPU-knooppunten, en meer tijd aan datacuratie en modelevaluatie. De bedrijfswaarde is duidelijk: snellere time-to-market voor AI-gestuurde applicaties en een hogere ROI op uw AI-initiatieven.

Deze gids is een walkthrough voor het gebruik van deze stack. Mijn doel is om een duidelijk, uitvoerbaar pad te bieden, geworteld in de realiteit van enterprise AI, zodat u aangepaste, performante modellen kunt implementeren zonder vast te lopen in infrastructuur.

Vereisten

Voordat we dieper ingaan, laten we de basisopstelling vaststellen voor een soepele start.

  • Azure Abonnement: Een actief abonnement met voldoende quotum voor Azure AI- en Azure OpenAI-services. Vraag tijdig een quotumverhoging aan indien nodig.
  • Azure AI Project: Een Azure AI Project-bron geconfigureerd in een Europese regio. Ik zal westeurope gebruiken voor alle voorbeelden. Dit project zal fungeren als uw centrale hub.
  • Azure OpenAI Bron: Een Azure OpenAI Service-bron geïmplementeerd in dezelfde regio (westeurope). Dit levert de basismodellen en de fijnafstemmings-API.
  • Python Omgeving: Python 3.12+ geïnstalleerd op uw lokale machine. Ik gebruik altijd een virtuele omgeving om afhankelijkheden te isoleren.
  • Authenticatie: Een Service Principal of uw gebruikersaccount moet de rol Cognitive Services OpenAI Contributor hebben voor zowel de Azure OpenAI-bron als het Azure AI Project.
  • Training- & Validatiegegevens: Uw dataset moet in JSONL-formaat zijn, waarbij elke regel een geldig JSON-object is. Voor chatmodellen moet dit object een messages-array bevatten met een specifieke structuur.

Zo heb ik mijn lokale omgeving ingesteld:

# Create and activate a Python virtual environment
python3.12 -m venv aift-env
source aift-env/bin/activate

# Install the necessary libraries
pip install openai azure-identity

# Verify the installations
pip show openai azure-identity

U zou recente versies van beide bibliotheken succesvol geïnstalleerd moeten zien.

Architectuur: de serverloze abstractie

Wanneer we spreken over de serverloze GPU-fijnafstemming van Azure, hebben we het over een sterk geabstraheerde beheerde service. De elegantie zit in het feit dat u de onderliggende rekenkracht niet hoeft te beheren, maar het is cruciaal om de conceptuele stroom te begrijpen om effectief problemen op te lossen en kosten te optimaliseren.

De mentale verschuiving van serverloze GPU

Veel organisaties worstelen met het 'serverloze' concept voor GPU's, omdat ze verwachten een cluster te definiëren. De mentale verschuiving is deze: in plaats van infrastructuur te definiëren, definieert u *workloadparameters* via een API-aanroep. De AI-services van Azure vertalen die parameters vervolgens naar vluchtige, geoptimaliseerde GPU-rekenkracht. Dit is vooral krachtig voor de onregelmatige, incidentele aard van fijnafstemmingstaken, waarbij toegewijde GPU-infrastructuur een financiële last zou zijn.

Een Azure AI Project fungeert als uw uniforme werkruimte. Wanneer u een fijnafstemmingstaak indient via de OpenAI Python-client die gericht is op uw Azure OpenAI-bron, orkestreert de service het hele backend-proces. Het "Serverloze GPU"-aspect betekent dat Azure de dynamische provisionering van rekenkracht beheert, de trainingstaak uitvoert en alles terugschroeft tot nul wanneer voltooid, waardoor inactieve kosten worden geëlimineerd.

Zo ziet die architectuurstroom eruit:

Belangrijkste concepten:

  • Beheerde Fine-tuning API: De openai_client.fine_tuning.jobs.create API-aanroep is uw primaire interface. U geeft uw gegevens en hyperparameters door, en Azure regelt de rest.
  • Onderliggende optimalisaties: De beheerde service verwerkt transparant complexe optimalisaties zoals Parameter-Efficient Fine-Tuning (PEFT), bijvoorbeeld LoRA, en kwantisering om de geheugenvoetafdruk en de kosten van training te verminderen. U configureert deze niet direct; u profiteert er automatisch van.
  • Gegevensresidentie: De parameter trainingType: "GlobalStandard", hoewel vaak aanbevolen voor kosteneffectiviteit, kan betekenen dat uw gegevens en modelgewichten tijdelijk buiten de regio van uw bron worden gekopieerd voor training. Voor gereguleerde sectoren heeft dit aanzienlijke implicaties voor gegevenssoevereiniteit. Bevestig altijd met uw compliance-team voordat u deze gebruikt.
  • Modelregister & Implementatie: Na fijnafstemming verschijnt het nieuwe model in het modelregister van uw Azure AI Project. Van daaruit kunt u het implementeren naar een beheerd eindpunt om inferentieaanvragen te bedienen.

Deze architectuur zorgt voor een duidelijke scheiding van taken, waardoor data science-teams zich kunnen richten op het model, terwijl het platform de infrastructuur beheert. Laten we deze theorie nu in de praktijk brengen.

Implementatiegids

Ik neem u stap voor stap mee door het proces, precies zoals ik dat zou doen met een junior architect in mijn team.

Discipline bij datavoorbereiding

Het succes van elke fijnafstemmingstaak hangt af van de kwaliteit en het formaat van uw trainingsgegevens. Rommel erin, rommel eruit. Ik heb talloze uren verspild aan het debuggen van taken die mislukten vanwege een verkeerd opgemaakt JSONL-bestand. Valideer uw gegevensformaat rigoureus voordat u iets uploadt.

Stap 1: Configureer de Azure OpenAI-client

Eerst configureren we ons Python-script om te communiceren met het Azure OpenAI-service-eindpunt. Ik gebruik altijd omgevingsvariabelen voor referenties – codeer ze nooit hard.

import os
import sys
import json
import openai

# --- Configuration for Azure OpenAI Service ---
# Set these in your shell or CI/CD environment
# export AZURE_OPENAI_ENDPOINT="https://your-aoai-resource.openai.azure.com/"
# export AZURE_OPENAI_API_KEY="your-api-key"
# export AZURE_OPENAI_API_VERSION="2025-04-01-preview"

AZURE_RESOURCE_REGION = "westeurope"

# Initialize the OpenAI client for Azure
try:
    openai_client = openai.AzureOpenAI(
        azure_endpoint=os.environ["AZURE_OPENAI_ENDPOINT"],
        api_key=os.environ["AZURE_OPENAI_API_KEY"],
        api_version=os.environ["AZURE_OPENAI_API_VERSION"],
    )
    print("Azure OpenAI client initialized successfully.")
except KeyError as e:
    print(f"Error: Missing environment variable {e}. Please set AZURE_OPENAI_ENDPOINT, AZURE_OPENAI_API_KEY, and AZURE_OPENAI_API_VERSION.")
    sys.exit(1)
except Exception as e:
    print(f"An unexpected error occurred during client initialization: {e}")
    sys.exit(1)

Stap 2: Bereid trainings- en validatiegegevens voor

Uw gegevens moeten in JSONL-formaat zijn. Voor chat-fijnafstemming is elke regel een JSON-object met een messages-array die role- en content-paren bevat. Hier is een minimaal voorbeeld.

training_file_path = "./training_data.jsonl"
validation_file_path = "./validation_data.jsonl"

# Example data for a customer support chatbot
training_data = [
    {"messages": [{"role": "system", "content": "You are a helpful customer support assistant for a SaaS company."}, {"role": "user", "content": "How can I reset my password?"}, {"role": "assistant", "content": "You can reset your password by visiting the 'Forgot Password' link on our login page."}]},
    {"messages": [{"role": "system", "content": "You are a helpful customer support assistant for a SaaS company."}, {"role": "user", "content": "What are your support hours?"}, {"role": "assistant", "content": "Our support team is available Monday to Friday, from 9 AM to 5 PM CET."}]},
]

validation_data = [
    {"messages": [{"role": "system", "content": "You are a helpful customer support assistant for a SaaS company."}, {"role": "user", "content": "I'm locked out of my account."}, {"role": "assistant", "content": "I'm sorry to hear that. Have you already tried using the 'Forgot Password' link?"}]},
]

# Write the data to local JSONL files
with open(training_file_path, "w") as f:
    for entry in training_data:
        f.write(json.dumps(entry) + "\n")

with open(validation_file_path, "w") as f:
    for entry in validation_data:
        f.write(json.dumps(entry) + "\n")

print(f"Training data written to {training_file_path}")
print(f"Validation data written to {validation_file_path}")

Stap 3: Upload databestanden naar Azure

Vervolgens uploaden we deze bestanden naar de Azure OpenAI-service. Ze worden opgeslagen en gevalideerd voordat de trainingstaak ze kan gebruiken. De vlag purpose="fine-tune" is verplicht.

# Upload training file
print("Uploading training file...")
with open(training_file_path, "rb") as f:
    train_file = openai_client.files.create(file=f, purpose="fine-tune")
print(f"Uploaded training file with ID: {train_file.id}")

# Upload validation file
print("Uploading validation file...")
with open(validation_file_path, "rb") as f:
    validation_file = openai_client.files.create(file=f, purpose="fine-tune")
print(f"Uploaded validation file with ID: {validation_file.id}")

# The service needs time to process the files. We can wait for it programmatically.
print("Waiting for files to be processed...")
openai_client.files.wait_for_processing(train_file.id)
openai_client.files.wait_for_processing(validation_file.id)
print("Files processed and ready for fine-tuning.")

Stap 4: Creëer de fijnafstemmingstaak

Dit is het belangrijkste moment. We activeren de fijnafstemmingstaak, waarbij we het basismodel, onze geüploade gegevens en hyperparameters specificeren. Houd er rekening mee dat u een modelversie moet gebruiken die fijnafstemming in uw regio ondersteunt, zoals gpt-4o-mini-2024-07-18.

# Verify the exact fine-tunable model name in your Azure AI Foundry deployment options.
base_model_name = "gpt-4o-mini-2024-07-18"

print(f"Creating supervised fine-tuning job for model '{base_model_name}'...")

fine_tuning_job = openai_client.fine_tuning.jobs.create(
    training_file=train_file.id,
    validation_file=validation_file.id,
    model=base_model_name,
    hyperparameters={
        "n_epochs": 3,
        "batch_size": 1,
        "learning_rate_multiplier": 2.0
    },
    suffix="ew1-support-v1", # A useful suffix for the resulting model name
    # Pass Azure-specific parameters via extra_body
    extra_body={
        "trainingType": "GlobalStandard"
    }
)

print(f"Fine-tuning job created with ID: {fine_tuning_job.id}")
print(f"Current job status: {fine_tuning_job.status}")
print("Monitor the job's progress in the Azure AI Foundry.")

Stap 5: Monitor de taak

Fijnafstemming kan minuten tot uren duren. U kunt de voortgang van de taak programmatisch volgen met behulp van de OpenAI SDK, of via de Azure AI Foundry-portal onder de sectie "Fijnafstemming" van uw project.

import time

job_id = fine_tuning_job.id

while True:
    job = openai_client.fine_tuning.jobs.retrieve(job_id)
    print(f"Status: {job.status}")
    if job.status in ("succeeded", "failed", "cancelled"):
        break
    time.sleep(60)

if job.status == "succeeded":
    print(f"Fine-tuned model ID: {job.fine_tuned_model}")
else:
    print(f"Job ended with status: {job.status}")

for event in openai_client.fine_tuning.jobs.list_events(job_id):
    print(f"{event.created_at}: {event.message}")

Zodra de taak is voltooid, bevat job.fine_tuned_model de ID van uw aangepaste model (bijv. \ft:gpt-4o-mini-2024-07-18:my-org:ew1-support-v1:xxxxxx).

Stap 6: Implementeer het fijnafgestemde model

Om inferentie te bedienen, moet u het model implementeren naar een beheerd eindpunt. Dit gebeurt via de Azure Management REST API, niet via de openai-bibliotheek.

`\bash curl -X PUT "https://management.azure.com/subscriptions//resourceGroups//providers/Microsoft.CognitiveServices/accounts//deployments/?api-version=2024-10-21" \ -H "Authorization: Bearer $(az account get-access-token --query accessToken -o tsv)" \ -H "Content-Type: application/json" \ -d '{ "sku": {"name": "standard", "capacity": 1}, "properties": { "model": { "format": "OpenAI", "name": "", "version": "1" } } }'

```

U kunt ook implementeren via de Azure AI Foundry-portal. Deze implementatiestap maakt uw aangepaste model beschikbaar als een veilig, schaalbaar API-eindpunt voor uw applicaties.

Probleemoplossing en verificatie

Zelfs met een beheerde service kunnen er dingen misgaan. Hier zijn de veelvoorkomende faalmodi die ik in de praktijk zie.

  1. **Fout:

openai.BadRequestError: Het aangevraagde model 'gpt-4o-mini' wordt niet ondersteund voor fijnafstemming.`**
    *   **Hoofdoorzaak:** De door u opgegeven basismodel-ID is onjuist of niet beschikbaar voor fijnafstemming in uw specifieke Azure-regio en abonnement. Ondersteuning varieert.
    *   **Oplossing:** Ga naar de Azure AI Foundry, navigeer naar uw project en controleer de lijst met modellen die beschikbaar zijn voor fijnafstemming. Gebruik de exacte modelnaam die daar wordt vermeld, die vaak een versienummer bevat (bijv. `gpt-4o-mini-2024-07-18`).

2.  **Fout: `openai.BadRequestError: Ongeldig bestandsformaat. Elke regel in het bestand moet een JSON-object zijn.`**
    *   **Hoofdoorzaak:** Dit is een gegevensopmaakprobleem. Uw `.jsonl`-bestand heeft een syntaxisfout – een extra komma, een ontbrekende haak, of een regel die geen compleet JSON-object is.
    *   **Oplossing:** Valideer het bestand lokaal voordat u het uploadt. Een eenvoudig Python-script kan u veel tijd besparen:

```python
# Local validator for a JSONL file
import json
file_to_check = "./training_data.jsonl"
try:
    with open(file_to_check, 'r') as f:
        for line_num, line in enumerate(f, 1):
            json.loads(line)
    print(f"File '{file_to_check}' is valid JSONL.")
except json.JSONDecodeError as e:
    print(f"JSON error in '{file_to_check}' on line {line_num}: {e}")
  1. Fout: openai.AuthenticationError: Toegang geweigerd vanwege ongeldige abonnementssleutel of verkeerd API-eindpunt.
    • Hoofdoorzaak: Uw omgevingsvariabelen (AZURE_OPENAI_ENDPOINT, AZURE_OPENAI_API_KEY) zijn onjuist of uw principal heeft niet de juiste machtigingen.
    • Oplossing: Controleer dubbel of uw eindpunt verwijst naar uw specifieke Azure OpenAI-bron (https://<uw-resource-naam>.openai.azure.com/) en of de API-sleutel geldig is. Controleer of uw Service Principal of gebruikersaccount de rol Cognitive Services OpenAI Contributor heeft op de bron.

Belangrijkste leerpunten

De overstap naar beheerde fijnafstemming op Azure betekent een aanzienlijke productiviteitsboost voor AI-teams. Door de complexe infrastructuurlaag te abstraheren, kunt u zich richten op wat echt bedrijfswaarde creëert: het maken van zeer gespecialiseerde modellen die specifieke problemen oplossen.

  • Abstractie is uw bondgenoot: Omarm het serverloze GPU-model. Laat Azure de provisionering, schaling en optimalisatie afhandelen, zodat u zich kunt richten op gegevens- en modelkwaliteit.
  • API-gestuurde workflow: Het hele fijnafstemmingsproces is programmatisch, waardoor het perfect past bij MLOps en geautomatiseerde CI/CD-pipelines.
  • Data is alles: De kwaliteit en het formaat van uw trainingsgegevens zijn de belangrijkste bepalende factoren voor succes. Investeer zwaar in datavoorbereiding en -validatie.
  • Regiobewuste architectuur: Implementeer resources altijd in uw beoogde Europese regio's (westeurope, northeurope) en houd rekening met de implicaties van gegevensresidentie voor instellingen zoals trainingType.
  • Itereer en verbeter: Beschouw fijnafstemming als een continue cyclus. Monitor taken in de Azure Portal, analyseer de resultaten en verfijn uw datasets en hyperparameters om de modelprestaties gestaag te verbeteren.

Mijn laatste aanbeveling voor architecten is om deze service niet alleen als een hulpmiddel te zien, maar als een strategische facilitator. Het verlaagt de drempel voor aangepaste AI, waardoor meer teams kunnen experimenteren en sneller dan ooit waarde kunnen leveren. Uw volgende stap zou moeten zijn om een waardevolle, weinig complexe use case in uw organisatie te identificeren en een proof-of-concept uit te voeren met behulp van deze workflow.

Last updated:

This article was produced using an AI-assisted research and writing pipeline. Learn how we create content →

Related Articles

AWS SageMaker Serverless Inference: Een praktijkhandleiding

AWS SageMaker Serverless Inference: Een praktijkhandleiding

Implementeer machine learning-modellen op AWS zonder instanties te beheren. Deze...