Rychlý start: Generování imagí pomocí služby Azure OpenAI

V tomto průvodci můžete začít generovat image pomocí Azure OpenAI v prohlížeči pomocí Azure AI Foundry.

Požadavky

Předplatné Azure. Vytvořte si ho zdarma.
Prostředek Azure OpenAI vytvořený v podporované oblasti Viz Dostupnost oblastí. Další informace najdete v tématu Vytvoření prostředku a nasazení modelu pomocí Azure OpenAI.

Přechod na Azure AI Foundry

Přejděte do Azure AI Foundry a přihlaste se pomocí přihlašovacích údajů přidružených k vašemu prostředku Azure OpenAI. Během nebo po přihlášení vyberte příslušný adresář, předplatné Azure a prostředek Azure OpenAI.

Na cílové stránce Azure AI Foundry vytvořte nebo vyberte nový projekt. V levém navigačním panelu přejděte na stránku Modely a koncové body . Vyberte Nasadit model a pak ze seznamu zvolte jeden z modelů DALL-E. Dokončete proces nasazení.

Na stránce modelu vyberte Otevřít v dětském hřišti.

Vyzkoušení generování imagí

Začněte zkoumat možnosti Azure OpenAI s přístupem bez kódu prostřednictvím dětského hřiště Images. Do textového pole zadejte výzvu k zadání obrázku a vyberte Generovat. Až bude image generovaná AI připravená, zobrazí se na stránce.

Poznámka:

Rozhraní API pro generování obrázků mají filtr kon režim stanu ration. Pokud Azure OpenAI rozpozná vaši výzvu jako škodlivý obsah, nevrátí vygenerovaný obrázek. Další informace najdete v tématu Filtrování obsahu.

Na dětském hřišti Obrázků si také můžete prohlédnout ukázky kódu Pythonu a cURL, které jsou předem vyplněné podle vašeho nastavení. Vyberte Zobrazit kód v horní části stránky. Tento kód můžete použít k napsání aplikace, která dokončí stejnou úlohu.

Vyčištění prostředků

Pokud chcete vyčistit a odebrat prostředek Azure OpenAI, můžete odstranit prostředek nebo skupinu prostředků. Odstraněním skupiny prostředků se odstraní také všechny ostatní prostředky, které jsou k ní přidružené.

Další kroky

Prozkoumejte rozhraní API pro generování imagí podrobněji pomocí průvodce postupy DALL-E.
Vyzkoušejte příklady v úložišti GitHub ukázek Azure OpenAI.
Viz referenční informace k rozhraní API

V této příručce můžete začít volat rozhraní REST API pro generování imagí služby Azure OpenAI pomocí Pythonu.

Předplatné Azure. Vytvořte si ho zdarma.
Python 3.8 nebo novější verze
Nainstalovaly se následující knihovny Pythonu: os, requests, json.
Prostředek Azure OpenAI vytvořený v podporované oblasti Viz Dostupnost oblastí.
Pak potřebujete nasadit model s prostředkem dalle3 Azure. Další informace najdete v tématu Vytvoření prostředku a nasazení modelu pomocí Azure OpenAI.

Nastavení

Načtení klíče a koncového bodu

K úspěšnému volání rozhraní API Azure OpenAI potřebujete následující informace o prostředku Azure OpenAI:

Proměnná	Jméno	Hodnota
Endpoint	`api_base`	Hodnota koncového bodu se nachází v části Klíče a koncový bod vašeho prostředku na webu Azure Portal. Koncový bod najdete také na stránce Nasazení na portálu Azure AI Foundry. Ukázkový koncový bod je: `https://docs-test-001.openai.azure.com/`.
Klíč	`api_key`	Hodnota klíče se nachází také v části Klíče a koncový bod vašeho prostředku na webu Azure Portal. Azure vygeneruje dva klíče pro váš prostředek. Můžete použít kteroukoli hodnotu.

Na webu Azure Portal přejděte ke svému prostředku. V navigačním podokně vyberte v části Správa prostředků klíče a koncový bod. Zkopírujte hodnotu koncového bodu a hodnotu přístupového klíče. Můžete použít hodnotu KLÍČ 1 nebo KLÍČ 2 . Vždy mít dva klíče vám umožní bezpečně otáčet a znovu vygenerovat klíče, aniž by to způsobilo přerušení služeb.

Proměnné prostředí

Vytvořte a přiřaďte trvalé proměnné prostředí pro klíč a koncový bod.

Důležité

Pokud používáte klíč rozhraní API, uložte ho bezpečně někam jinam, například ve službě Azure Key Vault. Nezahrnujte klíč rozhraní API přímo do kódu a nikdy ho nevštěvujte veřejně.

Další informace o zabezpečení služeb AI najdete v tématu Ověřování požadavků na služby 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"

Vytvoření nové aplikace v Pythonu

