Azure OpenAI: Een stapsgewijze gids voor beginners

Azure OpenAI instellen

In deze sectie laat ik zien hoe je Azure OpenAI instelt. Ik ga ervan uit dat je enige ervaring hebt met Azure. 

Houd er rekening mee dat gebruikersinterfaces vaak veranderen. De indeling en tekst van verschillende secties en titels in de instructies en screenshots kan in de loop van de tijd of per regio wijzigen.

Stap 1: Maak een Azure-account aan

Ga naar de Azure OpenAI-homepage en kies Sign in rechtsboven. Log in met je Microsoft-account. Heb je nog geen Microsoft-account, kies dan op de aanmeldpagina de optie om een nieuw account te maken en maak een Microsoft-account aan. 

Maak daarna een Azure-account aan via de onderstaande stappen:

1. Log in met je Microsoft-account op het Azure Portal. Kies de optie Start with an Azure free trial. 

Het Microsoft Azure Portal.

2. Kies op de volgende pagina de optie om een Azure free account aan te maken met $200 gratis tegoed.

Kies een type Azure-account.

3. Vul je persoonlijke gegevens in op het formulier.

Maak een gratis Azure-account.

4. Verifieer je identiteit met een creditcard of betaalpas. Let op: er kan tijdelijk een klein bedrag (meestal enkele centen of het equivalent) worden gereserveerd op je rekening. 

Verifieer je Azure-account (screenshot door auteur) 

5. Na het verifiëren van je betalingsgegevens kies je Go to Azure Portal. Je wordt doorgestuurd naar het Quickstart Center.
6. Let op: het gratis tegoed van $200 kan niet worden gebruikt voor Azure OpenAI-services. Azure OpenAI-modellen zijn alleen toegankelijk met een betaald account. Om je account te upgraden naar een pay-as-you-go-abonnement, ga je terug naar het Azure-portal en kies je Upgrade in de bovenbalk. 

Upgrade je Azure-account.

7. Vul de gegevens in op de upgradepagina en kies Upgrade to pay as you go.

Na het upgraden naar een betaald account heb je toegang tot OpenAI-modellen. 

Stap 2: Toegang tot Azure OpenAI in het Azure-portal

1. Ga terug naar het Azure-portal. Daar zie je allerlei services, zoals AI-services, virtuele machines, storage-accounts en meer. 

Azure-portal met beschikbare services.

2. Kies Azure AI services en ga naar de homepagina van AI-services. Azure biedt diverse AI-diensten, zoals gezichtsherkenning, anomaliedetectie, spraak, computervisie, OpenAI en meer. 

Azure AI-services.

3. Ga op het tabblad Azure OpenAI account naar de optie View. 
4. Dit brengt je naar de Azure OpenAI pagina met de lijst met OpenAI-instances in je account. Kies Create Azure OpenAI om een nieuwe instance te maken. Je kunt ook Create kiezen op de vorige pagina. 
5. Voer de volgende gegevens in:
• Onder Subscription kies je de naam van je betaalde abonnement.
• Onder Resource group kies je Create new:
• Voer een naam in voor de nieuwe resourcegroep. 

Maak een nieuwe Azure OpenAI-instance.

• • • Kies bij Region de dichtstbijzijnde regio.
    • Voer onder Name een unieke naam in. 
    • Kies onder de Pricing tier voor Standard S0.
    • Kies Next om door te gaan.

6. Selecteer in de sectie Network de optie "All networks, including the Internet, can access this resource." Ga daarna door naar de volgende stap.
7. Vul in de sectie Tags naam-waardeparen in om deze instance te categoriseren. Dit helpt bij geconsolideerde facturatie. Deze stap is optioneel. 
8. Kies in de volgende sectie Review + submit, controleer de waarden en kies Create. Hiermee wordt een nieuwe OpenAI-instance uitgerold. 
9. Na korte tijd verschijnt het bericht "Your deployment is complete." Kies op deze pagina Go to resource. 
10. Kies op de resourcepagina de naam van de resource onder het tabblad Resources. 

Stap 3: API-toegang instellen

De resourcepagina toont de details van de instance. 

Het tabblad Develop bevat de API-sleutels en API-endpoint-URL's voor deze instance. De sleutels zijn automatisch voor je gegenereerd. 

• Kopieer de sleutels en het endpoint naar een tekstbestand.

