Azure OpenAI: guida introduttiva passo dopo passo

Configurare Azure OpenAI

In questa sezione ti mostro come configurare Azure OpenAI. Presuppongo che tu abbia un po’ di esperienza con Azure. 

Tieni presente che le interfacce utente cambiano spesso. Quindi il layout e il testo di varie sezioni e titoli nelle istruzioni e negli screenshot possono cambiare nel tempo o da regione a regione.

Passaggio 1: Crea un account Azure

Vai alla home page di Azure OpenAI e seleziona Sign in in alto a destra. Accedi con il tuo account Microsoft. Se non hai un account Microsoft, seleziona l’opzione per crearne uno nuovo nella pagina di accesso e crea un account Microsoft. 

Quindi, crea un account Azure seguendo i passaggi qui sotto:

1. Accedi con il tuo account Microsoft al portale Azure. Seleziona l’opzione Start with an Azure free trial. 

Il portale Microsoft Azure.

2. Nella pagina successiva, seleziona l’opzione per creare un Azure free account con 200 $ di crediti gratuiti.

Scegli il tipo di account Azure.

3. Compila il modulo con le tue informazioni personali.

Crea un account Azure gratuito.

4. Verifica la tua identità usando una carta di credito o debito. Tieni presente che può essere addebitata una pre-autorizzazione temporanea (di solito pochi centesimi o equivalente) sul tuo conto. 

Verifica il tuo account Azure (screenshot dell’autore) 

5. Dopo aver verificato le informazioni di pagamento, seleziona Go to Azure Portal. Verrai reindirizzato al Quickstart Center.
6. Nota che i 200 $ di crediti gratuiti non possono essere utilizzati per i servizi Azure OpenAI. I modelli Azure OpenAI sono accessibili solo con un account a pagamento. Per eseguire l’upgrade del tuo account a un abbonamento a consumo, torna al portale Azure e seleziona Upgrade nella barra in alto. 

Esegui l’upgrade del tuo account Azure.

7. Compila i dettagli nella pagina di upgrade e seleziona Upgrade to pay as you go.

Dopo l’upgrade a un account a pagamento, puoi accedere ai modelli OpenAI. 

Passaggio 2: Accedi ad Azure OpenAI nel portale Azure

1. Torna al portale Azure, che mostra una varietà di servizi, come servizi di IA, macchine virtuali, account di archiviazione e altro. 

Portale Azure con i servizi disponibili.

2. Seleziona Azure AI services e vai alla home page dei servizi di IA. Azure offre vari servizi basati su IA, come riconoscimento facciale, rilevamento anomalie, speech, computer vision, OpenAI e altro. 

Servizi Azure AI.

3. Nella scheda Azure OpenAI account, seleziona l’opzione View. 
4. Si apre la pagina di Azure OpenAI, che mostra l’elenco delle istanze OpenAI del tuo account. Seleziona Create Azure OpenAI per creare una nuova istanza. Puoi anche selezionare Create nella pagina precedente. 
5. Inserisci i dettagli seguenti:
• In Subscription, seleziona il nome del tuo abbonamento a pagamento.
• In Resource group, seleziona Create new:
• Inserisci un nome per il nuovo resource group. 

Crea una nuova istanza Azure OpenAI.

• • • In Region, seleziona la regione più vicina.
    • In Name, inserisci un nome univoco. 
    • In Pricing tier, scegli Standard S0.
    • Seleziona Next per procedere.

6. Nella sezione Network, seleziona "All networks, including the Internet, can access this resource." Quindi, procedi al passaggio successivo.
7. Nella sezione Tags, inserisci coppie nome-valore per categorizzare questa istanza. Questo aiuta nella fatturazione consolidata. Questo passaggio è facoltativo. 
8. Nella sezione successiva, seleziona Review + submit, ricontrolla i valori e seleziona Create. Questo distribuisce una nuova istanza OpenAI. 
9. Dopo poco tempo, viene mostrato il messaggio "Your deployment is complete." In questa pagina, seleziona Go to resource. 
10. Nella pagina della risorsa, seleziona il nome della risorsa nella scheda Resources. 

Passaggio 3: Configura l’accesso alle API