Vytvořte nový soubor Pythonu s názvem quickstart.py. V preferovaném editoru nebo integrovaném vývojovém prostředí (IDE) otevřete nový soubor.

Obsah quickstart.py nahraďte následujícím kódem. Změňte hodnotu prompt na upřednostňovaný text.

DALL-E 3
DALL-E 2 (Preview)

V adrese URL je také nutné nahradit <dalle3> názvem nasazení, který jste zvolili při nasazení modelu DALL-E 3. Zadání názvu modelu způsobí chybu, pokud jste vybrali název nasazení, který je shodný s názvem základního modelu. Pokud dojde k chybě, poklikejte na to, abyste se ujistili, že nemáte zdvojnásobení intervalu / mezi koncovým bodem a /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)

Skript vytvoří synchronní volání rozhraní API pro generování obrázků.

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)

Skript vytvoří volání rozhraní API pro generování obrázků a potom smyčky, dokud nebude vygenerovaná image připravená.

Důležité

Nezapomeňte klíč odebrat z kódu, až budete hotovi, a nikdy ho veřejně neposílejte. V produkčním prostředí použijte bezpečný způsob ukládání a přístupu k vašim přihlašovacím údajům. Další informace najdete v tématu Azure Key Vault.

Spusťte aplikaci pomocí python příkazu:
```
python quickstart.py
```
Počkejte chvíli, než se odpověď zobrazí.

Výstup

Výstup z úspěšného volání rozhraní API pro generování imagí vypadá jako v následujícím příkladu. Pole url obsahuje adresu URL, kde si můžete stáhnout vygenerovaný obrázek. Adresa URL zůstane aktivní po dobu 24 hodin.

DALL-E 3
DALL-E 2 (Preview)

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

Rozhraní API pro generování obrázků mají filtr kon režim stanu ration. Pokud služba rozpozná vaši výzvu jako škodlivý obsah, nevygeneruje obrázek. Další informace najdete v tématu Filtrování obsahu. Příklady chybových odpovědí najdete v průvodci postupy DALL-E.

Systém vrátí stav Failed operace a error.code hodnota ve zprávě je nastavena na contentFilter. Tady je příklad:

DALL-E 3
DALL-E 2 (Preview)

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

Je také možné, že se vygenerovaná image filtruje. V tomto případě je chybová zpráva nastavena na Generated image was filtered as a result of our safety system.. Tady je příklad:

DALL-E 3
DALL-E 2 (Preview)

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

Vyčištění prostředků

Pokud chcete vyčistit a odebrat prostředek Azure OpenAI, můžete odstranit prostředek nebo skupinu prostředků. Odstraněním skupiny prostředků se odstraní také všechny ostatní prostředky, které jsou k ní přidružené.

Další kroky

Prozkoumejte rozhraní API pro generování imagí podrobněji pomocí průvodce postupy DALL-E.
Vyzkoušejte příklady v úložišti GitHub ukázek Azure OpenAI.
Viz referenční informace k rozhraní API

Tento průvodce vám pomůže začít generovat image pomocí sady Azure OpenAI SDK pro Python.

Ukázky balíčků zdrojového | kódu knihovny |

Požadavky

DALL-E 3
DALL-E 2 (Preview)

Předplatné Azure. Vytvořte si ho zdarma.
Python 3.8 nebo novější verze
Prostředek Azure OpenAI vytvořený v kompatibilní oblasti Viz Dostupnost oblastí.
Pak potřebujete nasadit model s prostředkem dalle3 Azure. Další informace najdete v tématu Vytvoření prostředku a nasazení modelu pomocí Azure OpenAI.

Nastavení

Načtení klíče a koncového bodu

K úspěšnému volání rozhraní API Azure OpenAI potřebujete následující informace o prostředku Azure OpenAI:

Proměnná	Jméno	Hodnota
Endpoint	`api_base`	Hodnota koncového bodu se nachází v části Klíče a koncový bod vašeho prostředku na webu Azure Portal. Koncový bod najdete také na stránce Nasazení na portálu Azure AI Foundry. Ukázkový koncový bod je: `https://docs-test-001.openai.azure.com/`.
Klíč	`api_key`	Hodnota klíče se nachází také v části Klíče a koncový bod vašeho prostředku na webu Azure Portal. Azure vygeneruje dva klíče pro váš prostředek. Můžete použít kteroukoli hodnotu.

Na webu Azure Portal přejděte ke svému prostředku. V navigačním podokně vyberte v části Správa prostředků klíče a koncový bod. Zkopírujte hodnotu koncového bodu a hodnotu přístupového klíče. Můžete použít hodnotu KLÍČ 1 nebo KLÍČ 2 . Vždy mít dva klíče vám umožní bezpečně otáčet a znovu vygenerovat klíče, aniž by to způsobilo přerušení služeb.

Proměnné prostředí

Vytvořte a přiřaďte trvalé proměnné prostředí pro klíč a koncový bod.

Důležité