Je krijgt twee API-sleutels. Zo kun je de tweede sleutel gebruiken als de eerste is gecompromitteerd. Je kunt de tweede sleutel ook gebruiken terwijl je de eerste opnieuw genereert. Zo kun je sleutels periodiek roteren zonder downtime. 

API-sleutels van Azure OpenAI-instance

• Controleer op het tabblad Monitor de gebruiksstatistieken van deze instance. 
• Kies op het tabblad Get Started de optie Explore Azure AI Foundry portal om de AI-playground in een nieuwe pagina te openen. 

Azure OpenAI chat-playground.

• Kies de Chat playground in het linkermenu. 
• Kies onder Deployment de optie Create new dep.
• Kies From base models in de pop-up voor nieuwe deployments
• Er verschijnt een pop-up waarin je het model kunt kiezen. 
• Typ “gpt-3” in de zoekbalk. 
• Kies gpt-35-turbo uit de lijst. Dit is een voordelig model dat is geoptimaliseerd voor chatcompletions. Zodra je configuratie werkt, kun je indien nodig overschakelen naar een geavanceerder (en duurder) model.
• Kies Confirm. 
• Kies in de pop-up Deploy model voor Customize.
• Verlaag de Tokens per Minute Rate Limit naar een lage waarde (bijvoorbeeld 12 requests per minuut) voor handmatig testen. Verhoog dit later als je het model in productie zet. 
• Schakel dynamic quota uit. Dit heb je pas nodig wanneer de deployment veel verkeer ontvangt. 
• Kies Deploy.

Rol een nieuw model uit in de chat-playground.

Dat is alles! In de volgende sectie bekijken we hoe je toegang krijgt tot deze deployment van het OpenAI-model gpt-35-turbo. 

API-sleutels opnieuw genereren

Het is verstandig om de API-toegangssleutels periodiek opnieuw te genereren. Zo voorkom je dat het account wordt gecompromitteerd als oude sleutels per ongeluk uitlekken. Hieronder staan de stappen om sleutels te regenereren:

• Kies onder Resource Management in het linkermenu Keys and Endpoint.
• Genereer elke sleutel afzonderlijk opnieuw. 

API-sleutels van Azure OpenAI-instance.

Azure OpenAI gebruiken in applicaties

Na het instellen van Azure OpenAI en het uitrollen van een model, kijken we hoe je er programmatic toegang toe krijgt. 

Stap 1: Je ontwikkelomgeving instellen

Ik laat zien hoe je Python gebruikt om verbinding te maken met Azure OpenAI. Installeer de vereiste libraries:

$ pip install openai

Gebruik je een notebook, voer dan de volgende opdracht uit. Opmerking: ik gebruik een DataLab-notebook.

!pip install openai

Importeer de benodigde packages in de Python-shell of in het notebook:

import os
from openai import AzureOpenAI

De AzureOpenAI-module geeft toegang tot OpenAI-diensten binnen Azure. Dit is anders dan de OpenAI-module die wordt gebruikt voor toegang tot de standalone OpenAI API. 

Voordat je Azure OpenAI gebruikt, stel je de API-sleutel en het endpoint in je omgeving in. In de vorige sectie zag je waar je deze waarden vindt. In principe kun je ze binnen de programmeeromgeving instellen, maar ik raad dat af. Stel nooit API-sleutels bloot in de code. 

API-sleutels instellen via de terminal

Om Python lokaal te draaien, stel je de omgevingsvariabelen in het shell-configuratiebestand in. Ik laat zien hoe je dit doet voor de Bash-shell. 

• Bewerk het .bashrc-bestand in een teksteditor. 
• Voeg aan het einde van het bestand deze twee regels toe:
• export AZURE_OPENAI_API_KEY=MY_API_KEY'
• export AZURE_OPENAI_ENDPOINT=MY_ENDPOINT'
• Sla het bestand op en sluit het.
• Laad de wijzigingen in de terminal met het commando source ~/.bashrc. 
• Voor andere shells, zoals sh of zsh, kan het proces iets afwijken. 
• Open (of heropen) de Python-shell in dezelfde terminalsessie. 

Importeer de API-sleutel en endpointwaarden in de Python-terminal:

azure_openai_api_key = os.getenv["AZURE_OPENAI_API_KEY"]
azure_openai_endpoint = os.getenv["AZURE_OPENAI_ENDPOINT"]

