Guida introduttiva: Generare un'immagine con il servizio OpenAI di Azure

Usare questa guida per iniziare a generare immagini con Azure OpenAI nel browser.

Prerequisiti

DALL-E 3
DALL-E 2 (anteprima)

Una sottoscrizione di Azure. Crearne una gratuitamente.
Una risorsa OpenAI di Azure creata in un'area supportata. Vedere Disponibilità a livello di area.
È quindi necessario distribuire un modello dalle3 con la risorsa di Azure. Per altre informazioni, vedere Creare una risorsa e distribuire un modello con Azure OpenAI.

Passa ad Azure OpenAI Studio

Passare ad Azure OpenAI Studio e accedere con le credenziali associate alla risorsa di OpenAI di Azure. Durante o dopo il flusso di lavoro di accesso, selezionare la directory appropriata, la sottoscrizione di Azure e la risorsa OpenAI di Azure.

DALL-E 3
DALL-E 2 (anteprima)

Nella pagina di destinazione di Azure OpenAI Studio selezionare Playground per le immagini per usare le API di generazione di immagini. Selezionare Impostazioni nella parte superiore della pagina e verificare che nell'elenco a discesa Distribuzione sia selezionata la distribuzione DALL-E 3.

Provare la generazione di immagini

Iniziare a esplorare le funzionalità di Azure OpenAI con un approccio senza codice tramite Playground per le immagini. Immettere il prompt dell'immagine nella casella di testo e selezionare Genera. Quando l'immagine generata dall'intelligenza artificiale è pronta, viene visualizzata nella pagina.

Nota

Le API di generazione di immagini sono dotate di un filtro di moderazione del contenuto. Se Azure OpenAI riconosce la richiesta come contenuto dannoso, non restituisce un'immagine generata. Per altre informazioni, vedere Filtro del contenuto.

In Playground per le immagini è anche possibile visualizzare esempi di codice Python e cURL, precompilati in base alle impostazioni. Selezionare Visualizza codice nella parte superiore della pagina. È possibile usare questo codice per scrivere un'applicazione che completa la stessa attività.

Pulire le risorse

Per pulire e rimuovere una risorsa OpenAI, è possibile eliminare la risorsa o il gruppo di risorse. L'eliminazione del gruppo di risorse comporta anche l'eliminazione di tutte le altre risorse associate.

Passaggi successivi

Esplorare le API di generazione di immagini in modo più approfondito con la guida pratica DALL-E.
Provare altri esempi nel repository GitHub degli esempi di OpenAI di Azure.
Vedere il riferimento API

Usare questa guida per iniziare a chiamare le API REST di generazione di immagini del servizio OpenAI di Azure usando Python.

Una sottoscrizione di Azure. Crearne una gratuitamente.
Python 3.8 o versioni successive.
Le librerie Python seguenti installate: os, requests, json.
Una risorsa OpenAI di Azure creata in un'area supportata. Vedere Disponibilità a livello di area.
È quindi necessario distribuire un modello dalle3 con la risorsa di Azure. Per altre informazioni, vedere Creare una risorsa e distribuire un modello con Azure OpenAI.

Attrezzaggio

Recuperare la chiave e l'endpoint

Per chiamare correttamente le API OpenAI di Azure, sono necessarie le informazioni seguenti sulla risorsa di OpenAI di Azure:

Variabile	Nome	Valore
Endpoint	`api_base`	Il valore dell'endpoint si trova in Chiavi ed endpoint per la risorsa nel portale di Azure. È anche possibile trovare l'endpoint tramite la pagina Distribuzioni in Azure AI Studio. Un endpoint di esempio è `https://docs-test-001.openai.azure.com/`.
Chiave	`api_key`	Il valore della chiave si trova in Chiavi ed endpoint per la risorsa nel portale di Azure. Azure genera due chiavi per la risorsa. È possibile usare indifferentemente una delle due.

Passare alla risorsa nel portale di Azure. Nel riquadro di spostamento selezionare Chiavi ed endpoint in Gestione risorse. Copiare il valore Endpoint e un valore della chiave di accesso. È possibile usare il valore KEY 1 o KEY 2. Disporre sempre di due chiavi consente di ruotare e rigenerare in modo sicuro le chiavi senza causare un'interruzione del servizio.

Variabili di ambiente

Creare e assegnare variabili di ambiente persistenti per la chiave e l'endpoint.

Importante

Se si usa una chiave API, archiviarla in modo sicuro in un'altra posizione, ad esempio in Azure Key Vault. Non includere la chiave API direttamente nel codice e non esporla mai pubblicamente.

Per altre informazioni sulla sicurezza dei servizi IA, vedere Autenticare richieste in Servizi di Azure AI.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Creare una nuova applicazione Python

Creare un nuovo file Python denominato quickstart.py. Aprire il nuovo file nell'editor preferito.

Sostituire il contenuto di quickstart.py con il codice seguente. Sostituire il valore di prompt con il testo che si preferisce.

DALL-E 3
DALL-E 2 (anteprima)

Sarà anche necessario sostituire <dalle3> nell'URL con il nome di distribuzione scelto quando è stato distribuito il modello DALL-E 3. Se si immette il nome del modello, verrà generato un errore, a meno che non sia stato scelto un nome di distribuzione identico a quello del modello sottostante. Se si verifica un errore, verificare che non sia presente un raddoppio del / alla separazione tra l'endpoint e /openai/deployments.

import requests
import time
import os
api_base = os.environ['AZURE_OPENAI_ENDPOINT']  # Enter your endpoint here
api_key = os.environ['AZURE_OPENAI_API_KEY']         # Enter your API key here

api_version = '2024-02-01'
url = f"{api_base}/openai/deployments/<dalle3>/images/generations?api-version={api_version}"
headers= { "api-key": api_key, "Content-Type": "application/json" }
body = {
    # Enter your prompt text here
    "prompt": "A multi-colored umbrella on the beach, disposable camera",
    "size": "1024x1024", # supported values are “1792x1024”, “1024x1024” and “1024x1792” 
    "n": 1, #The number of images to generate. Only n=1 is supported for DALL-E 3.
    "quality": "hd", # Options are “hd” and “standard”; defaults to standard 
    "style": "vivid" # Options are “natural” and “vivid”; defaults to “vivid”
}
submission = requests.post(url, headers=headers, json=body)

image_url = submission.json()['data'][0]['url']

print(image_url)

Lo script esegue una chiamata API di generazione di immagini sincrona.

import requests
import time
import os

api_base = os.environ['AZURE_OPENAI_ENDPOINT'] # Enter your endpoint here
api_key = os.environ['AZURE_OPENAI_API_KEY']         # Enter your API key here

# Assign the API version (DALL-E is currently supported for the 2023-06-01-preview API version only)
api_version = '2023-06-01-preview'

# Define the prompt for the image generation
url = f"{api_base}openai/images/generations:submit?api-version={api_version}"
headers= { "api-key": api_key, "Content-Type": "application/json" }
body = {
    # Enter your prompt text here
    "prompt": "a multi-colored umbrella on the beach, disposable camera",  
    "size": "1024x1024",
    "n": 1
}
submission = requests.post(url, headers=headers, json=body)

# Call the API to generate the image and retrieve the response
operation_location = submission.headers['operation-location']
status = ""
while (status != "succeeded"):
    time.sleep(1)
    response = requests.get(operation_location, headers=headers)
    status = response.json()['status']
image_url = response.json()['result']['data'][0]['url']