Pokud používáte klíč rozhraní API, uložte ho bezpečně někam jinam, například ve službě Azure Key Vault. Nezahrnujte klíč rozhraní API přímo do kódu a nikdy ho nevštěvujte veřejně.

Další informace o zabezpečení služeb AI najdete v tématu Ověřování požadavků na služby 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"

Instalace sady Python SDK

Otevřete příkazový řádek a přejděte do složky projektu. Pomocí následujícího příkazu nainstalujte sadu OpenAI Python SDK:

DALL-E 3
DALL-E 2 (Preview)

pip install openai

Důležité

Nejnovější verze knihovny OpenAI Python v současné době nepodporuje DALL-E 2 při použití s Azure OpenAI. Pokud chcete získat přístup k DALL-E 2 pomocí Azure OpenAI, použijte verzi 0.28.1. Nebo postupujte podle průvodce migrací a použijte DALL-E 2 s OpenAI 1.x.

pip install openai==0.28.1

Nainstalujte také následující knihovny:

pip install requests
pip install pillow

Generování imagí pomocí DALL-E

Vytvořte nový soubor Pythonu quickstart.py. Otevřete ho v preferovaném editoru nebo integrovaném vývojovém prostředí (IDE).

Obsah quickstart.py nahraďte následujícím kódem.

DALL-E 3
DALL-E 2 (Preview)

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

Do příslušných polí zadejte adresu URL a klíč koncového bodu.
Změňte hodnotu prompt na upřednostňovaný text.
Změňte hodnotu model na název nasazeného modelu DALL-E 3.

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

Do příslušných polí zadejte adresu URL a klíč koncového bodu.
Změňte hodnotu prompt na upřednostňovaný text.

Důležité

Nezapomeňte klíč odebrat z kódu, až budete hotovi, a nikdy ho veřejně neposílejte. V produkčním prostředí použijte bezpečný způsob ukládání a přístupu k vašim přihlašovacím údajům. Další informace najdete v tématu Azure Key Vault.

Spusťte aplikaci pomocí python příkazu:

python quickstart.py

Počkejte chvíli, než se odpověď zobrazí.

Výstup

Azure OpenAI ukládá výstupní image do souboru generated_image.png ve vašem zadaném adresáři. Skript také zobrazí obrázek ve výchozím prohlížeči obrázků.

Rozhraní API pro generování obrázků mají filtr kon režim stanu ration. Pokud služba rozpozná vaši výzvu jako škodlivý obsah, nevygeneruje obrázek. Další informace najdete v tématu Filtrování obsahu.

Vyčištění prostředků

Pokud chcete vyčistit a odebrat prostředek Azure OpenAI, můžete odstranit prostředek nebo skupinu prostředků. Odstraněním skupiny prostředků se odstraní také všechny ostatní prostředky, které jsou k ní přidružené.

Další kroky

Prozkoumejte rozhraní API pro generování imagí podrobněji pomocí průvodce postupy DALL-E.
Vyzkoušejte příklady v úložišti GitHub ukázek Azure OpenAI.
Viz referenční informace k rozhraní API

V tomto průvodci můžete začít generovat image pomocí sady Azure OpenAI SDK pro jazyk C#.

Ukázky balíčku zdrojového kódu | knihovny (NuGet) |

Požadavky

Předplatné Azure – Vytvoření předplatného zdarma
Sada .NET 7 SDK
Prostředek Azure OpenAI vytvořený v podporované oblasti (viz Dostupnost oblastí). Další informace najdete v tématu Vytvoření prostředku a nasazení modelu pomocí Azure OpenAI.

Nastavení

Načtení klíče a koncového bodu

K úspěšnému volání azure OpenAI potřebujete koncový bod a klíč.

Název proměnné	Hodnota
`ENDPOINT`	Koncový bod služby najdete v části Klíče a koncový bod při zkoumání vašeho prostředku na webu Azure Portal. Koncový bod najdete také na stránce Nasazení na portálu Azure AI Foundry. Ukázkový koncový bod je: `https://docs-test-001.openai.azure.com/`.
`API-KEY`	Tuto hodnotu najdete v části Klíče a koncový bod při zkoumání prostředku na webu Azure Portal. Použít můžete předponu `KEY1` nebo `KEY2`.

Na webu Azure Portal přejděte ke svému prostředku. Oddíl Klíče a koncový bod najdete v části Správa prostředků. Zkopírujte koncový bod a přístupový klíč, protože budete potřebovat obojí pro ověřování volání rozhraní API. Použít můžete předponu KEY1 nebo KEY2. Vždy mít dva klíče vám umožní bezpečně otáčet a znovu vygenerovat klíče, aniž by to způsobilo přerušení služeb.

Proměnné prostředí

Vytvořte a přiřaďte trvalé proměnné prostředí pro klíč a koncový bod.

Důležité