API-sleutels instellen via online notebooks (DataLab)

In DataLab kun je omgevingsvariabelen direct instellen voor een notebook.

• Kies in de bovenste menubalk Environment en vervolgens Environment variables in het dropdownmenu. 
• Kies de optie om omgevingsvariabelen toe te voegen. 
• Voeg twee variabelen toe, AZURE_OPENAI_API_KEY en AZURE_OPENAI_ENDPOINT, met hun respectieve waarden. 
• Geef een naam aan deze set omgevingswaarden en sla de wijzigingen op. 

Haal in het notebook deze waarden op zoals hieronder getoond:

azure_openai_api_key = os.environ["AZURE_OPENAI_API_KEY"]
azure_openai_endpoint = os.environ["AZURE_OPENAI_ENDPOINT"]

Stap 2: Doe je eerste API-aanroep naar Azure OpenAI

Je kunt nu de functie AzureOpenAI() gebruiken om een client-object te maken dat aanvragen verwerkt. Deze functie gebruikt de volgende parameters:

• api_version: de versie van de Azure OpenAI API. Controleer de meest recente versie in de Azure-documentatie. 
• api_key: de Azure OpenAI API-sleutel. Haal deze uit de omgevingsvariabelen die je eerder hebt ingesteld. Stel dit hier niet handmatig in. 
• azure_endpoint: de URL van het Azure OpenAI API-endpoint (haal deze waarde uit de omgeving). 

client = AzureOpenAI(
    api_version="2024-06-01",
    api_key=azure_openai_api_key,
    azure_endpoint=azure_openai_endpoint
)

Gebruik dit client-object voor taken zoals chat completion met de functie .chat.completions.create(). Deze functie accepteert de volgende parameters:

• model: de modelnaam. In oudere releases van de OpenAI API heette dit engine. Let op dat de parameter model moet overeenkomen met het model dat je tijdens de deployment hebt opgegeven (op het Azure AI Foundry-portal). Als je een ander model gebruikt dan het gedeployde model, krijg je onderstaande foutmelding: 

NotFoundError: Error code: 404 - {'error': {'code': 'DeploymentNotFound', 'message': 'The API deployment for this resource does not exist. If you created the deployment within the last 5 minutes, please wait a moment and try again.'}}

• messages: deze parameter specificeert het gesprek tussen de gebruiker en het model. Het bestaat uit een set message-objecten. Elk message-object heeft een key-value-paar aangeduid met role (either system, user of assistant) en content (de tekst van het bericht). Deze message-objecten geven context voor de interactie en sturen de reacties van het model. 

Hieronder geef ik voorbeelden van key-value-paren (role, content) voor verschillende waarden van role: 

• user: de prompt die de eindgebruiker invoert. 

Voorbeeld: {“role”: “user”, “content”: “explain the difference between rational and irrational numbers”}

• system: de beschrijving van de rol die OpenAI in de interactie moet spelen. 

Voorbeeld: {“role”: “system”, “content”: “you are a helpful teacher to guide elementary mathematics students”}

• assistant: de reactie die van OpenAI wordt verwacht. 

Voorbeeld: {“role”: “assistant”, “content”: “the difference between rational and irrational numbers is … an example explanation …”}

De rol assistant is alleen nodig wanneer trainingsdata wordt aangeleverd om het model te fine-tunen. Bij gebruik van de client voor taken zoals chat completion volstaan de rollen user en system. Voor veel eenvoudige taken is alleen de rol user al voldoende. 

• max_tokens: deze parameter bepaalt het maximale aantal tokens dat mag worden gebruikt om de API-aanroep te verwerken (zowel input als output). Je betaalt direct voor het aantal gebruikte tokens. De standaardwaarde is 16. Voor eenvoudige use-cases is dit voldoende; je kunt deze parameter dan weglaten. 

simple_completion = client.chat.completions.create(
    model="gpt-35-turbo",  
    messages=[
        {
            "role": "user",
            "content": "Explain the difference between OpenAI and Azure OpenAI in 20 words",
        },
    ],
)

Print de output van de chat completion-taak:

print(simple_completion.to_json())

De output is een JSON-object met verschillende key-value-paren. Het bevat de uitvoer van het model, zoals in het onderstaande voorbeeld. Merk op dat assistant de standaardrol is die aan het model wordt toegekend. 