print(image_url)

Lo script esegue una chiamata API di generazione di immagini e quindi esegue il ciclo fino a quando l'immagine generata non sarà pronta.

Importante

Al termine, ricordarsi di rimuovere la chiave dal codice e di non renderlo mai pubblico. Per la produzione, usare un modo sicuro per archiviare e accedere alle credenziali. Per altre informazioni, vedere Azure Key Vault.

Eseguire l'applicazione con il comando python:
```
python quickstart.py
```
Attendere qualche istante per ottenere la risposta.

Output

L'output di una chiamata API di generazione di immagini ha un aspetto simile all'esempio seguente. Il campo url contiene un URL in cui è possibile scaricare l'immagine generata. L'URL rimane attivo per 24 ore.

DALL-E 3
DALL-E 2 (anteprima)

{ 
    "created": 1698116662, 
    "data": [ 
        { 
            "url": "<URL_to_generated_image>",
            "revised_prompt": "<prompt_that_was_used>" 
        }
    ]
}

{
    "created": 1685130482,
    "expires": 1685216887,
    "id": "088e4742-89e8-4c38-9833-c294a47059a3",
    "result":
    {
        "data":
        [
            {
                "url": "<URL_to_generated_image>"
            }
        ]
    },
    "status": "succeeded"
}

Le API di generazione di immagini sono dotate di un filtro di moderazione del contenuto. Se il servizio riconosce la richiesta come contenuto dannoso, non genera un'immagine. Per altre informazioni, vedere Filtro del contenuto. Per esempi di risposte agli errori, vedere la guida pratica DALL-E.

Il sistema restituirà lo stato dell'operazione di Failed e il valore error.code nel messaggio viene impostato su contentFilter. Ecco un esempio:

DALL-E 3
DALL-E 2 (anteprima)

{
    "created": 1698435368,
    "error":
    {
        "code": "contentFilter",
        "message": "Your task failed as a result of our safety system."
    }
}

{
   "created": 1589478378,
   "error": {
       "code": "contentFilter",
       "message": "Your task failed as a result of our safety system."
   },
   "id": "9484f239-9a05-41ba-997b-78252fec4b34",
   "status": "failed"
}

È anche possibile che l'immagine generata sia filtrata. In questo caso, il messaggio di errore è impostato su Generated image was filtered as a result of our safety system.. Ecco un esempio:

DALL-E 3
DALL-E 2 (anteprima)

{
    "created": 1698435368,
    "error":
    {
        "code": "contentFilter",
        "message": "Generated image was filtered as a result of our safety system."
    }
}

{
   "created": 1589478378,
   "expires": 1589478399,
   "id": "9484f239-9a05-41ba-997b-78252fec4b34",
   "lastActionDateTime": 1589478378,
   "data": [
       {
           "url": "<URL_TO_IMAGE>"
       },
       {
           "error": {
               "code": "contentFilter",
               "message": "Generated image was filtered as a result of our safety system."
           }
       }
   ],
   "status": "succeeded"
}

Pulire le risorse

Per pulire e rimuovere una risorsa OpenAI, è possibile eliminare la risorsa o il gruppo di risorse. L'eliminazione del gruppo di risorse comporta anche l'eliminazione di tutte le altre risorse associate.

Passaggi successivi

Esplorare le API di generazione di immagini in modo più approfondito con la guida pratica DALL-E.
Provare altri esempi nel repository GitHub degli esempi di OpenAI di Azure.
Vedere il riferimento API

Usare questa guida per iniziare a generare immagini con SDK di Azure OpenAI per Python.

Codice sorgente della libreria | Pacchetto | Esempi

Prerequisiti

DALL-E 3
DALL-E 2 (anteprima)

Una sottoscrizione di Azure. Crearne una gratuitamente.
Python 3.8 o versioni successive.
Una risorsa OpenAI di Azure creata in un'area compatibile. Vedere Disponibilità a livello di area.
È quindi necessario distribuire un modello dalle3 con la risorsa di Azure. Per altre informazioni, vedere Creare una risorsa e distribuire un modello con Azure OpenAI.

Attrezzaggio

Recuperare la chiave e l'endpoint

Per chiamare correttamente le API OpenAI di Azure, sono necessarie le informazioni seguenti sulla risorsa di OpenAI di Azure:

Variabile	Nome	Valore
Endpoint	`api_base`	Il valore dell'endpoint si trova in Chiavi ed endpoint per la risorsa nel portale di Azure. È anche possibile trovare l'endpoint tramite la pagina Distribuzioni in Azure AI Studio. Un endpoint di esempio è `https://docs-test-001.openai.azure.com/`.
Chiave	`api_key`	Il valore della chiave si trova in Chiavi ed endpoint per la risorsa nel portale di Azure. Azure genera due chiavi per la risorsa. È possibile usare indifferentemente una delle due.

Passare alla risorsa nel portale di Azure. Nel riquadro di spostamento selezionare Chiavi ed endpoint in Gestione risorse. Copiare il valore Endpoint e un valore della chiave di accesso. È possibile usare il valore KEY 1 o KEY 2. Disporre sempre di due chiavi consente di ruotare e rigenerare in modo sicuro le chiavi senza causare un'interruzione del servizio.

Variabili di ambiente

Creare e assegnare variabili di ambiente persistenti per la chiave e l'endpoint.

Importante

Se si usa una chiave API, archiviarla in modo sicuro in un'altra posizione, ad esempio in Azure Key Vault. Non includere la chiave API direttamente nel codice e non esporla mai pubblicamente.

Per altre informazioni sulla sicurezza dei servizi IA, vedere Autenticare richieste in Servizi di Azure AI.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Installare l'SDK per Python

Aprire un prompt dei comandi e passare alla cartella del progetto. Installare OpenAI Python SDK usando il comando seguente:

DALL-E 3
DALL-E 2 (anteprima)

pip install openai

Importante

La versione più recente della libreria Python OpenAI attualmente non supporta DALL-E 2 quando viene usata con Azure OpenAI. Per accedere a DALL-E 2 con Azure OpenAI, usare la versione 0.28.1. In alternativa, seguire la guida alla migrazione per usare DALL-E 2 con OpenAI 1.x.

pip install openai==0.28.1

Installare anche le librerie seguenti:

pip install requests
pip install pillow

Generare immagini con DALL-E

Creare un nuovo file Python quickstart.py. Aprirlo nell'editor o nell'IDE preferito.

Sostituire il contenuto di quickstart.py con il codice seguente.

DALL-E 3
DALL-E 2 (anteprima)

from openai import AzureOpenAI
import os
import requests
from PIL import Image
import json

client = AzureOpenAI(
    api_version="2024-02-01",  
    api_key=os.environ["AZURE_OPENAI_API_KEY"],  
    azure_endpoint=os.environ['AZURE_OPENAI_ENDPOINT']
)

result = client.images.generate(
    model="dalle3", # the name of your DALL-E 3 deployment
    prompt="a close-up of a bear walking throughthe forest",
    n=1
)

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

# Set the directory for the stored image
image_dir = os.path.join(os.curdir, 'images')

# If the directory doesn't exist, create it
if not os.path.isdir(image_dir):
    os.mkdir(image_dir)

# Initialize the image path (note the filetype should be png)
image_path = os.path.join(image_dir, 'generated_image.png')

# Retrieve the generated image
image_url = json_response["data"][0]["url"]  # extract image URL from response
generated_image = requests.get(image_url).content  # download the image
with open(image_path, "wb") as image_file:
    image_file.write(generated_image)