La pagina della risorsa mostra i dettagli dell’istanza. 

La scheda Develop mostra le chiavi API e gli endpoint API per questa istanza. Le chiavi vengono generate automaticamente. 

• Copia le chiavi e l’endpoint in un file di testo.

Ricevi due chiavi API. Questo ti permette di usare la seconda chiave nel caso la prima venga compromessa. Puoi anche usare la seconda chiave mentre rigeneri la prima. In questo modo puoi ruotare periodicamente le chiavi senza subire downtime. 

Chiavi API dell’istanza Azure OpenAI

• Nella scheda Monitor, controlla le metriche di utilizzo di questa istanza. 
• Nella scheda Get Started, seleziona Explore Azure AI Foundry portal per aprire l’AI playground in una nuova pagina. 

Azure OpenAI chat playground.

• Seleziona il Chat playground dal menu a sinistra. 
• In Deployment, seleziona Create new dep.
• Seleziona From base models nel pop-up per la nuova distribuzione
• Si apre un popup che ti consente di selezionare il modello. 
• Nella barra di ricerca, digita “gpt-3”. 
• Seleziona gpt-35-turbo dall’elenco. È un modello economico ottimizzato per chat completion. Dopo aver ottenuto una configurazione funzionante, passa a un modello più avanzato (e più costoso) se necessario.
• Seleziona Confirm. 
• Nel popup Deploy model, seleziona Customize.
• Riduci il Tokens per Minute Rate Limit a un valore basso (ad esempio, 12 richieste al minuto) per i test manuali. Aumentalo in seguito quando metti il modello in produzione. 
• Disattiva la dynamic quota. Non ti serve finché la distribuzione non riceve traffico elevato. 
• Seleziona Deploy.

Distribuisci un nuovo modello nel chat playground.

Tutto qui! Nella prossima sezione vedremo come accedere a questa distribuzione del modello gpt-35-turbo di OpenAI. 

Rigenerare le chiavi API

È consigliabile rigenerare periodicamente le chiavi di accesso API. Questo garantisce che l’account non venga compromesso se chiavi vecchie vengono divulgate per errore. I passaggi seguenti descrivono come rigenerare le chiavi:

• In Resource Management, dal menu a sinistra, scegli Keys and Endpoint.
• Rigenera ciascuna chiave singolarmente. 

Chiavi API dell’istanza Azure OpenAI.

Usare Azure OpenAI nelle applicazioni

Dopo aver configurato Azure OpenAI e distribuito un modello, vediamo come accedervi in modo programmatico. 

Passaggio 1: Configurare l’ambiente di sviluppo

Ti mostrerò come usare Python per connetterti ad Azure OpenAI. Installa le librerie necessarie:

$ pip install openai

Se usi un notebook, esegui il seguente comando. Nota: sto usando un notebook DataLab.

!pip install openai

Importa i pacchetti necessari nella shell Python o nel notebook:

import os
from openai import AzureOpenAI

Il modulo AzureOpenAI consente l’accesso ai servizi OpenAI all’interno di Azure. È diverso dal modulo OpenAI usato per accedere alla API OpenAI standalone. 

Prima di usare Azure OpenAI, imposta nell’ambiente la chiave API e l’endpoint. La sezione precedente ha mostrato come trovare questi valori. In linea di principio, puoi impostarli nell’ambiente di programmazione, ma sconsiglio di farlo. Non esporre mai le chiavi API nel programma. 

Impostare le chiavi API tramite terminale

Per eseguire Python in locale, imposta la variabile d’ambiente nel file di configurazione della shell. Ti mostrerò come farlo per la shell Bash. 

• Modifica il file .bashrc in un editor di testo. 
• Alla fine del file, aggiungi queste due righe:
• export AZURE_OPENAI_API_KEY=MY_API_KEY'
• export AZURE_OPENAI_ENDPOINT=MY_ENDPOINT'
• Salva e chiudi il file.
• Ricarica le modifiche nel terminale con il comando source ~/.bashrc. 
• Per altre shell, come sh o zsh, il processo può essere leggermente diverso. 
• Apri (o riapri) la shell Python nella stessa sessione di terminale. 