Pokud používáte klíč rozhraní API, uložte ho bezpečně někam jinam, například ve službě Azure Key Vault. Nezahrnujte klíč rozhraní API přímo do kódu a nikdy ho nevštěvujte veřejně.

Další informace o zabezpečení služeb AI najdete v tématu Ověřování požadavků na služby 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"

Vytvoření nové aplikace .NET Core

V okně konzoly (například cmd, PowerShell nebo Bash) pomocí dotnet new příkazu vytvořte novou konzolovou aplikaci s názvem azure-openai-quickstart. Tento příkaz vytvoří jednoduchý projekt Hello World s jedním zdrojovým souborem jazyka C#: Program.cs.

dotnet new console -n azure-openai-quickstart

Změňte adresář na nově vytvořenou složku aplikace. Aplikaci můžete sestavit pomocí následujících:

dotnet build

Výstup sestavení by neměl obsahovat žádná upozornění ani chyby.

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

Instalace sady OpenAI .NET SDK

Nainstalujte klientskou knihovnu pomocí:

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

Generování imagí pomocí DALL-E

V adresáři projektu otevřete soubor program.cs a nahraďte jeho obsah následujícím kódem:

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

Sestavte a spusťte aplikaci z adresáře aplikace pomocí těchto příkazů:

dotnet build
dotnet run

Výstup

Adresa URL vygenerovaného obrázku se vytiskne do konzoly.

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

Poznámka:

Rozhraní API pro generování obrázků mají filtr kon režim stanu ration. Pokud služba rozpozná vaši výzvu jako škodlivý obsah, nevrátí vygenerovaný obrázek. Další informace najdete v článku filtru obsahu.

Vyčištění prostředků

Pokud chcete vyčistit a odebrat prostředek Azure OpenAI, můžete prostředek odstranit. Před odstraněním prostředku musíte nejprve odstranit všechny nasazené modely.

Další kroky

Prozkoumejte rozhraní API pro generování imagí podrobněji pomocí průvodce postupy DALL-E.
Další příklady najdete v úložišti GitHub ukázek Azure OpenAI.

V tomto průvodci můžete začít generovat image pomocí sady Azure OpenAI SDK pro Javu.

Ukázky artefaktu zdrojového kódu | knihovny (Maven) |

Požadavky

Předplatné Azure – Vytvoření předplatného zdarma
Aktuální verze sady Java Development Kit (JDK)
Nástroj sestavení Gradle nebo jiný správce závislostí.
Prostředek Azure OpenAI vytvořený v podporované oblasti (viz Dostupnost oblastí). Další informace najdete v tématu Vytvoření prostředku a nasazení modelu pomocí Azure OpenAI.

Nastavení

Načtení klíče a koncového bodu

K úspěšnému volání azure OpenAI potřebujete koncový bod a klíč.

Název proměnné	Hodnota
`ENDPOINT`	Koncový bod služby najdete v části Klíče a koncový bod při zkoumání vašeho prostředku na webu Azure Portal. Koncový bod najdete také na stránce Nasazení na portálu Azure AI Foundry. Ukázkový koncový bod je: `https://docs-test-001.openai.azure.com/`.
`API-KEY`	Tuto hodnotu najdete v části Klíče a koncový bod při zkoumání prostředku na webu Azure Portal. Použít můžete předponu `KEY1` nebo `KEY2`.

Na webu Azure Portal přejděte ke svému prostředku. Oddíl Klíče a koncový bod najdete v části Správa prostředků. Zkopírujte koncový bod a přístupový klíč, protože budete potřebovat obojí pro ověřování volání rozhraní API. Použít můžete předponu KEY1 nebo KEY2. Vždy mít dva klíče vám umožní bezpečně otáčet a znovu vygenerovat klíče, aniž by to způsobilo přerušení služeb.

Proměnné prostředí

Vytvořte a přiřaďte trvalé proměnné prostředí pro klíč a koncový bod.

Důležité

Pokud používáte klíč rozhraní API, uložte ho bezpečně někam jinam, například ve službě Azure Key Vault. Nezahrnujte klíč rozhraní API přímo do kódu a nikdy ho nevštěvujte veřejně.

Další informace o zabezpečení služeb AI najdete v tématu Ověřování požadavků na služby 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"

Vytvoření nové aplikace v Javě

Vytvořte nový projekt Gradle.

V okně konzoly (například cmd, PowerShell nebo Bash) vytvořte pro vaši aplikaci nový adresář a přejděte do něj.

mkdir myapp && cd myapp

gradle init Spusťte příkaz z pracovního adresáře. Tento příkaz vytvoří základní soubory sestavení pro Gradle, včetně build.gradle.kts, které se používají za běhu k vytvoření a konfiguraci aplikace.

gradle init --type basic

Po zobrazení výzvy k výběru DSL vyberte Kotlin.

Instalace sady Java SDK