# Display the image in the default image viewer
image = Image.open(image_path)
image.show()

Immettere l'URL e la chiave dell'endpoint nei campi appropriati.
Sostituire il valore di prompt con il testo che si preferisce.
Modificare il valore di model con il nome del modello DALL-E 3 distribuito.

import openai
import os
import requests
from PIL import Image

# Get endpoint and key from environment variables
openai.api_base = os.environ['AZURE_OPENAI_ENDPOINT']
openai.api_key = os.environ['AZURE_OPENAI_API_KEY']     

# Assign the API version (DALL-E is currently supported for the 2023-06-01-preview API version only)
openai.api_version = '2023-06-01-preview'
openai.api_type = 'azure'

# Create an image by using the image generation API
generation_response = openai.Image.create(
    prompt='A painting of a dog',    # Enter your prompt text here
    size='1024x1024',
    n=2
)

# Set the directory for the stored image
image_dir = os.path.join(os.curdir, 'images')

# If the directory doesn't exist, create it
if not os.path.isdir(image_dir):
    os.mkdir(image_dir)

# Initialize the image path (note the filetype should be png)
image_path = os.path.join(image_dir, 'generated_image.png')

# Retrieve the generated image
image_url = generation_response["data"][0]["url"]  # extract image URL from response
generated_image = requests.get(image_url).content  # download the image
with open(image_path, "wb") as image_file:
    image_file.write(generated_image)

# Display the image in the default image viewer
image = Image.open(image_path)
image.show()

Immettere l'URL e la chiave dell'endpoint nei campi appropriati.
Sostituire il valore di prompt con il testo che si preferisce.

Importante

Al termine, ricordarsi di rimuovere la chiave dal codice e di non renderlo mai pubblico. Per la produzione, usare un modo sicuro per archiviare e accedere alle credenziali. Per altre informazioni, vedere Azure Key Vault.

Eseguire l'applicazione con il comando python:

python quickstart.py

Attendere qualche istante per ottenere la risposta.

Output

Azure OpenAI archivia l'immagine di output nel file generated_image.png nella directory specificata. Lo script visualizza anche l'immagine nel visualizzatore di immagini predefinito.

Le API di generazione di immagini sono dotate di un filtro di moderazione del contenuto. Se il servizio riconosce la richiesta come contenuto dannoso, non genera un'immagine. Per altre informazioni, vedere Filtro del contenuto.

Pulire le risorse

Per pulire e rimuovere una risorsa OpenAI, è possibile eliminare la risorsa o il gruppo di risorse. L'eliminazione del gruppo di risorse comporta anche l'eliminazione di tutte le altre risorse associate.

Passaggi successivi

Esplorare le API di generazione di immagini in modo più approfondito con la guida pratica DALL-E.
Provare altri esempi nel repository GitHub degli esempi di OpenAI di Azure.
Vedere il riferimento API

Usare questa guida per iniziare a generare immagini con SDK di Azure OpenAI per C#.

Codice sorgente della libreria | Pacchetto (NuGet) | Esempi

Prerequisiti

Una sottoscrizione di Azure: creare un account gratuitamente
L’SDK .NET 7
Una risorsa OpenAI di Azure creata in un'area supportata (vedere Disponibilità dell'area). Per altre informazioni, vedere Creare una risorsa e distribuire un modello con Azure OpenAI.

Attrezzaggio

Recuperare la chiave e l'endpoint

Per effettuare correttamente una chiamata ad Azure OpenAI, sono necessari un endpoint e una chiave.

Nome variabile	Valore
`ENDPOINT`	L'endpoint di servizio è disponibile nella sezione Chiavi ed endpoint quando si esamina la risorsa dal portale di Azure. In alternativa, è possibile trovare l'endpoint tramite la pagina Distribuzioni in Azure AI Studio. Un endpoint di esempio è `https://docs-test-001.openai.azure.com/`.
`API-KEY`	Questo valore è disponibile nella sezione Chiavi ed endpoint durante l'esame della risorsa dalla portale di Azure. Puoi usare entrambi `KEY1` o `KEY2`.

Passare alla risorsa nel portale di Azure. La sezione Chiavi ed endpoint è disponibile nella sezione Gestione risorse. Copiare l'endpoint e la chiave di accesso in base alle esigenze per l'autenticazione delle chiamate API. Puoi usare entrambi KEY1 o KEY2. Disporre sempre di due chiavi consente di ruotare e rigenerare in modo sicuro le chiavi senza causare un'interruzione del servizio.

Variabili di ambiente

Creare e assegnare variabili di ambiente persistenti per la chiave e l'endpoint.

Importante

Se si usa una chiave API, archiviarla in modo sicuro in un'altra posizione, ad esempio in Azure Key Vault. Non includere la chiave API direttamente nel codice e non esporla mai pubblicamente.

Per altre informazioni sulla sicurezza dei servizi IA, vedere Autenticare richieste in Servizi di Azure AI.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Creare una nuova applicazione .NET Core

In una finestra di una console, ad esempio cmd, PowerShell o Bash, usare il comando dotnet new per creare una nuova app console con il nome azure-openai-quickstart. Questo comando crea un semplice progetto "Hello World" con un singolo file di origine C#: program.cs.

dotnet new console -n azure-openai-quickstart

Spostarsi nella cartella dell'app appena creata. È possibile compilare l'applicazione con il comando seguente:

dotnet build

L'output di compilazione non deve contenere alcun avviso o errore.

...
Build succeeded.
 0 Warning(s)
 0 Error(s)
...

Installare OpenAI .NET SDK

Installare la libreria client con:

dotnet add package Azure.AI.OpenAI --version 1.0.0-beta.6

Generare immagini con DALL-E

Dalla directory del progetto, aprire il file program.cs e sostituire i contenuti con il codice seguente:

using Azure;
using Azure.AI.OpenAI;
using OpenAI.Images;
using static System.Environment;

string endpoint = GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT");
string key = GetEnvironmentVariable("AZURE_OPENAI_API_KEY");

AzureOpenAIClient azureClient = new(
    new Uri(endpoint),
    new AzureKeyCredential(key));

// This must match the custom deployment name you chose for your model
ImageClient chatClient = azureClient.GetImageClient("dalle-3");

var imageGeneration = await chatClient.GenerateImageAsync(
        "a happy monkey sitting in a tree, in watercolor",
        new ImageGenerationOptions()
        {
            Size = GeneratedImageSize.W1024xH1024
        }
    );

Console.WriteLine(imageGeneration.Value.ImageUri);

Compilare ed eseguire l'applicazione dalla directory dell'applicazione con i seguenti comandi:

dotnet build
dotnet run

Output

L'URL dell'immagine generata viene stampato nella console.

https://dalleproduse.blob.core.windows.net/private/images/b7ac5e55-f1f8-497a-8d0e-8f51446bf538/generated_00.png?se=2024-07-12T13%3A47%3A56Z&sig=Zri37iYVTVtc52qzTFBOqPgSHvXwEhcO86Smv2ojB%2FE%3D&ske=2024-07-17T12%3A15%3A44Z&skoid=09ba021e-c417-441c-b203-c81e5dcd7b7f&sks=b&skt=2024-07-10T12%3A15%3A44Z&sktid=33e01921-4d64-4f8c-a055-5bdaffd5e33d&skv=2020-10-02&sp=r&spr=https&sr=b&sv=2020-10-02

Nota

