Az Azure OpenAI által támogatott programozási nyelvek
A .NET-hez készült Azure OpenAI ügyfélkódtár a .NET-hez készült hivatalos OpenAI-ügyfélkódtár társa. Az Azure OpenAI-kódtár konfigurálja az ügyfelet az Azure OpenAI-hoz való használatra, és extra erősen gépelt bővítménytámogatást biztosít az Azure OpenAI-forgatókönyvekre jellemző kérés- és válaszmodellekhez.
Stabil kiadás:
Forráskódcsomag (NuGet) | Csomagreferenciák dokumentációja API-referenciadokumentáció minták | |
Előzetes kiadás:
Az előzetes kiadás hozzáféréssel rendelkezik a legújabb funkciókhoz.
Forráskódcsomag (NuGet) | API-referenciadokumentáció | Csomagreferenciák dokumentációja Minták |
Az Azure OpenAI API verziótámogatása
A Pythonhoz és JavaScripthez készült Azure OpenAI ügyfélkódtárakkal ellentétben az Azure OpenAI .NET-csomag az Azure OpenAI API-verziók egy adott részhalmazára korlátozódik. Általában minden Azure OpenAI .NET-csomag feloldja az Azure OpenAI API újabb kiadási funkcióihoz való hozzáférést. A legújabb API-verziókhoz való hozzáférés hatással van a funkciók rendelkezésre állására.
A verzióválasztást az AzureOpenAIClientOptions.ServiceVersion
enumerálás szabályozza.
A stabil kiadás jelenleg a következő célokat célozza:
2024-06-01
Az előzetes kiadás jelenleg a következő célokat célozhatja meg:
2024-06-01
2024-08-01-preview
2024-09-01-preview
2024-10-01-preview
Telepítés
dotnet add package Azure.AI.OpenAI --prerelease
A Azure.AI.OpenAI
csomag a hivatalos OpenAI-csomagra épül, amely függőségként szerepel.
Hitelesítés
Az Azure OpenAI vagy az OpenAI használatához hozzon létre egy példányt az alábbi módszerek egyikével AzureOpenAIClient
:
A biztonságos, kulcs nélküli hitelesítési módszer a Microsoft Entra ID (korábbi nevén Azure Active Directory) használata az Azure Identity-kódtáron keresztül. A kódtár használata:
dotnet add package Azure.Identity
Használja a tárból a kívánt hitelesítőadat-típust. Például DefaultAzureCredential
:
AzureOpenAIClient openAIClient = new(
new Uri("https://your-azure-openai-resource.com"),
new DefaultAzureCredential());
ChatClient chatClient = openAIClient.GetChatClient("my-gpt-4o-mini-deployment");
Az Azure OpenAI kulcs nélküli hitelesítésével kapcsolatos további információkért tekintse meg az "Első lépések az Azure OpenAI biztonsági építőelemével" rövid útmutatót.
Hang
AzureOpenAIClient.GetAudioClient
Transzkripció
AzureOpenAIClient openAIClient = new(
new Uri("https://your-azure-openai-resource.com"),
new DefaultAzureCredential());
AudioClient client = openAIClient.GetAudioClient("whisper");
string audioFilePath = Path.Combine("Assets", "speech.mp3");
AudioTranscriptionOptions options = new()
{
ResponseFormat = AudioTranscriptionFormat.Verbose,
TimestampGranularities = AudioTimestampGranularities.Word | AudioTimestampGranularities.Segment,
};
AudioTranscription transcription = client.TranscribeAudio(audioFilePath, options);
Console.WriteLine("Transcription:");
Console.WriteLine($"{transcription.Text}");
Console.WriteLine();
Console.WriteLine($"Words:");
foreach (TranscribedWord word in transcription.Words)
{
Console.WriteLine($" {word.Word,15} : {word.StartTime.TotalMilliseconds,5:0} - {word.EndTime.TotalMilliseconds,5:0}");
}
Console.WriteLine();
Console.WriteLine($"Segments:");
foreach (TranscribedSegment segment in transcription.Segments)
{
Console.WriteLine($" {segment.Text,90} : {segment.StartTime.TotalMilliseconds,5:0} - {segment.EndTime.TotalMilliseconds,5:0}");
}
Szövegfelolvasás (TTS)
using Azure.AI.OpenAI;
using Azure.Identity;
using OpenAI.Audio;
AzureOpenAIClient openAIClient = new(
new Uri("https://your-azure-openai-resource.com"),
new DefaultAzureCredential());
AudioClient client = openAIClient.GetAudioClient("tts-hd"); //Replace with your Azure OpenAI model deployment
string input = "Testing, testing, 1, 2, 3";
BinaryData speech = client.GenerateSpeech(input, GeneratedSpeechVoice.Alloy);
using FileStream stream = File.OpenWrite($"{Guid.NewGuid()}.mp3");
speech.ToStream().CopyTo(stream);
Csevegés
AzureOpenAIClient.GetChatClient
AzureOpenAIClient openAIClient = new(
new Uri("https://your-azure-openai-resource.com"),
new DefaultAzureCredential());
ChatClient chatClient = openAIClient.GetChatClient("my-gpt-4o-deployment");
ChatCompletion completion = chatClient.CompleteChat(
[
// System messages represent instructions or other guidance about how the assistant should behave
new SystemChatMessage("You are a helpful assistant that talks like a pirate."),
// User messages represent user input, whether historical or the most recent input
new UserChatMessage("Hi, can you help me?"),
// Assistant messages in a request represent conversation history for responses
new AssistantChatMessage("Arrr! Of course, me hearty! What can I do for ye?"),
new UserChatMessage("What's the best way to train a parrot?"),
]);
Console.WriteLine($"{completion.Role}: {completion.Content[0].Text}");
Csevegőüzenetek streamelése
A streamelt csevegések befejezései a és a CompleteChatStreaming
metódust használják, amelyek egy ResultCollection<StreamingChatCompletionUpdate>
vagy AsyncCollectionResult<StreamingChatCompletionUpdate>
több elemet adnak ClientResult<ChatCompletion>
CompleteChatStreamingAsync
vissza.
Ezek az eredménygyűjtemények a foreach használatával iterálhatók, vagy várhatók a foreachra, és minden frissítés megérkezik, amint új adatok érhetők el a streamelt válaszból.
AzureOpenAIClient openAIClient = new(
new Uri("https://your-azure-openai-resource.com"),
new DefaultAzureCredential());
ChatClient chatClient = openAIClient.GetChatClient("my-gpt-4o-deployment");
CollectionResult<StreamingChatCompletionUpdate> completionUpdates = chatClient.CompleteChatStreaming(
[
new SystemChatMessage("You are a helpful assistant that talks like a pirate."),
new UserChatMessage("Hi, can you help me?"),
new AssistantChatMessage("Arrr! Of course, me hearty! What can I do for ye?"),
new UserChatMessage("What's the best way to train a parrot?"),
]);
foreach (StreamingChatCompletionUpdate completionUpdate in completionUpdates)
{
foreach (ChatMessageContentPart contentPart in completionUpdate.ContentUpdate)
{
Console.Write(contentPart.Text);
}
}
Beágyazások
AzureOpenAIClient.GetEmbeddingClient
using Azure.AI.OpenAI;
using Azure.Identity;
using OpenAI.Embeddings;
AzureOpenAIClient openAIClient = new(
new Uri("https://your-azure-openai-resource.com"),
new DefaultAzureCredential());
EmbeddingClient client = openAIClient.GetEmbeddingClient("text-embedding-3-large"); //Replace with your model deployment name
string description = "This is a test embedding";
OpenAIEmbedding embedding = client.GenerateEmbedding(description);
ReadOnlyMemory<float> vector = embedding.ToFloats();
Console.WriteLine(string.Join(", ", vector.ToArray()));
Finomhangolás
Az Azure OpenAI .NET-csomagok jelenleg nem támogatottak.
Batch
Az Azure OpenAI .NET-csomagok jelenleg nem támogatottak.
Képek
AzureOpenAIClient.GetImageClient
using Azure.AI.OpenAI;
using Azure.Identity;
using OpenAI.Images;
AzureOpenAIClient openAIClient = new(
new Uri("https://your-azure-openai-resource.com"),
new DefaultAzureCredential());
ImageClient client = openAIClient.GetImageClient("dall-e-3"); // replace with your model deployment name.
string prompt = "A rabbit eating pancakes.";
ImageGenerationOptions options = new()
{
Quality = GeneratedImageQuality.High,
Size = GeneratedImageSize.W1792xH1024,
Style = GeneratedImageStyle.Vivid,
ResponseFormat = GeneratedImageFormat.Bytes
};
GeneratedImage image = client.GenerateImage(prompt, options);
BinaryData bytes = image.ImageBytes;
using FileStream stream = File.OpenWrite($"{Guid.NewGuid()}.png");
bytes.ToStream().CopyTo(stream);
Befejezések (örökölt)
Az Azure OpenAI .NET-csomagok nem támogatottak.
Hibakezelés
Hibakódok
Állapotkód | Hibatípus |
---|---|
400 | Bad Request Error |
401 | Authentication Error |
403 | Permission Denied Error |
404 | Not Found Error |
422 | Unprocessable Entity Error |
429 | Rate Limit Error |
500 | Internal Server Error |
503 | Service Unavailable |
504 | Gateway Timeout |
Újrapróbálkozások
Az ügyfélosztályok exponenciális visszalépéssel automatikusan újrapróbálkoznak a következő hibákra, akár háromszor is:
- 408 Kérés időtúllépése
- 429 – Túl sok kérelem
- 500 Belső kiszolgálóhiba
- 502 Hibás átjáró
- 503 A szolgáltatás nem érhető el
- 504 Időtúllépés az átjárón
Forráskódcsomag (pkg.go.dev) | API-referenciadokumentáció | Csomagreferenciák dokumentációja Minták |
Az Azure OpenAI API verziótámogatása
A Pythonhoz és JavaScripthez készült Azure OpenAI-ügyfélkódtárakkal ellentétben az Azure OpenAI Go-kódtár egy adott Azure OpenAI API-verzióra van megcélzva. A legújabb API-verziókhoz való hozzáférés hatással van a funkciók rendelkezésre állására.
Az Azure OpenAI API aktuális verziócélja: 2024-10-01-preview
Ez a custom_client.go fájlban van definiálva .
Telepítés
Telepítse a modulokat és azidentity
a azopenai
modulokat a következő lépésekkel:
go get github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai
# optional
go get github.com/Azure/azure-sdk-for-go/sdk/azidentity
Hitelesítés
Az azidentity modul az Azure Active Directory-hitelesítéshez használható az Azure OpenAI-val.
package main
import (
"log"
"github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai"
"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
)
func main() {
dac, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
// TODO: Update the following line with your application specific error handling logic
log.Printf("ERROR: %s", err)
return
}
// NOTE: this constructor creates a client that connects to an Azure OpenAI endpoint.
// To connect to the public OpenAI endpoint, use azopenai.NewClientForOpenAI
client, err := azopenai.NewClient("https://<your-azure-openai-host>.openai.azure.com", dac, nil)
if err != nil {
// TODO: Update the following line with your application specific error handling logic
log.Printf("ERROR: %s", err)
return
}
_ = client
}
További információ az Azure OpenAI kulcs nélküli hitelesítéséről: Az Azure OpenAI használata kulcsok nélkül.
Hang
Client.GenerateSpeechFromText
ackage main
import (
"context"
"fmt"
"io"
"log"
"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() {
openAIKey := os.Getenv("OPENAI_API_KEY")
// Ex: "https://api.openai.com/v1"
openAIEndpoint := os.Getenv("OPENAI_ENDPOINT")
modelDeploymentID := "tts-1"
if openAIKey == "" || openAIEndpoint == "" || modelDeploymentID == "" {
fmt.Fprintf(os.Stderr, "Skipping example, environment variables missing\n")
return
}
keyCredential := azcore.NewKeyCredential(openAIKey)
client, err := azopenai.NewClientForOpenAI(openAIEndpoint, keyCredential, nil)
if err != nil {
// TODO: Update the following line with your application specific error handling logic
log.Printf("ERROR: %s", err)
return
}
audioResp, err := client.GenerateSpeechFromText(context.Background(), azopenai.SpeechGenerationOptions{
Input: to.Ptr("i am a computer"),
Voice: to.Ptr(azopenai.SpeechVoiceAlloy),
ResponseFormat: to.Ptr(azopenai.SpeechGenerationResponseFormatFlac),
DeploymentName: to.Ptr("tts-1"),
}, nil)
if err != nil {
// TODO: Update the following line with your application specific error handling logic
log.Printf("ERROR: %s", err)
return
}
defer audioResp.Body.Close()
audioBytes, err := io.ReadAll(audioResp.Body)
if err != nil {
// TODO: Update the following line with your application specific error handling logic
log.Printf("ERROR: %s", err)
return
}
fmt.Fprintf(os.Stderr, "Got %d bytes of FLAC audio\n", len(audioBytes))
}
Client.GetAudioTranscription
package main
import (
"context"
"fmt"
"log"
"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("AOAI_WHISPER_API_KEY")
// Ex: "https://<your-azure-openai-host>.openai.azure.com"
azureOpenAIEndpoint := os.Getenv("AOAI_WHISPER_ENDPOINT")
modelDeploymentID := os.Getenv("AOAI_WHISPER_MODEL")
if azureOpenAIKey == "" || azureOpenAIEndpoint == "" || modelDeploymentID == "" {
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 {
// TODO: Update the following line with your application specific error handling logic
log.Printf("ERROR: %s", err)
return
}
mp3Bytes, err := os.ReadFile("testdata/sampledata_audiofiles_myVoiceIsMyPassportVerifyMe01.mp3")
if err != nil {
// TODO: Update the following line with your application specific error handling logic
log.Printf("ERROR: %s", err)
return
}
resp, err := client.GetAudioTranscription(context.TODO(), azopenai.AudioTranscriptionOptions{
File: mp3Bytes,
// this will return _just_ the translated text. Other formats are available, which return
// different or additional metadata. See [azopenai.AudioTranscriptionFormat] for more examples.
ResponseFormat: to.Ptr(azopenai.AudioTranscriptionFormatText),
DeploymentName: &modelDeploymentID,
}, nil)
if err != nil {
// TODO: Update the following line with your application specific error handling logic
log.Printf("ERROR: %s", err)
return
}
fmt.Fprintf(os.Stderr, "Transcribed text: %s\n", *resp.Text)
}
Csevegés
Client.GetChatCompletions
package main
import (
"context"
"fmt"
"log"
"os"
"github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai"
"github.com/Azure/azure-sdk-for-go/sdk/azcore"
)
func main() {
azureOpenAIKey := os.Getenv("AOAI_CHAT_COMPLETIONS_API_KEY")
modelDeploymentID := os.Getenv("AOAI_CHAT_COMPLETIONS_MODEL")
// Ex: "https://<your-azure-openai-host>.openai.azure.com"
azureOpenAIEndpoint := os.Getenv("AOAI_CHAT_COMPLETIONS_ENDPOINT")
if azureOpenAIKey == "" || modelDeploymentID == "" || azureOpenAIEndpoint == "" {
fmt.Fprintf(os.Stderr, "Skipping example, environment variables missing\n")
return
}
keyCredential := azcore.NewKeyCredential(azureOpenAIKey)
// In Azure OpenAI you must deploy a model before you can use it in your client. For more information
// see here: https://learn.microsoft.com/azure/cognitive-services/openai/how-to/create-resource
client, err := azopenai.NewClientWithKeyCredential(azureOpenAIEndpoint, keyCredential, nil)
if err != nil {
// TODO: Update the following line with your application specific error handling logic
log.Printf("ERROR: %s", err)
return
}
// This is a conversation in progress.
// NOTE: all messages, regardless of role, count against token usage for this API.
messages := []azopenai.ChatRequestMessageClassification{
// You set the tone and rules of the conversation with a prompt as the system role.
&azopenai.ChatRequestSystemMessage{Content: azopenai.NewChatRequestSystemMessageContent("You are a helpful assistant. You will talk like a pirate.")},
// The user asks a question
&azopenai.ChatRequestUserMessage{Content: azopenai.NewChatRequestUserMessageContent("Can you help me?")},
// The reply would come back from the ChatGPT. You'd add it to the conversation so we can maintain context.
&azopenai.ChatRequestAssistantMessage{Content: azopenai.NewChatRequestAssistantMessageContent("Arrrr! Of course, me hearty! What can I do for ye?")},
// The user answers the question based on the latest reply.
&azopenai.ChatRequestUserMessage{Content: azopenai.NewChatRequestUserMessageContent("What's the best way to train a parrot?")},
// from here you'd keep iterating, sending responses back from ChatGPT
}
gotReply := false
resp, err := client.GetChatCompletions(context.TODO(), azopenai.ChatCompletionsOptions{
// This is a conversation in progress.
// NOTE: all messages count against token usage for this API.
Messages: messages,
DeploymentName: &modelDeploymentID,
}, nil)
if err != nil {
// TODO: Update the following line with your application specific error handling logic
log.Printf("ERROR: %s", err)
return
}
for _, choice := range resp.Choices {
gotReply = true
if choice.ContentFilterResults != nil {
fmt.Fprintf(os.Stderr, "Content filter results\n")
if choice.ContentFilterResults.Error != nil {
fmt.Fprintf(os.Stderr, " Error:%v\n", choice.ContentFilterResults.Error)
}
fmt.Fprintf(os.Stderr, " Hate: sev: %v, filtered: %v\n", *choice.ContentFilterResults.Hate.Severity, *choice.ContentFilterResults.Hate.Filtered)
fmt.Fprintf(os.Stderr, " SelfHarm: sev: %v, filtered: %v\n", *choice.ContentFilterResults.SelfHarm.Severity, *choice.ContentFilterResults.SelfHarm.Filtered)
fmt.Fprintf(os.Stderr, " Sexual: sev: %v, filtered: %v\n", *choice.ContentFilterResults.Sexual.Severity, *choice.ContentFilterResults.Sexual.Filtered)
fmt.Fprintf(os.Stderr, " Violence: sev: %v, filtered: %v\n", *choice.ContentFilterResults.Violence.Severity, *choice.ContentFilterResults.Violence.Filtered)
}
if choice.Message != nil && choice.Message.Content != nil {
fmt.Fprintf(os.Stderr, "Content[%d]: %s\n", *choice.Index, *choice.Message.Content)
}
if choice.FinishReason != nil {
// this choice's conversation is complete.
fmt.Fprintf(os.Stderr, "Finish reason[%d]: %s\n", *choice.Index, *choice.FinishReason)
}
}
if gotReply {
fmt.Fprintf(os.Stderr, "Got chat completions reply\n")
}
}
Client.GetChatCompletionsStream
package main
import (
"context"
"errors"
"fmt"
"io"
"log"
"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("AOAI_CHAT_COMPLETIONS_API_KEY")
modelDeploymentID := os.Getenv("AOAI_CHAT_COMPLETIONS_MODEL")
// Ex: "https://<your-azure-openai-host>.openai.azure.com"
azureOpenAIEndpoint := os.Getenv("AOAI_CHAT_COMPLETIONS_ENDPOINT")
if azureOpenAIKey == "" || modelDeploymentID == "" || azureOpenAIEndpoint == "" {
fmt.Fprintf(os.Stderr, "Skipping example, environment variables missing\n")
return
}
keyCredential := azcore.NewKeyCredential(azureOpenAIKey)
// In Azure OpenAI you must deploy a model before you can use it in your client. For more information
// see here: https://learn.microsoft.com/azure/cognitive-services/openai/how-to/create-resource
client, err := azopenai.NewClientWithKeyCredential(azureOpenAIEndpoint, keyCredential, nil)
if err != nil {
// TODO: Update the following line with your application specific error handling logic
log.Printf("ERROR: %s", err)
return
}
// This is a conversation in progress.
// NOTE: all messages, regardless of role, count against token usage for this API.
messages := []azopenai.ChatRequestMessageClassification{
// You set the tone and rules of the conversation with a prompt as the system role.
&azopenai.ChatRequestSystemMessage{Content: azopenai.NewChatRequestSystemMessageContent("You are a helpful assistant. You will talk like a pirate and limit your responses to 20 words or less.")},
// The user asks a question
&azopenai.ChatRequestUserMessage{Content: azopenai.NewChatRequestUserMessageContent("Can you help me?")},
// The reply would come back from the ChatGPT. You'd add it to the conversation so we can maintain context.
&azopenai.ChatRequestAssistantMessage{Content: azopenai.NewChatRequestAssistantMessageContent("Arrrr! Of course, me hearty! What can I do for ye?")},
// The user answers the question based on the latest reply.
&azopenai.ChatRequestUserMessage{Content: azopenai.NewChatRequestUserMessageContent("What's the best way to train a parrot?")},
// from here you'd keep iterating, sending responses back from ChatGPT
}
resp, err := client.GetChatCompletionsStream(context.TODO(), azopenai.ChatCompletionsStreamOptions{
// This is a conversation in progress.
// NOTE: all messages count against token usage for this API.
Messages: messages,
N: to.Ptr[int32](1),
DeploymentName: &modelDeploymentID,
}, nil)
if err != nil {
// TODO: Update the following line with your application specific error handling logic
log.Printf("ERROR: %s", err)
return
}
defer resp.ChatCompletionsStream.Close()
gotReply := false
for {
chatCompletions, err := resp.ChatCompletionsStream.Read()
if errors.Is(err, io.EOF) {
break
}
if err != nil {
// TODO: Update the following line with your application specific error handling logic
log.Printf("ERROR: %s", err)
return
}
for _, choice := range chatCompletions.Choices {
gotReply = true
text := ""
if choice.Delta.Content != nil {
text = *choice.Delta.Content
}
role := ""
if choice.Delta.Role != nil {
role = string(*choice.Delta.Role)
}
fmt.Fprintf(os.Stderr, "Content[%d], role %q: %q\n", *choice.Index, role, text)
}
}
if gotReply {
fmt.Fprintf(os.Stderr, "Got chat completions streaming reply\n")
}
}
Beágyazások
Client.GetEmbeddings
package main
import (
"context"
"fmt"
"log"
"os"
"github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai"
"github.com/Azure/azure-sdk-for-go/sdk/azcore"
)
func main() {
azureOpenAIKey := os.Getenv("AOAI_EMBEDDINGS_API_KEY")
modelDeploymentID := os.Getenv("AOAI_EMBEDDINGS_MODEL")
// Ex: "https://<your-azure-openai-host>.openai.azure.com"
azureOpenAIEndpoint := os.Getenv("AOAI_EMBEDDINGS_ENDPOINT")
if azureOpenAIKey == "" || modelDeploymentID == "" || azureOpenAIEndpoint == "" {
fmt.Fprintf(os.Stderr, "Skipping example, environment variables missing\n")
return
}
keyCredential := azcore.NewKeyCredential(azureOpenAIKey)
// In Azure OpenAI you must deploy a model before you can use it in your client. For more information
// see here: https://learn.microsoft.com/azure/cognitive-services/openai/how-to/create-resource
client, err := azopenai.NewClientWithKeyCredential(azureOpenAIEndpoint, keyCredential, nil)
if err != nil {
// TODO: Update the following line with your application specific error handling logic
log.Printf("ERROR: %s", err)
return
}
resp, err := client.GetEmbeddings(context.TODO(), azopenai.EmbeddingsOptions{
Input: []string{"Testing, testing, 1,2,3."},
DeploymentName: &modelDeploymentID,
}, nil)
if err != nil {
// TODO: Update the following line with your application specific error handling logic
log.Printf("ERROR: %s", err)
return
}
for _, embed := range resp.Data {
// embed.Embedding contains the embeddings for this input index.
fmt.Fprintf(os.Stderr, "Got embeddings for input %d\n", *embed.Index)
}
}
Képgenerálás
Client.GetImageGenerations
package main
import (
"context"
"fmt"
"log"
"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("AOAI_DALLE_API_KEY")
// Ex: "https://<your-azure-openai-host>.openai.azure.com"
azureOpenAIEndpoint := os.Getenv("AOAI_DALLE_ENDPOINT")
azureDeployment := os.Getenv("AOAI_DALLE_MODEL")
if azureOpenAIKey == "" || azureOpenAIEndpoint == "" || azureDeployment == "" {
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 {
// TODO: Update the following line with your application specific error handling logic
log.Printf("ERROR: %s", err)
return
}
resp, err := client.GetImageGenerations(context.TODO(), azopenai.ImageGenerationOptions{
Prompt: to.Ptr("a cat"),
ResponseFormat: to.Ptr(azopenai.ImageGenerationResponseFormatURL),
DeploymentName: &azureDeployment,
}, nil)
if err != nil {
// TODO: Update the following line with your application specific error handling logic
log.Printf("ERROR: %s", err)
return
}
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 {
// TODO: Update the following line with your application specific error handling logic
log.Printf("ERROR: %s", err)
return
}
_ = resp.Body.Close()
fmt.Fprintf(os.Stderr, "Image generated, HEAD request on URL returned %d\n", resp.StatusCode)
}
}
Befejezések (örökölt)
Client.GetChatCompletions
package main
import (
"context"
"fmt"
"log"
"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("AOAI_COMPLETIONS_API_KEY")
modelDeployment := os.Getenv("AOAI_COMPLETIONS_MODEL")
// Ex: "https://<your-azure-openai-host>.openai.azure.com"
azureOpenAIEndpoint := os.Getenv("AOAI_COMPLETIONS_ENDPOINT")
if azureOpenAIKey == "" || modelDeployment == "" || azureOpenAIEndpoint == "" {
fmt.Fprintf(os.Stderr, "Skipping example, environment variables missing\n")
return
}
keyCredential := azcore.NewKeyCredential(azureOpenAIKey)
// In Azure OpenAI you must deploy a model before you can use it in your client. For more information
// see here: https://learn.microsoft.com/azure/cognitive-services/openai/how-to/create-resource
client, err := azopenai.NewClientWithKeyCredential(azureOpenAIEndpoint, keyCredential, nil)
if err != nil {
// TODO: Update the following line with your application specific error handling logic
log.Printf("ERROR: %s", err)
return
}
resp, err := client.GetCompletions(context.TODO(), azopenai.CompletionsOptions{
Prompt: []string{"What is Azure OpenAI, in 20 words or less"},
MaxTokens: to.Ptr(int32(2048)),
Temperature: to.Ptr(float32(0.0)),
DeploymentName: &modelDeployment,
}, nil)
if err != nil {
// TODO: Update the following line with your application specific error handling logic
log.Printf("ERROR: %s", err)
return
}
for _, choice := range resp.Choices {
fmt.Fprintf(os.Stderr, "Result: %s\n", *choice.Text)
}
}
Hibakezelés
A HTTP-kéréseket küldő metódusok akkor térnek vissza *azcore.ResponseError
, ha ezek a kérések sikertelenek.
ResponseError
hibaadatokkal és a szolgáltatás nyers válaszával rendelkezik.
Naplózás
Ez a modul az azcore naplózási implementációt használja. Az összes Azure SDK-modul naplózásának bekapcsolásához állítsa AZURE_SDK_GO_LOGGING az összesre. Alapértelmezés szerint a naplózó a stderrbe ír. A naplókimenet szabályozásához használja az azcore/log csomagot. Például csak HTTP-kérés- és válaszeseményeket naplózhat, és stdoutra nyomtathatja őket:
import azlog "github.com/Azure/azure-sdk-for-go/sdk/azcore/log"
// Print log events to stdout
azlog.SetListener(func(cls azlog.Event, msg string) {
fmt.Println(msg)
})
// Includes only requests and responses in credential logs
azlog.SetEvents(azlog.EventRequest, azlog.EventResponse)
Forráskód | összetevő (Maven) | API-referenciadokumentáció | csomaghivatkozási dokumentációmintái
Az Azure OpenAI API verziótámogatása
A Pythonhoz és JavaScripthez készült Azure OpenAI ügyfélkódtárakkal ellentétben az Azure OpenAI Java-csomag kompatibilitásának biztosítása érdekében az Azure OpenAI API-verziók egy adott részhalmazára korlátozódik. Általában minden Azure OpenAI Java-csomag feloldja az Azure OpenAI API újabb kiadási funkcióinak elérését. A legújabb API-verziókhoz való hozzáférés hatással van a funkciók rendelkezésre állására.
A verzióválasztást az OpenAIServiceVersion
enumerálás szabályozza.
Az Azure OpenAI legújabb előzetes API-ja a következő:
-2024-08-01-preview
A legújabb stabil (GA) kiadás támogatott:
-2024-06-01
Telepítés
Csomag részletei
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-ai-openai</artifactId>
<version>1.0.0-beta.12</version>
</dependency>
Hitelesítés
Az Azure OpenAI szolgáltatással való interakcióhoz létre kell hoznia egy ügyfélosztály-példányt, OpenAIAsyncClient
vagy OpenAIClient
a használatával OpenAIClientBuilder
. Ha konfigurálni szeretne egy ügyfelet az Azure OpenAI-val való használatra, adjon meg érvényes végponti URI-t egy Azure OpenAI-erőforrásnak, valamint egy megfelelő kulcs-hitelesítő adatot, jogkivonat-hitelesítő adatot vagy Azure Identity-hitelesítő adatot, amely jogosult az Azure OpenAI-erőforrás használatára.
A Microsoft Entra-azonosítóval való hitelesítéshez kezdeti beállítás szükséges:
Adja hozzá az Azure Identity-csomagot:
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-identity</artifactId>
<version>1.13.3</version>
</dependency>
A beállítás után kiválaszthatja, hogy milyen típusú hitelesítő azure.identity
adatokat használjon. Példaként DefaultAzureCredential
használható az ügyfél hitelesítésére: A Microsoft Entra ID alkalmazás ügyfélazonosítójának, bérlőazonosítójának és ügyféltitkának értékeit környezeti változókként állíthatja be: AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET.
Az engedélyezés a DefaultAzureCredential használatával a legegyszerűbb. A rendszer megkeresi a legjobb hitelesítő adatokat a futó környezetben.
TokenCredential defaultCredential = new DefaultAzureCredentialBuilder().build();
OpenAIClient client = new OpenAIClientBuilder()
.credential(defaultCredential)
.endpoint("{endpoint}")
.buildClient();
További információ az Azure OpenAI kulcs nélküli hitelesítéséről: Az Azure OpenAI használata kulcsok nélkül.
Hang
client.getAudioTranscription
String fileName = "{your-file-name}";
Path filePath = Paths.get("{your-file-path}" + fileName);
byte[] file = BinaryData.fromFile(filePath).toBytes();
AudioTranscriptionOptions transcriptionOptions = new AudioTranscriptionOptions(file)
.setResponseFormat(AudioTranscriptionFormat.JSON);
AudioTranscription transcription = client.getAudioTranscription("{deploymentOrModelName}", fileName, transcriptionOptions);
System.out.println("Transcription: " + transcription.getText());
client.generateSpeechFromText
Szövegfelolvasás (TTS)
String deploymentOrModelId = "{azure-open-ai-deployment-model-id}";
SpeechGenerationOptions options = new SpeechGenerationOptions(
"Today is a wonderful day to build something people love!",
SpeechVoice.ALLOY);
BinaryData speech = client.generateSpeechFromText(deploymentOrModelId, options);
// Checkout your generated speech in the file system.
Path path = Paths.get("{your-local-file-path}/speech.wav");
Files.write(path, speech.toBytes());
Csevegés
client.getChatCompletions
List<ChatRequestMessage> chatMessages = new ArrayList<>();
chatMessages.add(new ChatRequestSystemMessage("You are a helpful assistant. You will talk like a pirate."));
chatMessages.add(new ChatRequestUserMessage("Can you help me?"));
chatMessages.add(new ChatRequestAssistantMessage("Of course, me hearty! What can I do for ye?"));
chatMessages.add(new ChatRequestUserMessage("What's the best way to train a parrot?"));
ChatCompletions chatCompletions = client.getChatCompletions("{deploymentOrModelName}",
new ChatCompletionsOptions(chatMessages));
System.out.printf("Model ID=%s is created at %s.%n", chatCompletions.getId(), chatCompletions.getCreatedAt());
for (ChatChoice choice : chatCompletions.getChoices()) {
ChatResponseMessage message = choice.getMessage();
System.out.printf("Index: %d, Chat Role: %s.%n", choice.getIndex(), message.getRole());
System.out.println("Message:");
System.out.println(message.getContent());
}
Streamelés
List<ChatRequestMessage> chatMessages = new ArrayList<>();
chatMessages.add(new ChatRequestSystemMessage("You are a helpful assistant. You will talk like a pirate."));
chatMessages.add(new ChatRequestUserMessage("Can you help me?"));
chatMessages.add(new ChatRequestAssistantMessage("Of course, me hearty! What can I do for ye?"));
chatMessages.add(new ChatRequestUserMessage("What's the best way to train a parrot?"));
ChatCompletions chatCompletions = client.getChatCompletions("{deploymentOrModelName}",
new ChatCompletionsOptions(chatMessages));
System.out.printf("Model ID=%s is created at %s.%n", chatCompletions.getId(), chatCompletions.getCreatedAt());
for (ChatChoice choice : chatCompletions.getChoices()) {
ChatResponseMessage message = choice.getMessage();
System.out.printf("Index: %d, Chat Role: %s.%n", choice.getIndex(), message.getRole());
System.out.println("Message:");
System.out.println(message.getContent());
}
Csevegés befejezése képekkel
List<ChatRequestMessage> chatMessages = new ArrayList<>();
chatMessages.add(new ChatRequestSystemMessage("You are a helpful assistant that describes images"));
chatMessages.add(new ChatRequestUserMessage(Arrays.asList(
new ChatMessageTextContentItem("Please describe this image"),
new ChatMessageImageContentItem(
new ChatMessageImageUrl("https://raw.githubusercontent.com/MicrosoftDocs/azure-ai-docs/main/articles/ai-services/openai/media/how-to/generated-seattle.png"))
)));
ChatCompletionsOptions chatCompletionsOptions = new ChatCompletionsOptions(chatMessages);
ChatCompletions chatCompletions = client.getChatCompletions("{deploymentOrModelName}", chatCompletionsOptions);
System.out.println("Chat completion: " + chatCompletions.getChoices().get(0).getMessage().getContent());
Beágyazások
client.getEmbeddings
EmbeddingsOptions embeddingsOptions = new EmbeddingsOptions(
Arrays.asList("Your text string goes here"));
Embeddings embeddings = client.getEmbeddings("{deploymentOrModelName}", embeddingsOptions);
for (EmbeddingItem item : embeddings.getData()) {
System.out.printf("Index: %d.%n", item.getPromptIndex());
for (Float embedding : item.getEmbedding()) {
System.out.printf("%f;", embedding);
}
}
Képgenerálás
ImageGenerationOptions imageGenerationOptions = new ImageGenerationOptions(
"A drawing of the Seattle skyline in the style of Van Gogh");
ImageGenerations images = client.getImageGenerations("{deploymentOrModelName}", imageGenerationOptions);
for (ImageGenerationData imageGenerationData : images.getData()) {
System.out.printf(
"Image location URL that provides temporary access to download the generated image is %s.%n",
imageGenerationData.getUrl());
}
Hibák kezelése
Ügyfélnaplózás engedélyezése
Az Azure OpenAI-kódtárkal kapcsolatos problémák elhárításához fontos, hogy először engedélyezze a naplózást az alkalmazás viselkedésének monitorozásához. A naplókban szereplő hibák és figyelmeztetések általában hasznos betekintést nyújtanak a hibákba, és időnként korrekciós műveleteket is tartalmaznak a problémák megoldásához. A Java-hoz készült Azure-ügyfélkódtárak két naplózási lehetőséggel rendelkeznek:
- Beépített naplózási keretrendszer.
- A naplózás támogatása az SLF4J felülettel.
Tekintse meg a jelen referenciadokumentum utasításait a [naplózás konfigurálásához a Java-hoz készült Azure SDK-ban][logging_overview].
HTTP-kérések/válaszok naplózásának engedélyezése
A hibák elhárításához hasznos lehet az Azure OpenAI szolgáltatáson keresztül küldött VAGY a hálózaton keresztül kapott HTTP-kérés vagy válasz áttekintése. A HTTP-kérések és válaszok hasznos adatainak naplózásához az [OpenAIClient][openai_client] konfigurálható az alábbiak szerint. Ha nincs SLF4J Logger
az osztályútvonalon, állítson be egy környezeti változót [AZURE_LOG_LEVEL][azure_log_level] a gépen a naplózás engedélyezéséhez.
OpenAIClient openAIClient = new OpenAIClientBuilder()
.endpoint("{endpoint}")
.credential(new AzureKeyCredential("{key}"))
.httpLogOptions(new HttpLogOptions().setLogLevel(HttpLogDetailLevel.BODY_AND_HEADERS))
.buildClient();
// or
DefaultAzureCredential credential = new DefaultAzureCredentialBuilder().build();
OpenAIClient configurationClientAad = new OpenAIClientBuilder()
.credential(credential)
.endpoint("{endpoint}")
.httpLogOptions(new HttpLogOptions().setLogLevel(HttpLogDetailLevel.BODY_AND_HEADERS))
.buildClient();
Másik lehetőségként konfigurálhatja a http-kérések és válaszok naplózását a teljes alkalmazáshoz az alábbi környezeti változó beállításával. Vegye figyelembe, hogy ez a módosítás minden olyan Azure-ügyfél naplózását engedélyezi, amely támogatja a HTTP-kérések/válaszok naplózását.
Környezeti változó neve: AZURE_HTTP_LOG_DETAIL_LEVEL
Érték | Naplózási szint |
---|---|
Nincs | A HTTP-kérések/válaszok naplózása le van tiltva |
alapvető | Csak URL-címeket, HTTP-metódusokat és a kérés befejezéséhez szükséges időt naplózza. |
Fejlécek | Mindent naplóz a BASIC-ben, valamint az összes kérés- és válaszfejlécet. |
törzs | Mindent naplóz a BASIC-ben, valamint az összes kérés- és választörzset. |
body_and_headers | Mindent naplóz a FEJLÉCEKBEN és a TÖRZSben. |
Feljegyzés
A kérések és válaszok törzsének naplózásakor győződjön meg arról, hogy nem tartalmaznak bizalmas információkat. A fejlécek naplózásakor az ügyféltár alapértelmezett fejléckészlettel rendelkezik, amelyek biztonságosnak tekinthetők, de ez a készlet frissíthető a szerkesztő naplóbeállításainak frissítésével az alábbiak szerint.
clientBuilder.httpLogOptions(new HttpLogOptions().addAllowedHeaderName("safe-to-log-header-name"))
Kivételek hibaelhárítása
Az Azure OpenAI szolgáltatás metódusai hibát jeleznek[HttpResponseException
, vagy annak alosztályát.
Az HttpResponseException
OpenAI ügyfélkódtár által létrehozott részletes válaszhiba-objektum konkrét hasznos elemzéseket nyújt a hiba elhárításához, és korrekciós műveleteket tartalmaz a gyakori problémák megoldásához.
Ez a hibainformáció az objektum üzenettulajdonságában HttpResponseException
található.
Az alábbi példa azt mutatja be, hogyan foghatja el szinkron ügyféllel
List<ChatRequestMessage> chatMessages = new ArrayList<>();
chatMessages.add(new ChatRequestSystemMessage("You are a helpful assistant. You will talk like a pirate."));
chatMessages.add(new ChatRequestUserMessage("Can you help me?"));
chatMessages.add(new ChatRequestAssistantMessage("Of course, me hearty! What can I do for ye?"));
chatMessages.add(new ChatRequestUserMessage("What's the best way to train a parrot?"));
try {
ChatCompletions chatCompletions = client.getChatCompletions("{deploymentOrModelName}",
new ChatCompletionsOptions(chatMessages));
} catch (HttpResponseException e) {
System.out.println(e.getMessage());
// Do something with the exception
}
Az aszinkron ügyfelekkel a hibavisszahívások kivételeit észlelheti és kezelheti:
asyncClient.getChatCompletions("{deploymentOrModelName}", new ChatCompletionsOptions(chatMessages))
.doOnSuccess(ignored -> System.out.println("Success!"))
.doOnError(
error -> error instanceof ResourceNotFoundException,
error -> System.out.println("Exception: 'getChatCompletions' could not be performed."));
Hitelesítési hibák
Az Azure OpenAI támogatja a Microsoft Entra ID-hitelesítést.
OpenAIClientBuilder
metódust használ a beállításhoz credential
. Érvényes hitelesítő adatok megadásához használhat azure-identity
függőséget.
Forráskódcsomag (npm) | referencia | |
Az Azure OpenAI API verziótámogatása
Az Azure OpenAI szolgáltatás rendelkezésre állása a megcélzott REST API melyik verziójától függ. A legújabb funkciók esetében a legújabb előzetes API-t célozd meg.
Legújabb GA API | Legújabb előzetes verziójú API |
---|---|
2024-10-21 |
2025-01-01-preview |
Telepítés
npm install openai
Hitelesítés
Az Azure OpenAI szolgáltatással többféleképpen is hitelesíthető a Microsoft Entra ID-jogkivonatok használatával. Az alapértelmezett módszer az osztály használata a DefaultAzureCredential
@azure/identity
csomagból.
import { DefaultAzureCredential } from "@azure/identity";
const credential = new DefaultAzureCredential();
Ezt az objektumot ezután az AzureClientOptions
objektum részeként továbbítja a rendszer az AzureOpenAI
AssistantsClient
ügyfélkonstruktoroknak.
Az ügyfél hitelesítéséhez AzureOpenAI
azonban a getBearerTokenProvider
csomagból származó @azure/identity
függvényt kell használnunk. Ez a függvény létrehoz egy jogkivonat-szolgáltatót, amely AzureOpenAI
belsőleg használja az egyes kérések jogkivonatainak lekérését. A jogkivonat-szolgáltató a következőképpen jön létre:
import { AzureOpenAI } from 'openai';
import { DefaultAzureCredential, getBearerTokenProvider } from "@azure/identity";
const credential = new DefaultAzureCredential();
const endpoint = "https://your-azure-openai-resource.com";
const apiVersion = "2024-10-21"
const scope = "https://cognitiveservices.azure.com/.default";
const azureADTokenProvider = getBearerTokenProvider(credential, scope);
const deployment = "gpt-35-turbo";
const client = new AzureOpenAI({
endpoint,
apiVersion,
deployment,
azureADTokenProvider
});
Az Azure OpenAI kulcs nélküli hitelesítésével kapcsolatos további információkért tekintse meg az "Első lépések az Azure OpenAI biztonsági építőelemével" rövid útmutatót.
Konfiguráció
Az AzureClientOptions
objektum kibővíti az OpenAI ClientOptions
objektumot. Ez az Azure-specifikus ügyfélobjektum az Azure OpenAI-ügyfél kapcsolatának és viselkedésének konfigurálására szolgál. Az Azure-ban egyedi tulajdonságok megadására szolgáló tulajdonságokat tartalmaz.
Tulajdonság | Részletek |
---|---|
apiVersion: string |
A használni kívánt API-verziót adja meg. |
azureADTokenProvider: (() => Promise<string>) |
Egy függvény, amely a Microsoft Entra (korábbi nevén Azure Active Directory) hozzáférési jogkivonatát adja vissza, amelyet minden kéréskor meghívnak. |
felfejlődés: string |
Modelltelepítés. Ha meg van adva, az alapügyfél URL-címét adja meg./deployments/{deployment} A nem üzembehelyezési végpontok nem használhatók (az Assistants API-k nem támogatottak). |
végpont: string |
Az Azure OpenAI-végpont a következő formátumban: https://RESOURCE-NAME.azure.openai.com/ . |
Hang
Transzkripció
import { createReadStream } from "fs";
const result = await client.audio.transcriptions.create({
model: '',
file: createReadStream(audioFilePath),
});
Csevegés
chat.completions.create
const result = await client.chat.completions.create({ messages, model: '', max_tokens: 100 });
Streamelés
const stream = await client.chat.completions.create({ model: '', messages, max_tokens: 100, stream: true });
Beágyazások
const embeddings = await client.embeddings.create({ input, model: '' });
Képgenerálás
const results = await client.images.generate({ prompt, model: '', n, size });
Hibakezelés
Hibakódok
Állapotkód | Hibatípus |
---|---|
400 | Bad Request Error |
401 | Authentication Error |
403 | Permission Denied Error |
404 | Not Found Error |
422 | Unprocessable Entity Error |
429 | Rate Limit Error |
500 | Internal Server Error |
503 | Service Unavailable |
504 | Gateway Timeout |
Újrapróbálkozások
A rendszer alapértelmezés szerint automatikusan kétszer kivonja a következő hibákat egy rövid exponenciális visszalépéssel:
- Csatlakozási hibák
- 408 Kérés időtúllépése
- 429 sebességkorlát
-
>=
500 belső hiba
Az újrapróbálkozás viselkedésének beállítására/letiltására használható maxRetries
:
// Configure the default for all requests:
const client = new AzureOpenAI({
maxRetries: 0, // default is 2
});
// Or, configure per-request:
await client.chat.completions.create({ messages: [{ role: 'user', content: 'How can I get the name of the current day in Node.js?' }], model: '' }, {
maxRetries: 5,
});
Kódtár forráskódcsomagja (PyPi) | -referencia | |
Feljegyzés
Ezt a könyvtárat az OpenAI tartja karban. A kódtár legújabb frissítéseinek nyomon követéséhez tekintse meg a kiadási előzményeket.
Az Azure OpenAI API verziótámogatása
Az Azure OpenAI szolgáltatás rendelkezésre állása a megcélzott REST API melyik verziójától függ. A legújabb funkciók esetében a legújabb előzetes API-t célozd meg.
Legújabb GA API | Legújabb előzetes verziójú API |
---|---|
2024-10-21 |
2025-01-01-preview |
Telepítés
pip install openai
A legújabb verzió esetén:
pip install openai --upgrade
Hitelesítés
import os
from openai import AzureOpenAI
from azure.identity import DefaultAzureCredential, get_bearer_token_provider
token_provider = get_bearer_token_provider(
DefaultAzureCredential(), "https://cognitiveservices.azure.com/.default"
)
client = AzureOpenAI(
azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT"),
azure_ad_token_provider=token_provider,
api_version="2024-10-21"
)
Az Azure OpenAI kulcs nélküli hitelesítésével kapcsolatos további információkért tekintse meg az "Első lépések az Azure OpenAI biztonsági építőelemével" rövid útmutatót.
Hang
audio.speech.create()
Ez a függvény jelenleg előzetes verziójú API-t igényel.
Állítsa be api_version="2024-10-01-preview"
ezt a függvényt.
# from openai import AzureOpenAI
# client = AzureOpenAI()
from pathlib import Path
import os
speech_file_path = Path("speech.mp3")
response = client.audio.speech.create(
model="tts-hd", #Replace with model deployment name
voice="alloy",
input="Testing, testing, 1,2,3."
)
response.write_to_file(speech_file_path)
audio.transcriptions.create()
# from openai import AzureOpenAI
# client = AzureOpenAI()
audio_file = open("speech1.mp3", "rb")
transcript = client.audio.transcriptions.create(
model="whisper", # Replace with model deployment name
file=audio_file
)
print(transcript)
Csevegés
chat.completions.create()
# from openai import AzureOpenAI
# client = AzureOpenAI()
completion = client.chat.completions.create(
model="gpt-4o", # Replace with your model dpeloyment name.
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "When was Microsoft founded?"}
]
)
#print(completion.choices[0].message)
print(completion.model_dump_json(indent=2)
chat.completions.create() – streamelés
# from openai import AzureOpenAI
# client = AzureOpenAI()
completion = client.chat.completions.create(
model="gpt-4o", # Replace with your model dpeloyment name.
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "When was Microsoft founded?"}
],
stream=True
)
for chunk in completion:
if chunk.choices and chunk.choices[0].delta.content is not None:
print(chunk.choices[0].delta.content, end='',)
chat.completions.create() – képbemenet
completion = client.chat.completions.create(
model="gpt-4o",
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": "What's in this image?"},
{
"type": "image_url",
"image_url": {
"url": "https://raw.githubusercontent.com/MicrosoftDocs/azure-ai-docs/main/articles/ai-services/openai/media/how-to/generated-seattle.png",
}
},
],
}
],
max_tokens=300,
)
print(completion.model_dump_json(indent=2))
Beágyazások
embeddings.create()
# from openai import AzureOpenAI
# client = AzureOpenAI()
embedding = client.embeddings.create(
model="text-embedding-3-large", # Replace with your model deployment name
input="Attenion is all you need",
encoding_format="float"
)
print(embedding)
Finomhangolás
Finomhangolás Python-útmutatóval
Batch
Batch és Python – útmutató cikk
Képek
images.generate()
# from openai import AzureOpenAI
# client = AzureOpenAI()
generate_image = client.images.generate(
model="dall-e-3", #replace with your model deployment name
prompt="A rabbit eating pancakes",
n=1,
size="1024x1024",
quality = "hd",
response_format = "url",
style = "vivid"
)
print(generate_image.model_dump_json(indent=2))
Befejezések (örökölt)
completions.create()
# from openai import AzureOpenAI
# client = AzureOpenAI()
legacy_completion = client.completions.create(
model="gpt-35-turbo-instruct", # Replace with model deployment name
prompt="Hello World!",
max_tokens=100,
temperature=0
)
print(legacy_completion.model_dump_json(indent=2))
Hibakezelés
# from openai import AzureOpenAI
# client = AzureOpenAI()
import openai
try:
client.fine_tuning.jobs.create(
model="gpt-4o",
training_file="file-test",
)
except openai.APIConnectionError as e:
print("The server could not be reached")
print(e.__cause__) # an underlying Exception, likely raised within httpx.
except openai.RateLimitError as e:
print("A 429 status code was received; we should back off a bit.")
except openai.APIStatusError as e:
print("Another non-200-range status code was received")
print(e.status_code)
print(e.response)
Hibakódok
Állapotkód | Hibatípus |
---|---|
400 | BadRequestError |
401 | AuthenticationError |
403 | PermissionDeniedError |
404 | NotFoundError |
422 | UnprocessableEntityError |
429 | RateLimitError |
>=500 | InternalServerError |
n/a | APIConnectionError |
Azonosítók kérése
A kérés azonosítójának lekéréséhez használhatja a _request_id
válaszfejlécnek x-request-id
megfelelő tulajdonságot.
print(completion._request_id)
print(legacy_completion._request_id)
Újrapróbálkozások
A rendszer alapértelmezés szerint automatikusan kétszer kivonja a következő hibákat egy rövid exponenciális visszalépéssel:
- Csatlakozási hibák
- 408 Kérés időtúllépése
- 429 sebességkorlát
-
>=
500 belső hiba
Az újrapróbálkozás viselkedésének beállítására/letiltására használható max_retries
:
# For all requests
from openai import AzureOpenAI
client = AzureOpenAI(
max_retries=0
)
# max retires for specific requests
client.with_options(max_retries=5).chat.completions.create(
messages=[
{
"role": "user",
"content": "When was Microsoft founded?",
}
],
model="gpt-4o",
)
Következő lépések
- A jelenleg támogatott modellek megtekintéséhez tekintse meg az Azure OpenAI-modellek oldalát