"message": {
   "content": "OpenAI is a research organization focused on advancing AI, while Azure OpenAI is a collaboration between Microsoft and OpenAI.",
   "role": "assistant"
},

Stap 3: OpenAI-modellen gebruiken voor verschillende taken

Om een model via Azure OpenAI te gebruiken, moet je het eerst uitrollen. In de vorige sectie heb je het model gpt-35-turbo gedeployed. Wil je een ander model gebruiken:

• Ga terug naar de Azure AI Foundry en rol een ander model uit, zoals in de vorige sectie uitgelegd. Kies uit diverse modellen zoals GPT-3.5, GPT-4o, o1 en o1-mini, o3 en o3-mini, en meer. 
• Schrijf de prompts hierboven (in de functie chat.completions.create()) opnieuw met de naam van het nieuwe model. 

In oudere releases van OpenAI was het gebruikelijk om verschillende modellen voor verschillende taken te gebruiken. Er waren aparte modellen voor codegeneratie, NLP, enzovoort. Moderne modellen zoals GPT-3.5 en GPT-4 kunnen alle tekstgebaseerde generatieve taken uitvoeren. Veel oudere, taakspecifieke modellen (zoals davinci-modellen voor codegeneratie) zijn daarom uitgefaseerd. 

We bekijken nu hoe je de API gebruikt voor eenvoudige taken zoals vraag-en-antwoord en tekstsamenvatting. In de voorbeeldtaken hieronder gebruiken we hetzelfde model—GPT-3.5. Je kunt ook een van de GPT-4-modellen kiezen. 

Omdat dit beide tekstgebaseerde taken zijn, definiëren we eerst een tekstblok om mee te werken. Ik heb willekeurig een review van een paar laarzen van een e-commercesite gekopieerd. Wijs de tekst van deze review toe aan een variabele text. Zorg dat je enkele of dubbele aanhalingstekens in de tekst escaped. 

text = 'Comfort and Quality wise the boots are absolutely excellent. A 10 miles hike along the city Streets and the alps nearby felt like a smooth sail. The most plus it was quite well ventilated cause of the heavy duty Gore-tex material. After 12 hours when I removed it, there was just very little bit of perspiration (My foot sweats a lot) and absolutely no foul smell. Speaking of the Gore-Tex I would say, I sported this on a heavy rainy day after buying it in India, I was fearing the boot, though not very much like normal boots, would still be drenching with water, instead it was very little soaked. And some 5-6 hours later it was completely dry (Kept inside a closed room in the night). The only disadvantage I think is, that it fits my foot perfectly according to the size I chose, and there is no slight pain from 7 AM till 8 PM due to the shoe weight (of course its 1.2 KG, even though it doesn\'t feel like)' 

Tekstsamenvatting 

Om de bovenstaande tekst samen te vatten:

• Gebruik het eerder gemaakte client-object. 
• Geef de juiste rollen door binnen de parameter messages zoals in het onderstaande voorbeeld: 

summary_completion = client.chat.completions.create(
    model="gpt-35-turbo", 
    messages=[
        {
         "role": "system",
         "content": "You are a helpful assistant for summarizing text"
        },
        {
            "role": "user",
            "content": f"Summarize this text in 10 words: {text}",
        },
    ],
)

Let op hoe we de tekst als variabele in de prompt doorgeven in bovenstaande snippet.

print(summary_completion.to_json())

De output bevat de samenvatting van de lange tekst door de assistant, zoals in dit fragment: 

"message": {
   "content": "Excellent comfort and quality, well-ventilated, quick-drying, lightweight boots, minimal perspiration, no foul smell.",
   "role": "assistant"
},

Vragen beantwoorden

Om vragen te beantwoorden (op basis van de bovenstaande tekst), passen we de prompt aan en geven we de vraag als stringvariabele door. Net als eerder bevat de prompt ook de tekst als variabele. Het model beantwoordt de vraag op basis van de gegeven tekst. 

question = 'Are these shoes heavy?'

qna_completion = client.chat.completions.create(
    model="gpt-35-turbo", 
    messages=[
        {"role": "system",
         "content": "You are a helpful assistant for answering questions"
        },
        {
            "role": "user",
            "content": f"Answer this question: {question} in 10 words based on this text: {text}",
        },
    ],
)

Zet de output om naar JSON en print deze:

print(qna_completion.to_json())