Le API di generazione di immagini sono dotate di un filtro di moderazione del contenuto. Se il servizio riconosce la richiesta come contenuto dannoso, non restituirà un'immagine generata. Per altre informazioni, vedere l'articolo Filtro contenuto.

Pulire le risorse

Se si vuole ripulire e rimuovere una risorsa OpenAI di Azure, è possibile eliminare la risorsa. Prima di eliminare la risorsa, è necessario eliminare i modelli distribuiti.

Passaggi successivi

Esplorare le API di generazione di immagini in modo più approfondito con la guida pratica DALL-E.
Per altri esempi, vedere il repository GitHub degli esempi di OpenAI di Azure.

Usare questa guida per iniziare a generare immagini con SDK di Azure OpenAI per Java.

Codice sorgente libreria | Artefatto (Maven) | Esempi

Prerequisiti

Una sottoscrizione di Azure: creare un account gratuitamente
La versione più recente di Java Development Kit (JDK)
Lo strumento di compilazione Gradle o un'altra utilità di gestione dipendenze.
Una risorsa OpenAI di Azure creata in un'area supportata (vedere Disponibilità dell'area). Per altre informazioni, vedere Creare una risorsa e distribuire un modello con Azure OpenAI.

Attrezzaggio

Recuperare la chiave e l'endpoint

Per effettuare correttamente una chiamata ad Azure OpenAI, sono necessari un endpoint e una chiave.

Nome variabile	Valore
`ENDPOINT`	L'endpoint di servizio è disponibile nella sezione Chiavi ed endpoint quando si esamina la risorsa dal portale di Azure. In alternativa, è possibile trovare l'endpoint tramite la pagina Distribuzioni in Azure AI Studio. Un endpoint di esempio è `https://docs-test-001.openai.azure.com/`.
`API-KEY`	Questo valore è disponibile nella sezione Chiavi ed endpoint durante l'esame della risorsa dalla portale di Azure. Puoi usare entrambi `KEY1` o `KEY2`.

Passare alla risorsa nel portale di Azure. La sezione Chiavi ed endpoint è disponibile nella sezione Gestione risorse. Copiare l'endpoint e la chiave di accesso in base alle esigenze per l'autenticazione delle chiamate API. Puoi usare entrambi KEY1 o KEY2. Disporre sempre di due chiavi consente di ruotare e rigenerare in modo sicuro le chiavi senza causare un'interruzione del servizio.

Variabili di ambiente

Creare e assegnare variabili di ambiente persistenti per la chiave e l'endpoint.

Importante

Se si usa una chiave API, archiviarla in modo sicuro in un'altra posizione, ad esempio in Azure Key Vault. Non includere la chiave API direttamente nel codice e non esporla mai pubblicamente.

Per altre informazioni sulla sicurezza dei servizi IA, vedere Autenticare richieste in Servizi di Azure AI.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Creare una nuova applicazione Java

Creare un nuovo progetto Gradle.

In una finestra della console, ad esempio cmd, PowerShell o Bash, creare e passare a una nuova directory per l'app.

mkdir myapp && cd myapp

Eseguire il comando gradle init dalla directory di lavoro. Questo comando creerà i file di compilazione essenziali per Gradle, tra cui build.gradle.kts, che viene usato in fase di esecuzione per creare e configurare l'applicazione.

gradle init --type basic

Quando viene chiesto di scegliere un linguaggio DSL, selezionare Kotlin.

Installare Java SDK

Questo argomento di avvio rapido usa l'utilità di gestione dipendenze Gradle. La libreria client e le informazioni per altre utilità di gestione dipendenze sono disponibili in Maven Central Repository.

Individuare il file build.gradle.kts e aprirlo con un IDE o un editor di testo a scelta. Quindi copiare la configurazione di compilazione seguente. Questa configurazione definisce il progetto come applicazione Java il cui punto di ingresso è la classe OpenAIQuickstart. Importa la libreria di Visione artificiale di Azure.

plugins {
    java
    application
}
application { 
    mainClass.set("OpenAIQuickstart")
}
repositories {
    mavenCentral()
}
dependencies {
    implementation(group = "com.azure", name = "azure-ai-openai", version = "1.0.0-beta.3")
    implementation("org.slf4j:slf4j-simple:1.7.9")
}

Generare immagini con DALL-E

Creare un file Java

Dalla directory di lavoro eseguire il comando seguente per creare una cartella di origine del progetto:
```
mkdir -p src/main/java
```
Passare alla nuova cartella e creare un file denominato OpenAIQuickstart.java.

Aprire OpenAIQuickstart.java nell'editor o nell'IDE preferito e incollare il codice seguente.

import com.azure.ai.openai.OpenAIAsyncClient;
import com.azure.ai.openai.OpenAIClientBuilder;
import com.azure.ai.openai.models.ImageGenerationOptions;
import com.azure.ai.openai.models.ImageLocation;
import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.models.ResponseError;

import java.util.concurrent.TimeUnit;

/**
 * Sample demonstrates how to get the images for a given prompt.
 */
public class OpenAIQuickstart {

    /**
     * Runs the sample algorithm and demonstrates how to get the images for a given prompt.
     *
     * @param args Unused. Arguments to the program.
     */
    public static void main(String[] args) throws InterruptedException {

        // Get key and endpoint from environment variables:
        String azureOpenaiKey = System.getenv("AZURE_OPENAI_API_KEY");
        String endpoint = System.getenv("AZURE_OPENAI_ENDPOINT");

        OpenAIAsyncClient client = new OpenAIClientBuilder()
            .endpoint(endpoint)
            .credential(new AzureKeyCredential(azureOpenaiKey))
            .buildAsyncClient();

        ImageGenerationOptions imageGenerationOptions = new ImageGenerationOptions(
            "A drawing of the Seattle skyline in the style of Van Gogh");
        client.getImages(imageGenerationOptions).subscribe(
            images -> {
                for (ImageLocation imageLocation : images.getData()) {
                    ResponseError error = imageLocation.getError();
                    if (error != null) {
                        System.out.printf("Image generation operation failed. Error code: %s, error message: %s.%n",
                            error.getCode(), error.getMessage());
                    } else {
                        System.out.printf(
                            "Image location URL that provides temporary access to download the generated image is %s.%n",
                            imageLocation.getUrl());
                    }
                }
            },
            error -> System.err.println("There was an error getting images." + error),
            () -> System.out.println("Completed getImages."));

        // The .subscribe() creation and assignment is not a blocking call. For the purpose of this example, we sleep
        // the thread so the program does not end before the send operation is complete. Using .block() instead of
        // .subscribe() will turn this into a synchronous call.
        TimeUnit.SECONDS.sleep(10);
    }
}

Tornare alla cartella radice del progetto e compilare l'app con:
```
gradle build
```
Eseguirlo quindi con il comando gradle run:
```
gradle run
```

Output

L'URL dell'immagine generata viene stampato nella console.

Image location URL that provides temporary access to download the generated image is https://dalleproduse.blob.core.windows.net/private/images/d2ea917f-8802-4ad6-8ef6-3fb7a15c8482/generated_00.png?se=2023-08-25T23%3A11%3A28Z&sig=%2BKa5Mkb9U88DfvxoBpyAjamYRzwb7aVCEucM6XJC3wQ%3D&ske=2023-08-31T15%3A27%3A47Z&skoid=09ba021e-c417-441c-b203-c81e5dcd7b7f&sks=b&skt=2023-08-24T15%3A27%3A47Z&sktid=33e01921-4d64-4f8c-a055-5bdaffd5e33d&skv=2020-10-02&sp=r&spr=https&sr=b&sv=2020-10-02.
Completed getImages.