V tomto rychlém startu se používá správce závislostí Gradle. Klientskou knihovnu a informace pro další správce závislostí najdete v centrálním úložišti Maven.

Vyhledejte build.gradle.kts a otevřete ho pomocí preferovaného integrovaného vývojového prostředí (IDE) nebo textového editoru. Pak zkopírujte následující konfiguraci sestavení. Tato konfigurace definuje projekt jako aplikaci Java, jejíž vstupním bodem je třída OpenAIQuickstart. Naimportuje knihovnu Azure AI Vision.

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

Generování imagí pomocí DALL-E

Vytvořte soubor Java.

Spuštěním následujícího příkazu z pracovního adresáře vytvořte zdrojovou složku projektu:
```
mkdir -p src/main/java
```
Přejděte do nové složky a vytvořte soubor s názvem OpenAIQuickstart.java.

Otevřete OpenAIQuickstart.java v preferovaném editoru nebo integrovaném vývojovém prostředí (IDE) a vložte následující kód.

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);
    }
}

Přejděte zpět do kořenové složky projektu a sestavte aplikaci pomocí:
```
gradle build
```
Pak ho spusťte pomocí gradle run příkazu:
```
gradle run
```

Výstup

Adresa URL vygenerovaného obrázku se vytiskne do konzoly.

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.

Poznámka:

Rozhraní API pro generování obrázků mají filtr kon režim stanu ration. Pokud služba rozpozná vaši výzvu jako škodlivý obsah, nevrátí vygenerovaný obrázek. Další informace najdete v článku filtru obsahu.

Vyčištění prostředků

Pokud chcete vyčistit a odebrat prostředek Azure OpenAI, můžete prostředek odstranit. Před odstraněním prostředku musíte nejprve odstranit všechny nasazené modely.

Další kroky

Prozkoumejte rozhraní API pro generování imagí podrobněji pomocí průvodce postupy DALL-E.
Další příklady najdete v úložišti GitHub s ukázkami Azure OpenAI.

Pomocí této příručky můžete začít generovat image pomocí sady Azure OpenAI SDK pro JavaScript.

Referenční dokumentace | – ukázky balíčku zdrojového kódu | (npm) |

Požadavky

Předplatné Azure – Vytvoření předplatného zdarma
Verze LTS Node.js
Azure CLI , které se používá k ověřování bez hesla v místním vývojovém prostředí, vytvořte potřebný kontext přihlášením pomocí Azure CLI.
Prostředek Azure OpenAI vytvořený v podporované oblasti (viz Dostupnost oblastí). Další informace najdete v tématu Vytvoření prostředku a nasazení modelu pomocí Azure OpenAI.

Nastavení

Načtení klíče a koncového bodu

K úspěšnému volání azure OpenAI potřebujete koncový bod a klíč.

Název proměnné	Hodnota
`ENDPOINT`	Koncový bod služby najdete v části Klíče a koncový bod při zkoumání vašeho prostředku na webu Azure Portal. Koncový bod najdete také na stránce Nasazení na portálu Azure AI Foundry. Ukázkový koncový bod je: `https://docs-test-001.openai.azure.com/`.
`API-KEY`	Tuto hodnotu najdete v části Klíče a koncový bod při zkoumání prostředku na webu Azure Portal. Použít můžete předponu `KEY1` nebo `KEY2`.

Na webu Azure Portal přejděte ke svému prostředku. Oddíl Klíče a koncový bod najdete v části Správa prostředků. Zkopírujte koncový bod a přístupový klíč, protože budete potřebovat obojí pro ověřování volání rozhraní API. Použít můžete předponu KEY1 nebo KEY2. Vždy mít dva klíče vám umožní bezpečně otáčet a znovu vygenerovat klíče, aniž by to způsobilo přerušení služeb.

Proměnné prostředí

Vytvořte a přiřaďte trvalé proměnné prostředí pro klíč a koncový bod.

Důležité

Pokud používáte klíč rozhraní API, uložte ho bezpečně někam jinam, například ve službě Azure Key Vault. Nezahrnujte klíč rozhraní API přímo do kódu a nikdy ho nevštěvujte veřejně.

Další informace o zabezpečení služeb AI najdete v tématu Ověřování požadavků na služby 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"

Vytvoření aplikace Node

V okně konzoly (například cmd, PowerShell nebo Bash) vytvořte pro vaši aplikaci nový adresář a přejděte do něj. Potom spuštěním npm init příkazu vytvořte aplikaci uzlu se souborem package.json .

npm init

Instalace klientské knihovny

Nainstalujte klientské knihovny pomocí:

npm install openai @azure/identity

Soubor package.json vaší aplikace se aktualizuje o závislosti.

Generování imagí pomocí DALL-E

Vytvořte nový soubor s názvem ImageGeneration.js a otevřete ho v preferovaném editoru kódu. Do souboru ImageGeneration.js zkopírujte následující kód:

Microsoft Entra ID
Klíč rozhraní 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);
});