De output bevat het antwoord van de assistant op de vraag:

"message": {
   "content": "Lightweight. Not heavy. Comfortable for long hikes. Well-ventilated Gore-tex material.",
   "role": "assistant"
},

Use cases voor Azure OpenAI

Laten we nu kijken naar de verschillende use cases voor de Azure OpenAI-service.

Natural language processing (NLP)

Omdat het in de kern taalmodellen zijn, blinken de general-purpose-modellen van OpenAI zoals GPT-3 en GPT-4 uit in NLP-taken, zoals:

• Tekstsamenvatting: Geef de API een groot stuk tekst als input en vraag om het samen te vatten naar jouw wensen. In het eerdere voorbeeld vatten we de lange klantreview samen in 10 woorden.
• Tekstclassificatie: Gegeven een document (of set documenten) en een set vooraf gedefinieerde labels, kan OpenAI het document/de documenten classificeren in het meest passende label. 
• Sentimentanalyse: De API kan de emotionele lading van invoertekst bepalen. Zo kan een klantreview worden geclassificeerd als positief, negatief of neutraal.

In het volgende voorbeeld voeren we sentimentanalyse uit om de klantreviewtekst (eerder gedefinieerd) te classificeren.

sentiment_classification = client.chat.completions.create(
    model="gpt-35-turbo", 
    messages=[
        {"role": "system",
         "content": "You are a helpful assistant for classifying customer reviews into one of the following categories: very positive, positive, neutral, negative, very negative"
        },
        {
            "role": "user",
            "content": f"Classify this review: {text}",
        },
    ],
    #max_tokens=16
)

print(sentiment_classification.to_json())

De output bevat een fragment dat lijkt op het onderstaande. Hierin staat de classificatie van de review door de assistant:

"message": {
   "content": "This review can be classified as very positive.",
   "role": "assistant"
},

Codegeneratie

OpenAI-modellen kunnen code genereren in diverse programmeertalen. In eerdere releases van OpenAI waren er aparte, code-specifieke modellen, zoals Codex en code-davinci, die waren gefinetuned voor codegeneratie. 

Echter, nieuwere releases van OpenAI, zoals GPT-3.5 en GPT-4, genereren code zonder fine-tuning. De basismodellen zijn vooraf getraind op datasets met code. Daarom zijn Codex, code-davinci en veel andere legacy-modellen afgeschaft en niet meer beschikbaar voor nieuwe deployments. 

OpenAI-modellen kunnen helpen bij het schrijven van code in veelgebruikte programmeertalen. Geef instructies in natuurlijke taal voor programmeertaken zoals: 

• Code genereren: Met een tekstprompt of commentaar kan het model een codefragment genereren. De programmeur kan verschillende fragmenten combineren tot een werkend programma. Dit helpt repetitieve taken zoals boilerplate-code automatiseren. 
• Debuggen: Het model kan fouten- en waarschuwingsberichten analyseren, het probleem in gewone taal uitleggen en suggesties geven om het op te lossen. 
• Optimaliseren: OpenAI-modellen kunnen helpen code te refactoren naar schonere structuren en efficiëntere algoritmen te gebruiken voor veelvoorkomende taken zoals sorteren. 
• Uitleggen: OpenAI-modellen kunnen ook de gegenereerde codefragmenten uitleggen. Deze toelichtingen helpen de gegenereerde code aan te passen aan de behoeften van de ontwikkelaar en kunnen beginnende programmeurs ondersteunen bij het begrijpen van concepten. 

Neem een eenvoudig voorbeeld: een Python-functie schrijven om een bestand te openen en te lezen. Dat is een veelvoorkomende taak die makkelijk te automatiseren is. We vragen OpenAI om de code te genereren en uit te leggen. Gebruik het eerder gemaakte client-object. 

code_completion = client.chat.completions.create(
    model="gpt-35-turbo", 
    messages=[
        {"role": "system",
         "content": "You are a helpful assistant for generating programming code"
        },
        {
            "role": "user",
            "content": "Write and explain a Python function to open and read a file",
        },
    ],
)

Print de output: 

print(code_completion.to_json())

Let op dat het JSON-object in de output de reactie van de assistant bevat die lijkt op het onderstaande fragment: 

"content": "Below is a Python function that opens a file, reads its contents, and returns the content as a string:\n\n```python\ndef read_file(file_path):\n    try:\n        with open(file_path, 'r') as file:\n …