Nota

Le API di generazione di immagini sono dotate di un filtro di moderazione del contenuto. Se il servizio riconosce la richiesta come contenuto dannoso, non restituirà un'immagine generata. Per altre informazioni, vedere l'articolo Filtro contenuto.

Pulire le risorse

Se si vuole ripulire e rimuovere una risorsa OpenAI di Azure, è possibile eliminare la risorsa. Prima di eliminare la risorsa, è necessario eliminare i modelli distribuiti.

Passaggi successivi

Esplorare le API di generazione di immagini in modo più approfondito con la guida pratica DALL-E.
Per altri esempi, vedere il repository GitHub degli esempi di OpenAI di Azure

Usare questa guida per iniziare a generare immagini con SDK di Azure OpenAI per JavaScript.

Documentazione di riferimento | Codice sorgente | Pacchetto (npm) | Campioni

Prerequisiti

Una sottoscrizione di Azure: creare un account gratuitamente
Versioni LTS di Node.js
Interfaccia della riga di comando di Azure usata per l'autenticazione senza password in un ambiente di sviluppo locale, creare il contesto necessario eseguendo l'accesso tramite l'interfaccia della riga di comando di Azure.
Una risorsa OpenAI di Azure creata in un'area supportata (vedere Disponibilità dell'area). Per altre informazioni, vedere Creare una risorsa e distribuire un modello con Azure OpenAI.

Attrezzaggio

Recuperare la chiave e l'endpoint

Per effettuare correttamente una chiamata ad Azure OpenAI, sono necessari un endpoint e una chiave.

Nome variabile	Valore
`ENDPOINT`	L'endpoint di servizio è disponibile nella sezione Chiavi ed endpoint quando si esamina la risorsa dal portale di Azure. In alternativa, è possibile trovare l'endpoint tramite la pagina Distribuzioni in Azure AI Studio. Un endpoint di esempio è `https://docs-test-001.openai.azure.com/`.
`API-KEY`	Questo valore è disponibile nella sezione Chiavi ed endpoint durante l'esame della risorsa dalla portale di Azure. Puoi usare entrambi `KEY1` o `KEY2`.

Passare alla risorsa nel portale di Azure. La sezione Chiavi ed endpoint è disponibile nella sezione Gestione risorse. Copiare l'endpoint e la chiave di accesso in base alle esigenze per l'autenticazione delle chiamate API. Puoi usare entrambi KEY1 o KEY2. Disporre sempre di due chiavi consente di ruotare e rigenerare in modo sicuro le chiavi senza causare un'interruzione del servizio.

Variabili di ambiente

Creare e assegnare variabili di ambiente persistenti per la chiave e l'endpoint.

Importante

Se si usa una chiave API, archiviarla in modo sicuro in un'altra posizione, ad esempio in Azure Key Vault. Non includere la chiave API direttamente nel codice e non esporla mai pubblicamente.

Per altre informazioni sulla sicurezza dei servizi IA, vedere Autenticare richieste in Servizi di Azure AI.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Creare un'applicazione Node

In una finestra della console, ad esempio cmd, PowerShell o Bash, creare e passare a una nuova directory per l'app. Quindi, eseguire il comando npm init per creare un'applicazione node con un file package.json.

npm init

Installare la libreria client

Installare le librerie client con:

npm install openai @azure/identity

Il file package.json dell'app verrà aggiornato con le dipendenze.

Generare immagini con DALL-E

Creare un nuovo file denominato ImageGeneration.js e aprirlo nell'editor di codice preferito. Copiare il codice seguente nel file ImageGeneration.js:

Microsoft Entra ID
Chiave API

const { AzureOpenAI } = require("openai");
const { 
    DefaultAzureCredential, 
    getBearerTokenProvider 
} = require("@azure/identity");

// You will need to set these environment variables or edit the following values
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"];

// Required Azure OpenAI deployment name and API version
const apiVersion = "2024-07-01";
const deploymentName = "dall-e-3";

// The prompt to generate images from
const prompt = "a monkey eating a banana";
const numberOfImagesToGenerate = 1;

// keyless authentication    
const credential = new DefaultAzureCredential();
const scope = "https://cognitiveservices.azure.com/.default";
const azureADTokenProvider = getBearerTokenProvider(credential, scope);

function getClient(): AzureOpenAI {
  return new AzureOpenAI({
    endpoint,
    azureADTokenProvider,
    apiVersion,
    deployment: deploymentName,
  });
}
async function main() {
  console.log("== Image Generation ==");

  const client = getClient();

  const results = await client.images.generate({
    prompt,
    size: "1024x1024",
    n: numberOfImagesToGenerate,
    model: "",
    style: "vivid", // or "natural"
  });

  for (const image of results.data) {
    console.log(`Image generation result URL: ${image.url}`);
  }
}

main().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Eseguire lo script con il comando seguente:

node ImageGeneration.js

const { AzureOpenAI } = require("openai");

// You will need to set these environment variables or edit the following values
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"];
const apiKey = process.env["AZURE_OPENAI_API_KEY"];

// Required Azure OpenAI deployment name and API version
const apiVersion = "2024-07-01";
const deploymentName = "dall-e-3";

// The prompt to generate images from
const prompt = "a monkey eating a banana";
const numberOfImagesToGenerate = 1;

function getClient() {
  return new AzureOpenAI({
    endpoint,
    apiKey,
    apiVersion,
    deployment: deploymentName,
  });
}
async function main() {
  console.log("== Image Generation ==");

  const client = getClient();

  const results = await client.images.generate({
    prompt,
    size: "1024x1024",
    n: numberOfImagesToGenerate,
    model: "",
    style: "vivid", // or "natural"
  });

  for (const image of results.data) {
    console.log(`Image generation result URL: ${image.url}`);
  }
}

main().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Eseguire lo script con il comando seguente:

node ImageGeneration.js

Output

L'URL dell'immagine generata viene stampato nella console.

== Batch Image Generation ==
Image generation result URL: https://dalleproduse.blob.core.windows.net/private/images/5e7536a9-a0b5-4260-8769-2d54106f2913/generated_00.png?se=2023-08-29T19%3A12%3A57Z&sig=655GkWajOZ9ALjFykZF%2FBMZRPQALRhf4UPDImWCQoGI%3D&ske=2023-09-02T18%3A53%3A23Z&skoid=09ba021e-c417-441c-b203-c81e5dcd7b7f&sks=b&skt=2023-08-26T18%3A53%3A23Z&sktid=33e01921-4d64-4f8c-a055-5bdaffd5e33d&skv=2020-10-02&sp=r&spr=https&sr=b&sv=2020-10-02
Image generation result URL: https://dalleproduse.blob.core.windows.net/private/images/5e7536a9-a0b5-4260-8769-2d54106f2913/generated_01.png?se=2023-08-29T19%3A12%3A57Z&sig=B24ymPLSZ3HfG23uojOD9VlRFGxjvgcNmvFo4yPUbEc%3D&ske=2023-09-02T18%3A53%3A23Z&skoid=09ba021e-c417-441c-b203-c81e5dcd7b7f&sks=b&skt=2023-08-26T18%3A53%3A23Z&sktid=33e01921-4d64-4f8c-a055-5bdaffd5e33d&skv=2020-10-02&sp=r&spr=https&sr=b&sv=2020-10-02