Spusťte skript pomocí následujícího příkazu:

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);
});

Spusťte skript pomocí následujícího příkazu:

node ImageGeneration.js

Výstup

Adresa URL vygenerovaného obrázku se vytiskne do konzoly.

== 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

Poznámka:

Rozhraní API pro generování obrázků mají filtr kon režim stanu ration. Pokud služba rozpozná vaši výzvu jako škodlivý obsah, nevrátí vygenerovaný obrázek. Další informace najdete v článku filtru obsahu.

Vyčištění prostředků

Pokud chcete vyčistit a odebrat prostředek Azure OpenAI, můžete prostředek odstranit. Před odstraněním prostředku musíte nejprve odstranit všechny nasazené modely.

Další kroky

Prozkoumejte rozhraní API pro generování imagí podrobněji pomocí průvodce postupy DALL-E.
Další příklady najdete v úložišti GitHub ukázek Azure OpenAI.

Pomocí této příručky můžete začít generovat image pomocí sady Azure OpenAI SDK pro JavaScript.

Referenční dokumentace | – ukázky balíčku zdrojového kódu | (npm) |

Požadavky

Předplatné Azure – Vytvoření předplatného zdarma
Verze LTS Node.js
TypeScript
Azure CLI , které se používá k ověřování bez hesla v místním vývojovém prostředí, vytvořte potřebný kontext přihlášením pomocí Azure CLI.
Prostředek Azure OpenAI vytvořený v podporované oblasti (viz Dostupnost oblastí). Další informace najdete v tématu Vytvoření prostředku a nasazení modelu pomocí Azure OpenAI.

Nastavení

Načtení klíče a koncového bodu

K úspěšnému volání azure OpenAI potřebujete koncový bod a klíč.

Název proměnné	Hodnota
`ENDPOINT`	Koncový bod služby najdete v části Klíče a koncový bod při zkoumání vašeho prostředku na webu Azure Portal. Koncový bod najdete také na stránce Nasazení na portálu Azure AI Foundry. Ukázkový koncový bod je: `https://docs-test-001.openai.azure.com/`.
`API-KEY`	Tuto hodnotu najdete v části Klíče a koncový bod při zkoumání prostředku na webu Azure Portal. Použít můžete předponu `KEY1` nebo `KEY2`.

Na webu Azure Portal přejděte ke svému prostředku. Oddíl Klíče a koncový bod najdete v části Správa prostředků. Zkopírujte koncový bod a přístupový klíč, protože budete potřebovat obojí pro ověřování volání rozhraní API. Použít můžete předponu KEY1 nebo KEY2. Vždy mít dva klíče vám umožní bezpečně otáčet a znovu vygenerovat klíče, aniž by to způsobilo přerušení služeb.

Proměnné prostředí

Vytvořte a přiřaďte trvalé proměnné prostředí pro klíč a koncový bod.

Důležité

Pokud používáte klíč rozhraní API, uložte ho bezpečně někam jinam, například ve službě Azure Key Vault. Nezahrnujte klíč rozhraní API přímo do kódu a nikdy ho nevštěvujte veřejně.

Další informace o zabezpečení služeb AI najdete v tématu Ověřování požadavků na služby 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"

Vytvoření aplikace Node

V okně konzoly (například cmd, PowerShell nebo Bash) vytvořte pro vaši aplikaci nový adresář a přejděte do něj. Potom spuštěním npm init příkazu vytvořte aplikaci uzlu se souborem package.json .

npm init

Instalace klientské knihovny

Nainstalujte klientské knihovny pomocí:

npm install openai @azure/identity

Soubor package.json vaší aplikace se aktualizuje o závislosti.

Generování imagí pomocí DALL-E

Vytvořte nový soubor s názvem ImageGeneration.ts a otevřete ho v preferovaném editoru kódu. Do souboru ImageGeneration.ts zkopírujte následující kód:

Microsoft Entra ID
Klíč rozhraní 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);
});