Afbeeldingen genereren met DALL·E

De vorige voorbeelden waren allemaal tekstgebaseerd. Ze gebruikten OpenAI als groot taalmodel (LLM), doorgaans gebouwd met de transformer-architectuur. Naast LLMs heeft OpenAI ook diffuser-gebaseerde modellen, zoals DALL·E, die afbeeldingen genereren op basis van een inputprompt. 

Om DALL·E te gebruiken, geef je een tekstprompt met een gedetailleerde beschrijving van de gewenste afbeelding. Op basis daarvan genereert DALL·E een hoogwaardige afbeelding. Dit is nuttig voor taken zoals illustraties maken, productconcepten ontwerpen, schetsen voor marketingcampagnes en meer. 

DALL·E is momenteel niet in alle geografische regio's beschikbaar. Als het in jouw regio beschikbaar is, maak dan een nieuwe deployment aan (zoals eerder in deze tutorial uitgelegd), maar gebruik het model DALL·E-3 in plaats van GPT-3. Benader het DALL·E-model met hetzelfde eerder beschreven client-object. Gebruik de methode client.images.generate() om een afbeelding te genereren: 

• Stel de modelnaam in als dalle3 via de parameter model. 
• Beschrijf de gewenste afbeelding met de parameter prompt. 
• Je kunt ook een waarde opgeven voor n, het aantal te genereren afbeeldingen. 

result = client.images.generate(
    model="dalle3", 
    prompt="An owl wearing a Christmas hat",
    n=1
)

Haal het JSON-responseobject uit de respons van het model: 

import json
json_response = json.loads(result.model_dump_json())

Declareer de afbeeldingsmap. Let op: de map images moet bestaan onder de huidige werkmap (waar je de Python-shell hebt gestart). 

image_dir = os.path.join(os.curdir, 'images')

Specificeer het pad van de afbeelding binnen deze map:

image_path = os.path.join(image_dir, 'generated_image.png')

Haal de URL van de gegenereerde afbeelding uit het JSON-responseobject, download de afbeelding (als stream) en schrijf deze naar het afbeeldingsbestand:

image_url = json_response["data"][0]["url"]  
generated_image = requests.get(image_url).content  
with open(image_path, "wb") as image_file:
    image_file.write(generated_image)

Toon de afbeelding:

from PIL import Image

image = Image.open(image_path)
image.show()

Best practices voor het gebruik van Azure OpenAI

Het gebruik van de Azure OpenAI-service is eenvoudig, maar zoals bij elke technologie zijn er best practices om het maximale eruit te halen. We lopen ze in deze sectie door.

Het gebruik van de API monitoren en beheren

Azure OpenAI is een van de duurdere Azure-services. Zelfs het gratis tegoed voor nieuwe accounts is niet te gebruiken voor de OpenAI API. Het is dus essentieel om het gebruik te volgen, ook voor nieuwe gebruikers. Onbeheerd API-gebruik kan leiden tot onverwacht hoge rekeningen.

De kosten van OpenAI zijn gebaseerd op tokengebruik en -verbruik. Tokens zijn eenheden tekst die door het model worden verwerkt—zowel input als output. Het verwerken van een grote tekst consumeert meer tokens dan het genereren van een langer antwoord. Hoe meer tokens je gebruikt, hoe meer je betaalt. Wees daarom zuinig met de informatie die je het model geeft of laat genereren. 

Gebruik de parameter max_tokens om het aantal tokens te beperken dat in een verzoek wordt verbruikt. Bepaal voor productiemodellen experimenteel hoeveel tokens je verzoeken of gebruikers doorgaans nodig hebben en beperk het gebruik dienovereenkomstig. Verhoog de limiet per geval. 

Om de basismetrics te monitoren:

• Kies op de homepage Azure AI Services | Azure OpenAI de resource die je wilt monitoren. 
• Kies op de resourcepagina het tabblad Monitor om verschillende metrics te bekijken, zoals het aantal HTTP-verzoeken en het aantal verwerkte tokens per model en per deployment. 

Azure OpenAI-metricsdashboard.

Je kunt ook meer gedetailleerde metrics bekijken:

• Kies onder de optie Monitoring in het linkermenu Metrics. 

Gedetailleerde Azure OpenAI-metrics.