Nota

Le API di generazione di immagini sono dotate di un filtro di moderazione del contenuto. Se il servizio riconosce la richiesta come contenuto dannoso, non restituirà un'immagine generata. Per altre informazioni, vedere l'articolo Filtro contenuto.

Pulire le risorse

Se si vuole ripulire e rimuovere una risorsa OpenAI di Azure, è possibile eliminare la risorsa. Prima di eliminare la risorsa, è necessario eliminare i modelli distribuiti.

Passaggi successivi

Esplorare le API di generazione di immagini in modo più approfondito con la guida pratica DALL-E.
Per altri esempi, vedere il repository GitHub degli esempi di OpenAI di Azure.

Usare questa guida per iniziare a generare immagini con SDK di Azure OpenAI per JavaScript.

Documentazione di riferimento | Codice sorgente | Pacchetto (npm) | Campioni

Prerequisiti

Una sottoscrizione di Azure: creare un account gratuitamente
Versioni LTS di Node.js
TypeScript
Interfaccia della riga di comando di Azure usata per l'autenticazione senza password in un ambiente di sviluppo locale, creare il contesto necessario eseguendo l'accesso tramite l'interfaccia della riga di comando di Azure.
Una risorsa OpenAI di Azure creata in un'area supportata (vedere Disponibilità dell'area). Per altre informazioni, vedere Creare una risorsa e distribuire un modello con Azure OpenAI.

Attrezzaggio

Recuperare la chiave e l'endpoint

Per effettuare correttamente una chiamata ad Azure OpenAI, sono necessari un endpoint e una chiave.

Nome variabile	Valore
`ENDPOINT`	L'endpoint di servizio è disponibile nella sezione Chiavi ed endpoint quando si esamina la risorsa dal portale di Azure. In alternativa, è possibile trovare l'endpoint tramite la pagina Distribuzioni in Azure AI Studio. Un endpoint di esempio è `https://docs-test-001.openai.azure.com/`.
`API-KEY`	Questo valore è disponibile nella sezione Chiavi ed endpoint durante l'esame della risorsa dalla portale di Azure. Puoi usare entrambi `KEY1` o `KEY2`.

Passare alla risorsa nel portale di Azure. La sezione Chiavi ed endpoint è disponibile nella sezione Gestione risorse. Copiare l'endpoint e la chiave di accesso in base alle esigenze per l'autenticazione delle chiamate API. Puoi usare entrambi KEY1 o KEY2. Disporre sempre di due chiavi consente di ruotare e rigenerare in modo sicuro le chiavi senza causare un'interruzione del servizio.

Variabili di ambiente

Creare e assegnare variabili di ambiente persistenti per la chiave e l'endpoint.

Importante

Se si usa una chiave API, archiviarla in modo sicuro in un'altra posizione, ad esempio in Azure Key Vault. Non includere la chiave API direttamente nel codice e non esporla mai pubblicamente.

Per altre informazioni sulla sicurezza dei servizi IA, vedere Autenticare richieste in Servizi di Azure AI.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Creare un'applicazione Node

In una finestra della console, ad esempio cmd, PowerShell o Bash, creare e passare a una nuova directory per l'app. Quindi, eseguire il comando npm init per creare un'applicazione node con un file package.json.

npm init

Installare la libreria client

Installare le librerie client con:

npm install openai @azure/identity

Il file package.json dell'app verrà aggiornato con le dipendenze.

Generare immagini con DALL-E

Creare un nuovo file denominato ImageGeneration.ts e aprirlo nell'editor di codice preferito. Copiare il codice seguente nel file ImageGeneration.ts :

Microsoft Entra ID
Chiave API

import { AzureOpenAI } from "openai";
import { 
    DefaultAzureCredential, 
    getBearerTokenProvider 
} from "@azure/identity";

// You will need to set these environment variables or edit the following values
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"];

// Required Azure OpenAI deployment name and API version
const apiVersion = "2024-07-01";
const deploymentName = "dall-e-3";

// keyless authentication    
const credential = new DefaultAzureCredential();
const scope = "https://cognitiveservices.azure.com/.default";
const azureADTokenProvider = getBearerTokenProvider(credential, scope);

function getClient(): AzureOpenAI {
  return new AzureOpenAI({
    endpoint,
    azureADTokenProvider,
    apiVersion,
    deployment: deploymentName,
  });
}
async function main() {
  console.log("== Image Generation ==");

  const client = getClient();

  const results = await client.images.generate({
    prompt,
    size: "1024x1024",
    n: numberOfImagesToGenerate,
    model: "",
    style: "vivid", // or "natural"
  });

  for (const image of results.data) {
    console.log(`Image generation result URL: ${image.url}`);
  }
}

main().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Compilare l'applicazione con il comando seguente:
```
tsc
```
Eseguire l'applicazione con il comando seguente:
```
node ImageGeneration.js
```

import { AzureOpenAI } from "openai";

// You will need to set these environment variables or edit the following values
const endpoint = process.env["AZURE_OPENAI_ENDPOINT"];
const apiKey = process.env["AZURE_OPENAI_API_KEY"];

// Required Azure OpenAI deployment name and API version
const apiVersion = "2024-07-01";
const deploymentName = "dall-e-3";

// The prompt to generate images from
const prompt = "a monkey eating a banana";
const numberOfImagesToGenerate = 1;

function getClient(): AzureOpenAI {
  return new AzureOpenAI({
    endpoint,
    apiKey,
    apiVersion,
    deployment: deploymentName,
  });
}
async function main() {
  console.log("== Image Generation ==");

  const client = getClient();

  const results = await client.images.generate({
    prompt,
    size: "1024x1024",
    n: numberOfImagesToGenerate,
    model: "",
    style: "vivid", // or "natural"
  });

  for (const image of results.data) {
    console.log(`Image generation result URL: ${image.url}`);
  }
}

main().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Compilare l'applicazione con il comando seguente:
```
tsc
```
Eseguire l'applicazione con il comando seguente:
```
node ImageGeneration.js
```

Output

L'URL dell'immagine generata viene stampato nella console.

== Batch Image Generation ==
Image generation result URL: https://dalleproduse.blob.core.windows.net/private/images/5e7536a9-a0b5-4260-8769-2d54106f2913/generated_00.png?se=2023-08-29T19%3A12%3A57Z&sig=655GkWajOZ9ALjFykZF%2FBMZRPQALRhf4UPDImWCQoGI%3D&ske=2023-09-02T18%3A53%3A23Z&skoid=09ba021e-c417-441c-b203-c81e5dcd7b7f&sks=b&skt=2023-08-26T18%3A53%3A23Z&sktid=33e01921-4d64-4f8c-a055-5bdaffd5e33d&skv=2020-10-02&sp=r&spr=https&sr=b&sv=2020-10-02
Image generation result URL: https://dalleproduse.blob.core.windows.net/private/images/5e7536a9-a0b5-4260-8769-2d54106f2913/generated_01.png?se=2023-08-29T19%3A12%3A57Z&sig=B24ymPLSZ3HfG23uojOD9VlRFGxjvgcNmvFo4yPUbEc%3D&ske=2023-09-02T18%3A53%3A23Z&skoid=09ba021e-c417-441c-b203-c81e5dcd7b7f&sks=b&skt=2023-08-26T18%3A53%3A23Z&sktid=33e01921-4d64-4f8c-a055-5bdaffd5e33d&skv=2020-10-02&sp=r&spr=https&sr=b&sv=2020-10-02