Importa i valori della chiave API e dell’endpoint nel terminale Python:

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

Impostare le chiavi API usando notebook online (DataLab)

DataLab ti consente di impostare direttamente le variabili d’ambiente per un notebook.

• Dal menu in alto, seleziona Environment e poi Environment variables dal menu a discesa. 
• Seleziona l’opzione per aggiungere variabili d’ambiente. 
• Aggiungi due variabili, AZURE_OPENAI_API_KEY e AZURE_OPENAI_ENDPOINT, e i rispettivi valori. 
• Dai un nome a questo set di valori d’ambiente e salva le modifiche. 

Nel notebook, estrai questi valori come mostrato di seguito:

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

Passaggio 2: Effettua la tua prima chiamata API ad Azure OpenAI

Ora puoi usare la funzione AzureOpenAI() per creare un oggetto client che accetta richieste. Questa funzione usa i seguenti parametri:

• api_version: La versione dell’API Azure OpenAI. Controlla la versione più recente dalla documentazione Azure. 
• api_key: la chiave API di Azure OpenAI. Recuperala dalle variabili d’ambiente impostate prima. Non inserirla manualmente qui. 
• azure_endpoint: l’URL dell’endpoint API di Azure OpenAI (recupera questo valore dall’ambiente). 

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

Usa questo oggetto client per attività come la chat completion con la funzione .chat.completions.create(). Questa funzione accetta i seguenti parametri:

• model: Il nome del modello. Nelle versioni precedenti dell’API OpenAI, era il parametro engine. Nota che il parametro model deve corrispondere al modello specificato durante la distribuzione (sull’Azure AI Foundry portal). Se provi a usare un modello diverso da quello distribuito, viene generato un errore come mostrato di seguito: 

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: Questo parametro specifica la conversazione tra utente e modello. È composto da un insieme di oggetti messaggio. Ogni oggetto messaggio ha una coppia chiave-valore indicata da role (system, user o assistant) e content (il testo del messaggio). Questi oggetti messaggio forniscono contesto all’interazione e guidano le risposte del modello. 

Di seguito, riporto esempi di coppie chiave-valore (role, content) per diversi valori di role: 

• user: il prompt inserito dall’utente finale. 

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

• system: la descrizione del ruolo che OpenAI dovrebbe assumere nell’interazione. 

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

• assistant: la risposta attesa da OpenAI. 

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

Il ruolo assistant è necessario solo quando si forniscono dati di training per il fine-tuning del modello. Quando usi il client per attività come la chat completion, sono sufficienti i ruoli user e system. Per molte attività semplici, è sufficiente solo il ruolo user. 

• max_tokens: questo parametro decide il numero massimo di token che possono essere usati per elaborare (sia input che output) la chiamata API. Vieni addebitato direttamente per i token utilizzati. Il valore predefinito è 16. Questo valore è sufficiente per casi d’uso semplici; pertanto, il parametro può essere omesso. 

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",
        },
    ],
)

Stampa l’output dell’attività di chat completion:

print(simple_completion.to_json())

L’output è un oggetto JSON con varie coppie chiave-valore. Include l’output del modello, come mostrato nell’esempio qui sotto. Nota che assistant è il ruolo predefinito assegnato al modello. 

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

Passaggio 3: Utilizzare i modelli OpenAI per diverse attività

Per accedere a qualsiasi modello con Azure OpenAI, devi prima distribuirlo. Nella sezione precedente hai distribuito il modello gpt-35-turbo. Per usare un modello diverso:

• Torna a Azure AI Foundry e distribuisci un modello diverso, come spiegato nella sezione precedente. Scegli tra vari modelli come GPT-3.5, GPT-4o, o1 e o1-mini, o3 e o3-mini e altri. 
• R riscrivi i prompt sopra (nella funzione chat.completions.create()) usando il nome del nuovo modello. 

Nelle versioni precedenti di OpenAI, era comune usare modelli diversi per attività diverse. C’erano modelli dedicati alla generazione di codice, NLP e altro. I modelli moderni come GPT-3.5 e GPT-4 possono svolgere tutte le attività generative basate su testo. Pertanto, molti dei vecchi modelli specifici per attività (come i modelli davinci per la generazione di codice) sono stati dismessi. 