Sestavte aplikaci pomocí následujícího příkazu:
```
tsc
```
Spusťte aplikaci pomocí následujícího příkazu:
```
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);
});

Sestavte aplikaci pomocí následujícího příkazu:
```
tsc
```
Spusťte aplikaci pomocí následujícího příkazu:
```
node ImageGeneration.js
```

Výstup

Adresa URL vygenerovaného obrázku se vytiskne do konzoly.

== 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

Poznámka:

Rozhraní API pro generování obrázků mají filtr kon režim stanu ration. Pokud služba rozpozná vaši výzvu jako škodlivý obsah, nevrátí vygenerovaný obrázek. Další informace najdete v článku filtru obsahu.

Vyčištění prostředků

Pokud chcete vyčistit a odebrat prostředek Azure OpenAI, můžete prostředek odstranit. Před odstraněním prostředku musíte nejprve odstranit všechny nasazené modely.

Další kroky

Prozkoumejte rozhraní API pro generování imagí podrobněji pomocí průvodce postupy DALL-E.
Další příklady najdete v úložišti GitHub ukázek Azure OpenAI.

Tento průvodce vám pomůže začít generovat image pomocí sady Azure OpenAI SDK for Go.

Ukázky balíčků zdrojového | kódu knihovny |

Požadavky

Předplatné Azure – Vytvoření předplatného zdarma
Go 1.8+
Prostředek Azure OpenAI vytvořený v podporované oblasti (viz Dostupnost oblastí). Další informace najdete v tématu Vytvoření prostředku a nasazení modelu pomocí Azure OpenAI.

Nastavení

Načtení klíče a koncového bodu

K úspěšnému volání azure OpenAI potřebujete koncový bod a klíč.

Název proměnné	Hodnota
`ENDPOINT`	Koncový bod služby najdete v části Klíče a koncový bod při zkoumání vašeho prostředku na webu Azure Portal. Koncový bod najdete také na stránce Nasazení na portálu Azure AI Foundry. Ukázkový koncový bod je: `https://docs-test-001.openai.azure.com/`.
`API-KEY`	Tuto hodnotu najdete v části Klíče a koncový bod při zkoumání prostředku na webu Azure Portal. Použít můžete předponu `KEY1` nebo `KEY2`.

Na webu Azure Portal přejděte ke svému prostředku. Oddíl Klíče a koncový bod najdete v části Správa prostředků. Zkopírujte koncový bod a přístupový klíč, protože budete potřebovat obojí pro ověřování volání rozhraní API. Použít můžete předponu KEY1 nebo KEY2. Vždy mít dva klíče vám umožní bezpečně otáčet a znovu vygenerovat klíče, aniž by to způsobilo přerušení služeb.

Proměnné prostředí

Vytvořte a přiřaďte trvalé proměnné prostředí pro klíč a koncový bod.

Důležité

Pokud používáte klíč rozhraní API, uložte ho bezpečně někam jinam, například ve službě Azure Key Vault. Nezahrnujte klíč rozhraní API přímo do kódu a nikdy ho nevštěvujte veřejně.

Další informace o zabezpečení služeb AI najdete v tématu Ověřování požadavků na služby 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"

Vytvoření nové aplikace Go

Otevřete příkazový řádek a přejděte do složky projektu. Vytvořte nový soubor sample.go.

Instalace sady Go SDK

Pomocí následujícího příkazu nainstalujte sadu OpenAI Go SDK:

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

Nebo pokud použijete dep, spusťte v úložišti:

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

Generování imagí pomocí DALL-E

Otevřete sample.go v preferovaném editoru kódu.

Do skriptu přidejte následující kód:

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

Spusťte skript pomocí go run příkazu:

go run sample.go

Výstup

Adresa URL vygenerovaného obrázku se vytiskne do konzoly.

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

Poznámka:

Rozhraní API pro generování obrázků mají filtr kon režim stanu ration. Pokud služba rozpozná vaši výzvu jako škodlivý obsah, nevrátí vygenerovaný obrázek. Další informace najdete v článku filtru obsahu.

Vyčištění prostředků

Pokud chcete vyčistit a odebrat prostředek Azure OpenAI, můžete odstranit prostředek nebo skupinu prostředků. Odstraněním skupiny prostředků se odstraní také všechny ostatní prostředky, které jsou k ní přidružené.

Další kroky

Prozkoumejte rozhraní API pro generování imagí podrobněji pomocí průvodce postupy DALL-E.
Další příklady najdete v úložišti GitHub ukázek Azure OpenAI.

V této příručce můžete začít volat rozhraní API pro generování imagí služby Azure OpenAI pomocí PowerShellu.

Poznámka:

Rozhraní API pro generování obrázků vytvoří obrázek z textové výzvy. Neupravuje ani nevytvoří varianty existujících obrázků.

Požadavky

Předplatné Azure. Vytvořte si ho zdarma.
Pro tuto úlohu se doporučuje nejnovější verze PowerShellu 7, protože příklady používají nové funkce, které nejsou dostupné ve Windows PowerShellu 5.1.
Prostředek Azure OpenAI vytvořený v podporované oblasti (viz Dostupnost oblastí). Další informace najdete v tématu Vytvoření prostředku a nasazení modelu pomocí Azure OpenAI.

Nastavení

Načtení klíče a koncového bodu

K úspěšnému volání azure OpenAI potřebujete koncový bod a klíč.

Název proměnné	Hodnota
`ENDPOINT`	Koncový bod služby najdete v části Klíče a koncový bod při zkoumání vašeho prostředku na webu Azure Portal. Koncový bod najdete také na stránce Nasazení na portálu Azure AI Foundry. Ukázkový koncový bod je: `https://docs-test-001.openai.azure.com/`.
`API-KEY`	Tuto hodnotu najdete v části Klíče a koncový bod při zkoumání prostředku na webu Azure Portal. Použít můžete předponu `KEY1` nebo `KEY2`.