Nota

Le API di generazione di immagini sono dotate di un filtro di moderazione del contenuto. Se il servizio riconosce la richiesta come contenuto dannoso, non restituirà un'immagine generata. Per altre informazioni, vedere l'articolo Filtro contenuto.

Pulire le risorse

Se si vuole ripulire e rimuovere una risorsa OpenAI di Azure, è possibile eliminare la risorsa. Prima di eliminare la risorsa, è necessario eliminare i modelli distribuiti.

Passaggi successivi

Esplorare le API di generazione di immagini in modo più approfondito con la guida pratica DALL-E.
Per altri esempi, vedere il repository GitHub degli esempi di OpenAI di Azure.

Usare questa guida per iniziare a generare immagini con SDK di Azure OpenAI per Go.

Codice sorgente della libreria | Pacchetto | Esempi

Prerequisiti

Una sottoscrizione di Azure: creare un account gratuitamente
Go 1.8+
Una risorsa OpenAI di Azure creata in un'area supportata (vedere Disponibilità dell'area). Per altre informazioni, vedere Creare una risorsa e distribuire un modello con Azure OpenAI.

Attrezzaggio

Recuperare la chiave e l'endpoint

Per effettuare correttamente una chiamata ad Azure OpenAI, sono necessari un endpoint e una chiave.

Nome variabile	Valore
`ENDPOINT`	L'endpoint di servizio è disponibile nella sezione Chiavi ed endpoint quando si esamina la risorsa dal portale di Azure. In alternativa, è possibile trovare l'endpoint tramite la pagina Distribuzioni in Azure AI Studio. Un endpoint di esempio è `https://docs-test-001.openai.azure.com/`.
`API-KEY`	Questo valore è disponibile nella sezione Chiavi ed endpoint durante l'esame della risorsa dalla portale di Azure. Puoi usare entrambi `KEY1` o `KEY2`.

Passare alla risorsa nel portale di Azure. La sezione Chiavi ed endpoint è disponibile nella sezione Gestione risorse. Copiare l'endpoint e la chiave di accesso in base alle esigenze per l'autenticazione delle chiamate API. Puoi usare entrambi KEY1 o KEY2. Disporre sempre di due chiavi consente di ruotare e rigenerare in modo sicuro le chiavi senza causare un'interruzione del servizio.

Variabili di ambiente

Creare e assegnare variabili di ambiente persistenti per la chiave e l'endpoint.

Importante

Se si usa una chiave API, archiviarla in modo sicuro in un'altra posizione, ad esempio in Azure Key Vault. Non includere la chiave API direttamente nel codice e non esporla mai pubblicamente.

Per altre informazioni sulla sicurezza dei servizi IA, vedere Autenticare richieste in Servizi di Azure AI.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Creare una nuova applicazione Go

Aprire il prompt dei comandi e passare alla cartella del progetto. Creare un nuovo file sample.go.

Installare Go SDK

Installare OpenAI Go SDK usando il comando seguente:

go get github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai@latest

Oppure, se si usa dep nell'esecuzione del repository:

dep ensure -add github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai

Generare immagini con DALL-E

Aprire sample.go nell'editor di codice preferito.

Aggiungere il codice seguente allo script:

package main

import (
	"context"
	"fmt"
	"net/http"
	"os"

	"github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
)

func main() {
	azureOpenAIKey := os.Getenv("AZURE_OPENAI_API_KEY")

	// Ex: "https://<your-azure-openai-host>.openai.azure.com"
	azureOpenAIEndpoint := os.Getenv("AZURE_OPENAI_ENDPOINT")

	if azureOpenAIKey == "" || azureOpenAIEndpoint == "" {
		fmt.Fprintf(os.Stderr, "Skipping example, environment variables missing\n")
		return
	}

	keyCredential := azcore.NewKeyCredential(azureOpenAIKey)

	client, err := azopenai.NewClientWithKeyCredential(azureOpenAIEndpoint, keyCredential, nil)

	if err != nil {
		// handle error
	}

	resp, err := client.GetImageGenerations(context.TODO(), azopenai.ImageGenerationOptions{
		Prompt:         to.Ptr("a painting of a cat in the style of Dali"),
		ResponseFormat: to.Ptr(azopenai.ImageGenerationResponseFormatURL),
	}, nil)

	if err != nil {
		// handle error
	}

	for _, generatedImage := range resp.Data {
		// the underlying type for the generatedImage is dictated by the value of
		// ImageGenerationOptions.ResponseFormat. In this example we used `azopenai.ImageGenerationResponseFormatURL`,
		// so the underlying type will be ImageLocation.

		resp, err := http.Head(*generatedImage.URL)

		if err != nil {
			// handle error
		}

		fmt.Fprintf(os.Stderr, "Image generated, HEAD request on URL returned %d\nImage URL: %s\n", resp.StatusCode, *generatedImage.URL)
	}
}

Eseguire lo script usando il comando go run:

go run sample.go

Output

L'URL dell'immagine generata viene stampato nella console.

Image generated, HEAD request on URL returned 200
Image URL: https://dalleproduse.blob.core.windows.net/private/images/d7b28a5c-ca32-4792-8c2a-6a5d8d8e5e45/generated_00.png?se=2023-08-29T17%3A05%3A37Z&sig=loqntaPypYVr9VTT5vpbsjsCz31g1GsdoQi0smbGkks%3D&ske=2023-09-02T18%3A53%3A23Z&skoid=09ba021e-c417-441c-b203-c81e5dcd7b7f&sks=b&skt=2023-08-26T18%3A53%3A23Z&sktid=33e01921-4d64-4f8c-a055-5bdaffd5e33d&skv=2020-10-02&sp=r&spr=https&sr=b&sv=2020-10-02

Nota

Le API di generazione di immagini sono dotate di un filtro di moderazione del contenuto. Se il servizio riconosce la richiesta come contenuto dannoso, non restituirà un'immagine generata. Per altre informazioni, vedere l'articolo Filtro contenuto.

Pulire le risorse

Per pulire e rimuovere una risorsa OpenAI, è possibile eliminare la risorsa o il gruppo di risorse. L'eliminazione del gruppo di risorse comporta anche l'eliminazione di tutte le altre risorse associate.

Passaggi successivi

Esplorare le API di generazione di immagini in modo più approfondito con la guida pratica DALL-E.
Per altri esempi, vedere il repository GitHub degli esempi di OpenAI di Azure.

Usare questa guida per iniziare a chiamare le API di generazione di immagini del servizio OpenAI di Azure con PowerShell.

Nota

L'API di generazione di immagini crea un'immagine da un prompt di testo. Non modifica le immagini esistenti, né ne crea varianti.

Prerequisiti

Una sottoscrizione di Azure. Crearne una gratuitamente.
Per questa attività è consigliabile la versione più recente di PowerShell 7 perché gli esempi usano nuove funzionalità non disponibili in Windows PowerShell 5.1.
Una risorsa OpenAI di Azure creata in un'area supportata (vedere Disponibilità dell'area). Per altre informazioni, vedere Creare una risorsa e distribuire un modello con Azure OpenAI.

Attrezzaggio

Recuperare la chiave e l'endpoint

Per effettuare correttamente una chiamata ad Azure OpenAI, sono necessari un endpoint e una chiave.