Ora vediamo come usare l’API per varie attività semplici come question answering e sintesi del testo. Negli esempi seguenti, usiamo lo stesso modello—GPT-3.5. Puoi anche scegliere uno dei modelli GPT-4. 

Poiché entrambe sono attività basate su testo, dichiariamo prima un blocco di testo su cui lavorare. Ho copiato arbitrariamente una recensione di un paio di scarponi da un sito di e-commerce. Assegna il testo di questa recensione a una variabile text. Assicurati di effettuare l’escape di eventuali virgolette singole o doppie presenti nel testo. 

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

Sintesi del testo 

Per riassumere il testo sopra:

• Usa l’oggetto client creato in precedenza. 
• Passa i ruoli appropriati nel parametro messages come mostrato nell’esempio seguente: 

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}",
        },
    ],
)

Nota come nel prompt passiamo il testo come variabile nello snippet sopra.

print(summary_completion.to_json())

L’output contiene il riassunto del testo lungo generato dall’assistente, come mostrato in questo estratto: 

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

Domande e risposte

Per rispondere a domande (basate sul testo di input sopra), modifichiamo il prompt per passare la domanda come variabile stringa. Come prima, il prompt include anche il testo come variabile. Il modello risponde alla domanda in base al testo fornito. 

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}",
        },
    ],
)

Converti l’output in JSON e stampalo:

print(qna_completion.to_json())

L’output include la risposta dell’assistente alla domanda:

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

Casi d’uso di Azure OpenAI

Ora vediamo i diversi casi d’uso del servizio Azure OpenAI.

Elaborazione del linguaggio naturale (NLP)

Essendo un modello linguistico alla base, i modelli generali di OpenAI come GPT-3 e GPT-4 eccellono in compiti NLP, come:

• Sintesi del testo: Fornisci all’API un testo lungo come input e chiedi di riassumerlo in base alle tue esigenze. Nell’esempio precedente, abbiamo sintetizzato una lunga recensione del cliente in un riassunto di 10 parole.
• Classificazione del testo: Dato un documento (o un insieme di documenti) e un set di etichette predefinite, OpenAI può classificare il/i documento/i nell’etichetta più appropriata. 
• Analisi del sentiment: L’API può analizzare un testo di input per valutarne il sentiment. Ad esempio, può classificare una recensione come positiva, negativa o neutra.

Nel seguente esempio, eseguiamo l’analisi del sentiment per classificare il testo della recensione del cliente (definito in precedenza).

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

L’output contiene un frammento simile all’estratto sottostante. Contiene la classificazione della recensione da parte dell’assistente:

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

Generazione di codice

I modelli OpenAI possono generare codice in vari linguaggi di programmazione. In passato, OpenAI aveva modelli specifici per il codice, come Codex e code-davinci, perfezionati per la generazione di codice. 

Tuttavia, le versioni più recenti di OpenAI, come GPT-3.5 e GPT-4, generano codice senza fine-tuning. I modelli base sono pre-addestrati su dataset di codice. Pertanto, Codex, code-davinci e molti altri modelli legacy sono stati deprecati e non sono più disponibili per nuove distribuzioni. 

I modelli OpenAI possono aiutare a scrivere codice in vari linguaggi comuni. Interagisci con il modello in linguaggio naturale per dare istruzioni su attività di programmazione come: 

• Generare codice: Dato un prompt testuale o un commento, il modello può generare uno snippet di codice. Il programmatore può combinare vari snippet in un programma funzionante. Questo aiuta ad automatizzare attività ripetitive come la scrittura di boilerplate. 
• Debug: Il modello può analizzare errori e messaggi di warning per spiegare il problema in linguaggio naturale e suggerire come risolverlo. 
• Ottimizzazione: I modelli OpenAI possono aiutare a rifattorizzare il codice in strutture più pulite e a usare algoritmi più efficienti per attività comuni come l’ordinamento. 
• Spiegazione: I modelli OpenAI possono anche spiegare gli snippet di codice che generano. Queste spiegazioni aiutano a personalizzare il codice generato in base alle esigenze dello sviluppatore. Possono anche aiutare i nuovi programmatori a comprendere i concetti di programmazione. 