• Selecteer in de pop-up Select a scope de OpenAI-instance (vink het selectievakje aan)
• Kies Apply.

Op de pagina Metrics:

• Selecteer het tijdvenster rechtsboven. 
• Kies in de menubalk boven de (aanvankelijk lege) grafiek de juiste metric in de dropdown Metric. Kies uit metrics zoals:
• Azure OpenAI-aanvragen, 
• Statistieken over tokengebruik (actieve tokens, gegenereerde tokens, enz.)
• Prestaties van API-calls (time to first byte, enz.), en meer. 

Voorbeeld van Azure OpenAI-monitoring.

Stel tot slot altijd budgetlimieten in op API-accounts en configureer e-mailalerts wanneer je een budgetdrempel overschrijdt. 

Modellen fine-tunen

De basismodellen van OpenAI zijn getraind op enorme datasets die veel verschillende domeinen bestrijken. Grofweg zijn er drie manieren om de gewenste output van LLM-modellen te krijgen: 

• Prompt engineering: voor de meeste use-cases is het voldoende om specifieke instructies toe te voegen aan de prompt. Dit heet prompt engineering. 
• Few-shot learning: als prompt engineering niet volstaat, voeg je enkele voorbeelden toe aan de prompt om het model te helpen begrijpen welke antwoorden de gebruiker wil. Dit heet few-shot learning, waarbij het model leert op basis van een klein aantal voorbeelden. 
• Fine-tuning: soms wil je met het model praten over een heel niche domein, bijvoorbeeld op basis van een handleiding voor het repareren van gespecialiseerd apparatuur. Tekst genereren over dit onderwerp vereist jargon en taalpatronen die waarschijnlijk niet in openbare datasets voorkwamen (waarop de basismodellen zijn getraind). 

Je kunt een basismodel fine-tunen als few-shot learning en prompt engineering niet helpen om de juiste reacties te krijgen. 

Fine-tunen betekent dat je een vooraf getraind basismodel opnieuw traint op een gespecialiseerd dataset. In de praktijk worden slechts enkele lagen van het basismodel (niet het hele model) opnieuw getraind op de nieuwe data. De Azure fine-tuning-tutorial legt de stappen uit om een populair OpenAI-model te fine-tunen. 

Onthoud dat je voor succesvol fine-tunen grote hoeveelheden relevante, hoogwaardige data nodig hebt met duizenden trainingsvoorbeelden. Bovendien brengt fine-tuning onvermijdelijk hoge initiële kosten met zich mee om het model te trainen. Ook moet het gefinetunede model op jouw kosten worden gehost voordat je het uitrolt. 

Je API-sleutels beveiligen

Openbaar gemaakte API-sleutels kunnen worden misbruikt om toegang te krijgen tot gevoelige informatie, onveilige en/of illegale taken uit te voeren of ongeautoriseerde verzoeken te doen, wat kan leiden tot een hoge rekening voor de accounteigenaar. Het is daarom cruciaal om API-sleutels veilig te beheren in plaats van ze hard te coderen in de broncode. Er zijn verschillende aanpakken mogelijk: 

• Gebruik voor clouddiensten keymanagementtools zoals AWS Secrets Manager en Azure Key Vault.
• Gebruik .env-bestanden om sleutels in key-value-formaat op te slaan. Voeg dit bestand toe aan de .gitignore-lijst zodat het niet in de code-repository wordt gecommit. 
• Gebruik bij Jupyter-notebookdiensten de optie om sleutels op te slaan als onderdeel van de omgeving. Deze methode is eerder in deze tutorial beschreven. 

Ik raad aan de permissies te beperken voor welke taken de sleutels kunnen worden gebruikt. Het is ook nuttig om sleutels periodiek te roteren of opnieuw te genereren zodat oude sleutels niet kunnen worden misbruikt als ze uitlekken.

Conclusie 

In deze tutorial bespraken we starten met een Azure-account, het instellen van OpenAI-services, het maken van een nieuwe OpenAI-instance en het uitrollen van een model. Daarna bekeken we voorbeelden van praktische taken met OpenAI-modellen. Ook behandelden we hoe je het gebruik en de prestaties van Azure OpenAI-resources monitort. 

Voor meer verdieping in Microsoft Azure, volg de DataCamp Azure Fundamentals-track. Wil je meer leren over de kernconcepten van OpenAI, volg dan de DataCamp OpenAI Fundamentals-track.