Nome variabile	Valore
`ENDPOINT`	L'endpoint di servizio è disponibile nella sezione Chiavi ed endpoint quando si esamina la risorsa dal portale di Azure. In alternativa, è possibile trovare l'endpoint tramite la pagina Distribuzioni in Azure AI Studio. Un endpoint di esempio è `https://docs-test-001.openai.azure.com/`.
`API-KEY`	Questo valore è disponibile nella sezione Chiavi ed endpoint durante l'esame della risorsa dalla portale di Azure. Puoi usare entrambi `KEY1` o `KEY2`.

Passare alla risorsa nel portale di Azure. La sezione Chiavi ed endpoint è disponibile nella sezione Gestione risorse. Copiare l'endpoint e la chiave di accesso in base alle esigenze per l'autenticazione delle chiamate API. Puoi usare entrambi KEY1 o KEY2. Disporre sempre di due chiavi consente di ruotare e rigenerare in modo sicuro le chiavi senza causare un'interruzione del servizio.

Variabili di ambiente

Creare e assegnare variabili di ambiente persistenti per la chiave e l'endpoint.

Importante

Se si usa una chiave API, archiviarla in modo sicuro in un'altra posizione, ad esempio in Azure Key Vault. Non includere la chiave API direttamente nel codice e non esporla mai pubblicamente.

Per altre informazioni sulla sicurezza dei servizi IA, vedere Autenticare richieste in Servizi di Azure AI.

setx AZURE_OPENAI_API_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE" 
setx AZURE_OPENAI_ENDPOINT "REPLACE_WITH_YOUR_ENDPOINT_HERE"

[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_API_KEY', 'REPLACE_WITH_YOUR_KEY_VALUE_HERE', 'User')
[System.Environment]::SetEnvironmentVariable('AZURE_OPENAI_ENDPOINT', 'REPLACE_WITH_YOUR_ENDPOINT_HERE', 'User')

export AZURE_OPENAI_API_KEY="REPLACE_WITH_YOUR_KEY_VALUE_HERE"
export AZURE_OPENAI_ENDPOINT="REPLACE_WITH_YOUR_ENDPOINT_HERE"

Generare immagini con DALL-E 2

Creare un nuovo file di PowerShell denominato quickstart.ps1. Aprire il nuovo file nell'editor preferito.

Sostituire il contenuto di quickstart.ps1 con il codice seguente. Immettere l'URL e la chiave dell'endpoint nei campi appropriati. Sostituire il valore di prompt con il testo che si preferisce.

# Azure OpenAI metadata variables
$openai = @{
  api_key     = $Env:AZURE_OPENAI_API_KEY
  api_base    = $Env:AZURE_OPENAI_ENDPOINT # your endpoint should look like the following https://YOUR_RESOURCE_NAME.openai.azure.com/
  api_version = '2023-06-01-preview' # this may change in the future
}

# Text to describe image
$prompt = 'A painting of a dog'

# Header for authentication
$headers = [ordered]@{
  'api-key' = $openai.api_key
}

# Adjust these values to fine-tune completions
$body = [ordered]@{
   prompt = $prompt
   size   = '1024x1024'
   n      = 1
} | ConvertTo-Json

 # Call the API to generate the image and retrieve the response
$url = "$($openai.api_base)/openai/images/generations:submit?api-version=$($openai.api_version)"

$submission = Invoke-RestMethod -Uri $url -Headers $headers -Body $body -Method Post -ContentType 'application/json' -ResponseHeadersVariable submissionHeaders

 $operation_location = $submissionHeaders['operation-location'][0]
 $status = ''
 while ($status -ne 'succeeded') {
     Start-Sleep -Seconds 1
     $response = Invoke-RestMethod -Uri $operation_location -Headers $headers
     $status   = $response.status
 }

# Set the directory for the stored image
$image_dir = Join-Path -Path $pwd -ChildPath 'images'

# If the directory doesn't exist, create it
if (-not(Resolve-Path $image_dir -ErrorAction Ignore)) {
    New-Item -Path $image_dir -ItemType Directory
}

# Initialize the image path (note the filetype should be png)
$image_path = Join-Path -Path $image_dir -ChildPath 'generated_image.png'

# Retrieve the generated image
$image_url = $response.result.data[0].url  # extract image URL from response
$generated_image = Invoke-WebRequest -Uri $image_url -OutFile $image_path  # download the image
return $image_path

Importante

Per la produzione, usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio La gestione dei segreti di PowerShell con Azure Key Vault. Per altre informazioni sulla sicurezza delle credenziali, vedere l'articolo sulla sicurezza dei servizi di Azure AI.

Eseguire lo script con PowerShell:
```
./quickstart.ps1
```
Lo script esegue un ciclo fino a quando l'immagine generata non sarà pronta.

Output

PowerShell richiede l'immagine da Azure OpenAI e archivia l'immagine di output nel file generated_image.png nella directory specificata. Per praticità, il percorso completo del file viene restituito alla fine dello script.

Le API di generazione di immagini sono dotate di un filtro di moderazione del contenuto. Se il servizio riconosce la richiesta come contenuto dannoso, non genera un'immagine. Per altre informazioni, vedere Filtro del contenuto.

Pulire le risorse

Per pulire e rimuovere una risorsa OpenAI, è possibile eliminare la risorsa o il gruppo di risorse. L'eliminazione del gruppo di risorse comporta anche l'eliminazione di tutte le altre risorse associate.

Passaggi successivi

Esplorare le API di generazione di immagini in modo più approfondito con la guida pratica DALL-E.

Provare altri esempi nel repository GitHub degli esempi di OpenAI di Azure.

Condividi tramite

Prerequisiti

Passa ad Azure OpenAI Studio

Provare la generazione di immagini

Pulire le risorse

Passaggi successivi

Prerequisiti

Attrezzaggio

Recuperare la chiave e l'endpoint

Variabili di ambiente

Creare una nuova applicazione Python

Output

Pulire le risorse

Passaggi successivi

Prerequisiti

Attrezzaggio

Recuperare la chiave e l'endpoint

Variabili di ambiente

Installare l'SDK per Python

Generare immagini con DALL-E

Output

Pulire le risorse

Passaggi successivi

Prerequisiti

Attrezzaggio

Recuperare la chiave e l'endpoint

Variabili di ambiente

Creare una nuova applicazione .NET Core

Installare OpenAI .NET SDK

Generare immagini con DALL-E

Output

Pulire le risorse

Passaggi successivi

Prerequisiti

Attrezzaggio

Recuperare la chiave e l'endpoint

Variabili di ambiente

Creare una nuova applicazione Java

Installare Java SDK

Generare immagini con DALL-E

Output

Pulire le risorse

Passaggi successivi

Prerequisiti

Attrezzaggio

Recuperare la chiave e l'endpoint

Variabili di ambiente

Creare un'applicazione Node

Installare la libreria client

Generare immagini con DALL-E

Output

Pulire le risorse

Passaggi successivi

Prerequisiti

Attrezzaggio

Recuperare la chiave e l'endpoint

Variabili di ambiente

Creare un'applicazione Node

Installare la libreria client

Generare immagini con DALL-E

Output

Pulire le risorse

Passaggi successivi

Prerequisiti

Attrezzaggio

Recuperare la chiave e l'endpoint

Variabili di ambiente

Creare una nuova applicazione Go

Installare Go SDK

Generare immagini con DALL-E

Output

Pulire le risorse

Passaggi successivi

Prerequisiti

Attrezzaggio

Recuperare la chiave e l'endpoint

Variabili di ambiente

Generare immagini con DALL-E 2

Output