Considera un semplice esempio di scrittura di una funzione Python per aprire e leggere un file. È un’attività abbastanza comune da poter essere facilmente automatizzata. Chiediamo a OpenAI di generare e spiegare il codice. Usa l’oggetto client creato in precedenza. 

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",
        },
    ],
)

Stampa l’output: 

print(code_completion.to_json())

Nota che l’oggetto JSON di output contiene l’output dell’assistente simile all’estratto d’esempio qui sotto: 

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

Generazione di immagini con DALL·E

Gli esempi precedenti erano tutti basati su testo. Usavano OpenAI come large language model (LLM), solitamente costruito con l’architettura transformer. Oltre agli LLM, OpenAI include modelli basati su diffuser, come DALL·E, che generano immagini a partire da un prompt di input. 

Per usare DALL·E, fornisci un prompt testuale con una descrizione dettagliata dell’immagine che vuoi ottenere. In base a questa descrizione, DALL·E genera un’immagine di alta qualità. È utile per attività come creare illustrazioni, progettare concept di prodotto, bozze per campagne marketing e altro. 

DALL·E non è attualmente disponibile in tutte le regioni geografiche. Se è disponibile nella tua regione, crea una nuova distribuzione (come spiegato in precedenza in questo tutorial) ma usando il modello DALL·E-3 invece di GPT-3. Accedi al modello DALL·E utilizzando lo stesso oggetto client descritto in precedenza. Usa il metodo client.images.generate() per generare un’immagine: 

• Imposta il nome del modello come dalle3 tramite il parametro model. 
• Descrivi l’immagine desiderata con il parametro prompt. 
• Puoi anche specificare un valore per n, cioè il numero di immagini da generare. 

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

Estrai l’oggetto di risposta JSON dalla risposta del modello: 

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

Dichiara la directory delle immagini. Nota che la directory images deve esistere nella directory di lavoro corrente (da cui hai avviato la shell Python). 

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

Specifica il percorso dell’immagine in questa directory:

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

Estrai l’URL dell’immagine generata dall’oggetto di risposta JSON, scarica l’immagine (come stream) e scrivila nel file immagine:

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)

Visualizza l’immagine:

from PIL import Image

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

Best practice per usare Azure OpenAI

Usare il servizio Azure OpenAI è semplice, ma come per ogni tecnologia, ci sono alcune best practice da seguire per trarne il massimo. Rivediamole in questa sezione.

Monitorare e gestire l’uso delle API

Azure OpenAI è uno dei servizi più costosi di Azure. Anche i crediti gratuiti disponibili per i nuovi account non sono utilizzabili per l’API OpenAI. È quindi essenziale tenere traccia dell’utilizzo, anche per i nuovi utenti. Un uso incontrollato dell’API può portare a fatture inaspettatamente elevate.

I costi di OpenAI si basano sull’uso e sul consumo di token. I token rappresentano unità di testo elaborate dal modello, sia in input che in output. L’elaborazione di un documento di testo lungo consuma più token rispetto alla generazione di una risposta più lunga. Più token usi, più paghi. Quindi, sii parsimonioso con le informazioni che fornisci al modello o che gli chiedi di generare. 

Usa il parametro max_tokens per limitare il numero di token consumati in quella richiesta. Per i modelli in produzione, sperimenta per determinare quanti token servono in genere alle tue richieste o ai tuoi utenti e limita l’uso di conseguenza. Aumenta il limite caso per caso. 

Per monitorare le metriche di base:

• Dalla home page Azure AI Services | Azure OpenAI, seleziona la risorsa da monitorare. 
• Nella pagina della risorsa, scegli la scheda Monitor per visualizzare varie metriche, come numero di richieste HTTP e numero di token elaborati per modello e per distribuzione. 

Dashboard delle metriche di Azure OpenAI.

Puoi anche visualizzare metriche più dettagliate:

• Dal menu a sinistra, in Monitoring, seleziona Metrics. 

Metriche dettagliate di Azure OpenAI.

• Nel pop-up Select a scope, seleziona l’istanza OpenAI (spunta la casella)
• Seleziona Apply.

Nella pagina Metrics:

• Seleziona l’intervallo temporale in alto a destra. 
• Dalla barra dei menu in alto al grafico (inizialmente vuoto), seleziona la metrica appropriata dal menu a discesa Metric. Scegli tra varie metriche come:
• Richieste di Azure OpenAI, 
• Statistiche sull’uso dei token (token attivi, token generati, ecc.)
• Prestazioni delle chiamate API (time to first byte, ecc.) e altro. 

Esempio di monitoraggio Azure OpenAI.

Infine, imposta sempre i limiti di budget sugli account API e configura le impostazioni per ricevere avvisi via email quando superi una soglia di budget. 

Fine-tuning dei modelli

I modelli base di OpenAI sono addestrati su enormi dataset che coprono molti domini diversi. In generale, ci sono tre modi per ottenere l’output desiderato dai modelli LLM: 

• Prompt engineering: Per la maggior parte dei casi d’uso, aggiungere istruzioni specifiche al prompt è sufficiente. Questo è chiamato prompt engineering. 
• Few-shot learning: Nei casi in cui il prompt engineering non basta, aggiungi alcuni esempi al prompt per aiutare il modello a capire il tipo di risposte desiderate. Questo è chiamato few-shot learning, in cui il modello apprende da un piccolo numero di esempi. 
• Fine-tuning: A volte vuoi chattare con il modello su un dominio molto di nicchia, per esempio basandoti su un manuale per riparare attrezzature specializzate. Generare testo su questo argomento implica usare gergo e pattern linguistici specifici del dominio, che è improbabile facciano parte dei dataset pubblici (su cui i modelli base sono stati addestrati). 

Puoi eseguire il fine-tuning di un modello base se few-shot learning e prompt engineering non aiutano a ottenere le risposte corrette. 

Il fine-tuning si riferisce al riaddestramento di un modello base pre-addestrato su un dataset specializzato. In pratica, solo alcuni strati del modello base (non l’intero modello) vengono riaddestrati sui nuovi dati. Il tutorial di Azure sul fine-tuning spiega i passaggi per eseguire il fine-tuning di un popolare modello OpenAI. 

Ricorda che per eseguire con successo il fine-tuning di un modello base servono grandi volumi di dati pertinenti e di alta qualità, con migliaia di esempi di training. Inoltre, il fine-tuning comporta invariabilmente alti costi iniziali per l’addestramento del modello. Inoltre, il modello ottimizzato deve essere ospitato a tue spese prima della distribuzione. 

Proteggere le tue chiavi API

Chiavi API esposte pubblicamente possono essere abusate per accedere a informazioni sensibili, svolgere attività non sicure e/o illegali, o effettuare richieste non autorizzate, con conseguenti costi elevati per il titolare dell’account. È quindi fondamentale gestire in modo sicuro le chiavi API invece di inserirle hardcoded nel sorgente. Esistono vari approcci per farlo: 

• Per i servizi cloud, usa strumenti di gestione delle chiavi come AWS Secrets Manager e Azure Key Vault.
• Usa file .env per archiviare le chiavi in formato chiave-valore. Aggiungi questo file alla lista .gitignore per evitare che venga caricato nel repository del codice. 
• Per servizi basati su Jupyter notebook usa l’opzione per archiviare le chiavi come parte dell’ambiente. Questo metodo è stato descritto in precedenza in questo tutorial. 

Consiglio di limitare i permessi per le attività per cui possono essere usate le chiavi. È anche utile ruotare o rigenerare periodicamente le chiavi in modo che quelle vecchie non possano essere usate impropriamente nel caso vengano divulgate.

Conclusione 

In questo tutorial, abbiamo parlato di come iniziare con un account Azure, configurare i servizi OpenAI, creare una nuova istanza OpenAI e distribuire un modello. Abbiamo poi visto esempi di utilizzo dei modelli OpenAI per attività pratiche. Abbiamo anche trattato come monitorare l’uso e le prestazioni delle risorse Azure OpenAI. 

Per approfondire Microsoft Azure, segui la track Azure Fundamentals di DataCamp. Per saperne di più sui concetti di base di OpenAI, segui la track OpenAI Fundamentals di DataCamp.