Na webu Azure Portal přejděte ke svému prostředku. Oddíl Klíče a koncový bod najdete v části Správa prostředků. Zkopírujte koncový bod a přístupový klíč, protože budete potřebovat obojí pro ověřování volání rozhraní API. Použít můžete předponu KEY1 nebo KEY2. Vždy mít dva klíče vám umožní bezpečně otáčet a znovu vygenerovat klíče, aniž by to způsobilo přerušení služeb.

Proměnné prostředí

Vytvořte a přiřaďte trvalé proměnné prostředí pro klíč a koncový bod.

Důležité

Pokud používáte klíč rozhraní API, uložte ho bezpečně někam jinam, například ve službě Azure Key Vault. Nezahrnujte klíč rozhraní API přímo do kódu a nikdy ho nevštěvujte veřejně.

Další informace o zabezpečení služeb AI najdete v tématu Ověřování požadavků na služby 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"

Generování obrázků pomocí DALL-E 2

Vytvořte nový soubor PowerShellu s názvem quickstart.ps1. V preferovaném editoru nebo integrovaném vývojovém prostředí (IDE) otevřete nový soubor.

Obsah souboru quickstart.ps1 nahraďte následujícím kódem. Do příslušných polí zadejte adresu URL a klíč koncového bodu. Změňte hodnotu prompt na upřednostňovaný text.

# 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

Důležité

V produkčním prostředí použijte zabezpečený způsob ukládání a přístupu k přihlašovacím údajům, jako je správa tajných kódů PowerShellu pomocí služby Azure Key Vault. Další informace o zabezpečení přihlašovacích údajů najdete v článku zabezpečení služeb Azure AI.

Spusťte skript pomocí PowerShellu:
```
./quickstart.ps1
```
Skript se smykne, dokud nebude vygenerovaná image připravená.

Výstup

PowerShell požádá o image z Azure OpenAI a uloží výstupní image do souboru generated_image.png ve vašem zadaném adresáři. Pro usnadnění je na konci skriptu vrácena úplná cesta k souboru.

Rozhraní API pro generování obrázků mají filtr kon režim stanu ration. Pokud služba rozpozná vaši výzvu jako škodlivý obsah, nevygeneruje obrázek. Další informace najdete v tématu Filtrování obsahu.

Vyčištění prostředků

Pokud chcete vyčistit a odebrat prostředek Azure OpenAI, můžete odstranit prostředek nebo skupinu prostředků. Odstraněním skupiny prostředků se odstraní také všechny ostatní prostředky, které jsou k ní přidružené.

Další kroky

Prozkoumejte rozhraní API pro generování imagí podrobněji pomocí průvodce postupy DALL-E.

Vyzkoušejte příklady v úložišti GitHub ukázek Azure OpenAI.

Sdílet prostřednictvím

Požadavky

Přechod na Azure AI Foundry

Vyzkoušení generování imagí

Vyčištění prostředků

Další kroky

Požadavky

Nastavení

Načtení klíče a koncového bodu

Proměnné prostředí

Vytvoření nové aplikace v Pythonu

Výstup

Vyčištění prostředků

Další kroky

Požadavky

Nastavení

Načtení klíče a koncového bodu

Proměnné prostředí

Instalace sady Python SDK

Generování imagí pomocí DALL-E

Výstup

Vyčištění prostředků

Další kroky

Požadavky

Nastavení

Načtení klíče a koncového bodu

Proměnné prostředí

Vytvoření nové aplikace .NET Core

Instalace sady OpenAI .NET SDK

Generování imagí pomocí DALL-E

Výstup

Vyčištění prostředků

Další kroky

Požadavky

Nastavení

Načtení klíče a koncového bodu

Proměnné prostředí

Vytvoření nové aplikace v Javě

Instalace sady Java SDK

Generování imagí pomocí DALL-E

Výstup

Vyčištění prostředků

Další kroky

Požadavky

Nastavení

Načtení klíče a koncového bodu

Proměnné prostředí

Vytvoření aplikace Node

Instalace klientské knihovny

Generování imagí pomocí DALL-E

Výstup

Vyčištění prostředků

Další kroky

Požadavky

Nastavení

Načtení klíče a koncového bodu

Proměnné prostředí

Vytvoření aplikace Node

Instalace klientské knihovny

Generování imagí pomocí DALL-E

Výstup

Vyčištění prostředků

Další kroky

Požadavky

Nastavení

Načtení klíče a koncového bodu

Proměnné prostředí

Vytvoření nové aplikace Go

Instalace sady Go SDK

Generování imagí pomocí DALL-E

Výstup

Vyčištění prostředků

Další kroky

Požadavky

Nastavení

Načtení klíče a koncového bodu

Proměnné prostředí

Generování obrázků pomocí DALL-E 2

Výstup