Ta przeglądarka nie jest już obsługiwana.
Przejdź na przeglądarkę Microsoft Edge, aby korzystać z najnowszych funkcji, aktualizacji zabezpieczeń i pomocy technicznej.
Biblioteka klienta platformy Azure OpenAI dla platformy .NET jest towarzyszem oficjalnej biblioteki klienta openAI dla platformy .NET. Biblioteka Azure OpenAI konfiguruje klienta do użycia z usługą Azure OpenAI i zapewnia bardzo silnie typizowaną obsługę rozszerzeń dla modeli żądań i odpowiedzi specyficznych dla scenariuszy usługi Azure OpenAI.
Dokumentacja dokumentacji interfejsu API | dokumentacji pakietu kodu źródłowego | (NuGet)Przykłady |
Wersja zapoznawcza ma dostęp do najnowszych funkcji.
Dokumentacja | referencyjna pakietu kodu źródłowego | (NuGet) | API Dokumentacja pakietu — dokumentacjapakietu — przykłady
W przeciwieństwie do bibliotek klienckich platformy Azure OpenAI dla języków Python i JavaScript pakiet platformy .NET usługi Azure OpenAI jest ograniczony do określania określonego podzestawu wersji interfejsu API usługi Azure OpenAI. Ogólnie każdy pakiet platformy .NET platformy Azure OpenAI odblokowuje dostęp do nowszych funkcji interfejsu API openAI platformy Azure. Dostęp do najnowszych wersji interfejsu API ma wpływ na dostępność funkcji.
Wybór wersji jest kontrolowany przez wyliczenie AzureOpenAIClientOptions.ServiceVersion .
Stabilna wersja jest obecnie przeznaczona dla następujących elementów:
2024-06-01
Wersja zapoznawcza może być obecnie docelowa:
2024-06-012024-08-01-preview2024-09-01-preview2024-10-01-previewdotnet add package Azure.AI.OpenAI --prerelease
Pakiet Azure.AI.OpenAI jest oparty na oficjalnym pakiecie OpenAI, który jest dołączany jako zależność.
Aby wchodzić w interakcje z usługą Azure OpenAI lub OpenAI, utwórz wystąpienie AzureOpenAIClient z jednym z następujących podejść:
Bezpieczne, bezkluczane podejście do uwierzytelniania polega na użyciu identyfikatora Entra firmy Microsoft (dawniej Azure Active Directory) za pośrednictwem biblioteki tożsamości platformy Azure. Aby użyć biblioteki:
dotnet add package Azure.Identity
Użyj żądanego typu poświadczeń z biblioteki. Na przykład : DefaultAzureCredential
AzureOpenAIClient azureClient = new(
new Uri("https://your-azure-openai-resource.com"),
new DefaultAzureCredential());
ChatClient chatClient = azureClient.GetChatClient("my-gpt-4o-mini-deployment");
Aby uzyskać więcej informacji na temat uwierzytelniania bez klucza usługi Azure OpenAI, zobacz artykuł Szybki start "Rozpoczynanie pracy z blokiem konstrukcyjnym zabezpieczeń usługi Azure OpenAI".
AzureOpenAIClient.GetAudioClient
AzureOpenAIClient azureClient = new(
new Uri("https://your-azure-openai-resource.com"),
new DefaultAzureCredential());
AudioClient client = azureClient.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}");
}
using Azure.AI.OpenAI;
using Azure.Identity;
using OpenAI.Audio;
AzureOpenAIClient azureClient = new(
new Uri("https://your-azure-openai-resource.com"),
new DefaultAzureCredential());
AudioClient client = azureClient.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);
AzureOpenAIClient.GetChatClient
AzureOpenAIClient azureClient = new(
new Uri("https://your-azure-openai-resource.com"),
new DefaultAzureCredential());
ChatClient chatClient = azureClient.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}");
Ukończenie czatu przesyłania strumieniowego CompleteChatStreaming używa metody i CompleteChatStreamingAsync , która zwraca ResultCollection<StreamingChatCompletionUpdate> wartość lub AsyncCollectionResult<StreamingChatCompletionUpdate> zamiast ClientResult<ChatCompletion>.
Te kolekcje wyników mogą być iterowane za pomocą foreach lub await foreach, a każda aktualizacja przybywa, ponieważ nowe dane są dostępne z odpowiedzi przesyłanej strumieniowo.
AzureOpenAIClient azureClient = new(
new Uri("https://your-azure-openai-resource.com"),
new DefaultAzureCredential());
ChatClient chatClient = azureClient.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);
}
}
AzureOpenAIClient.GetEmbeddingClient
using Azure.AI.OpenAI;
using Azure.Identity;
using OpenAI.Embeddings;
AzureOpenAIClient azureClient = new(
new Uri("https://your-azure-openai-resource.com"),
new DefaultAzureCredential());
EmbeddingClient client = azureClient.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()));
Obecnie nieobsługiwane w pakietach platformy .NET usługi Azure OpenAI.
Obecnie nieobsługiwane w pakietach platformy .NET usługi Azure OpenAI.
AzureOpenAIClient.GetImageClient
using Azure.AI.OpenAI;
using Azure.Identity;
using OpenAI.Images;
AzureOpenAIClient azureClient = new(
new Uri("https://your-azure-openai-resource.com"),
new DefaultAzureCredential());
ImageClient client = azureClient.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);
Nieobsługiwane w przypadku pakietów platformy .NET usługi Azure OpenAI.
| Kod stanu | Typ błędu |
|---|---|
| 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 |
Klasy klientów będą automatycznie ponawiać następujące błędy maksymalnie trzy razy przy użyciu wycofywania wykładniczego:
Dokumentacja dotycząca pakietu kodu źródłowego | (pkg.go.dev) | Dokumentacja dotycząca interfejsu | API Dokumentacja pakietu— przykłady
W przeciwieństwie do bibliotek klienckich platformy Azure OpenAI dla języków Python i JavaScript biblioteka Azure OpenAI Go jest przeznaczona dla określonej wersji interfejsu API usługi Azure OpenAI. Dostęp do najnowszych wersji interfejsu API ma wpływ na dostępność funkcji.
Bieżąca wersja interfejsu API usługi Azure OpenAI: 2024-10-01-preview
Jest to zdefiniowane w pliku custom_client.go.
azopenai Zainstaluj moduły i azidentity za pomocą polecenia get:
go get github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai
# optional
go get github.com/Azure/azure-sdk-for-go/sdk/azidentity
Moduł azidentity jest używany do uwierzytelniania usługi Azure Active Directory za pomocą usługi Azure OpenAI.
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
}
Aby uzyskać więcej informacji na temat uwierzytelniania bez klucza usługi Azure OpenAI, zobacz Używanie interfejsu Azure OpenAI bez kluczy.
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))
}
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)
}
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")
}
}
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")
}
}
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)
}
}
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)
}
}
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)
}
}
Wszystkie metody wysyłające żądania HTTP zwracają *azcore.ResponseError się, gdy te żądania kończą się niepowodzeniem.
ResponseError zawiera szczegóły błędu i nieprzetworzone odpowiedzi z usługi.
W tym module użyto implementacji rejestrowania w narzędziu azcore. Aby włączyć rejestrowanie dla wszystkich modułów zestawu Azure SDK, ustaw AZURE_SDK_GO_LOGGING na wszystkie. Domyślnie rejestrator zapisuje dane w stderr. Użyj pakietu azcore/log, aby kontrolować dane wyjściowe dziennika. Na przykład rejestrowanie tylko zdarzeń żądania HTTP i odpowiedzi oraz drukowanie ich w stdout:
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)
Dokumentacja | referencyjna interfejsu API artefaktu kodu | źródłowego (Maven) | Dokumentacjapakietu — przykłady
W przeciwieństwie do bibliotek klienckich platformy Azure OpenAI dla języków Python i JavaScript, aby zapewnić zgodność pakietu Java usługi Azure OpenAI jest ograniczona do określania określonego podzestawu wersji interfejsu API usługi Azure OpenAI. Ogólnie każdy pakiet Java openAI platformy Azure odblokowuje dostęp do nowszych funkcji interfejsu API openAI platformy Azure. Dostęp do najnowszych wersji interfejsu API ma wpływ na dostępność funkcji.
Wybór wersji jest kontrolowany przez wyliczenie OpenAIServiceVersion .
Najnowsza obsługiwana wersja zapoznawcza interfejsu API usługi Azure OpenAI to:
-2024-08-01-preview
Najnowsza obsługiwana stabilna wersja (GA) to:
-2024-06-01
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-ai-openai</artifactId>
<version>1.0.0-beta.12</version>
</dependency>
Aby móc korzystać z usługi Azure OpenAI Service, musisz utworzyć wystąpienie klasy OpenAIAsyncClient klienta lub OpenAIClient za pomocą polecenia OpenAIClientBuilder. Aby skonfigurować klienta do użycia z usługą Azure OpenAI, podaj prawidłowy identyfikator URI punktu końcowego dla zasobu usługi Azure OpenAI wraz z odpowiednimi poświadczeniami klucza, poświadczeniami tokenu lub poświadczeniami tożsamości platformy Azure, które są autoryzowane do korzystania z zasobu usługi Azure OpenAI.
Uwierzytelnianie przy użyciu identyfikatora Entra firmy Microsoft wymaga wstępnej konfiguracji:
Dodaj pakiet tożsamości platformy Azure:
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-identity</artifactId>
<version>1.13.3</version>
</dependency>
Po skonfigurowaniu można wybrać typ poświadczeń azure.identity do użycia. Na przykład DefaultAzureCredential można użyć do uwierzytelniania klienta: ustaw wartości identyfikatora klienta, identyfikatora dzierżawy i wpisu tajnego klienta aplikacji Microsoft Entra ID jako zmienne środowiskowe: AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET.
Autoryzacja jest najłatwiejsza przy użyciu wartości DefaultAzureCredential. Znajduje najlepsze poświadczenia do użycia w swoim uruchomionym środowisku.
TokenCredential defaultCredential = new DefaultAzureCredentialBuilder().build();
OpenAIClient client = new OpenAIClientBuilder()
.credential(defaultCredential)
.endpoint("{endpoint}")
.buildClient();
Aby uzyskać więcej informacji na temat uwierzytelniania bez klucza usługi Azure OpenAI, zobacz Używanie interfejsu Azure OpenAI bez kluczy.
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());
Zamiana tekstu na mowę (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());
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());
}
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());
}
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());
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);
}
}
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());
}
Aby rozwiązać problemy z biblioteką Azure OpenAI, należy najpierw włączyć rejestrowanie w celu monitorowania zachowania aplikacji. Błędy i ostrzeżenia w dziennikach zwykle zapewniają przydatne informacje o tym, co poszło nie tak, a czasami obejmują akcje naprawcze w celu rozwiązania problemów. Biblioteki klienta platformy Azure dla języka Java mają dwie opcje rejestrowania:
Zapoznaj się z instrukcjami w tym dokumencie referencyjnym, aby dowiedzieć się, jak [skonfigurować rejestrowanie w zestawie Azure SDK dla języka Java][logging_overview].
Przeglądanie żądania HTTP wysłanego lub odpowiedzi odebranego za pośrednictwem przewodu do/z usługi Azure OpenAI może być przydatne w rozwiązywaniu problemów. Aby włączyć rejestrowanie ładunku żądania HTTP i odpowiedzi, można skonfigurować element [OpenAIClient][openai_client], jak pokazano poniżej. Jeśli na ścieżce klasy nie ma żadnego SLF4J Logger , ustaw zmienną środowiskową [AZURE_LOG_LEVEL][azure_log_level] na maszynie, aby włączyć rejestrowanie.
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();
Alternatywnie można skonfigurować rejestrowanie żądań HTTP i odpowiedzi dla całej aplikacji, ustawiając następującą zmienną środowiskową. Pamiętaj, że ta zmiana spowoduje włączenie rejestrowania dla każdego klienta platformy Azure, który obsługuje rejestrowanie żądań/odpowiedzi HTTP.
Nazwa zmiennej środowiskowej: AZURE_HTTP_LOG_DETAIL_LEVEL
| Wartość | Poziom rejestrowania |
|---|---|
| Brak | Rejestrowanie żądań HTTP/odpowiedzi jest wyłączone |
| podstawowy | Rejestruje tylko adresy URL, metody HTTP i czas zakończenia żądania. |
| nagłówki | Rejestruje wszystkie elementy w warstwie PODSTAWOWA oraz wszystkie nagłówki żądań i odpowiedzi. |
| treść | Rejestruje wszystko w warstwie PODSTAWOWA oraz całą treść żądania i odpowiedzi. |
| body_and_headers | Rejestruje wszystko w nagłówkach i treści. |
Uwaga
Podczas rejestrowania treści żądania i odpowiedzi upewnij się, że nie zawierają informacji poufnych. Podczas rejestrowania nagłówków biblioteka klienta ma domyślny zestaw nagłówków, które są uważane za bezpieczne do rejestrowania, ale ten zestaw można zaktualizować, aktualizując opcje dziennika w konstruktorze, jak pokazano poniżej.
clientBuilder.httpLogOptions(new HttpLogOptions().addAllowedHeaderName("safe-to-log-header-name"))
Metody usługi Azure OpenAI zgłaszają błąd[HttpResponseException lub jej podklasę.
Biblioteka HttpResponseException klienta OpenAI zgłaszana przez bibliotekę klienta programu OpenAI zawiera szczegółowy obiekt błędu odpowiedzi, który zapewnia szczegółowe informacje o tym, co poszło nie tak, i zawiera akcje naprawcze w celu rozwiązania typowych problemów.
Te informacje o błędzie można znaleźć wewnątrz właściwości komunikatu HttpResponseException obiektu.
Oto przykład sposobu przechwytywania go za pomocą klienta synchronicznego
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
}
Za pomocą klientów asynchronicznych można przechwytywać wyjątki i obsługiwać je w wywołaniach zwrotnych błędów:
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."));
Usługa Azure OpenAI obsługuje uwierzytelnianie identyfikatora Entra firmy Microsoft.
OpenAIClientBuilder has method to set the credential. Aby podać prawidłowe poświadczenia, możesz użyć azure-identity zależności.
Dokumentacja pakietu kodu źródłowego | (npm)Reference | |
Dostępność funkcji w usłudze Azure OpenAI zależy od wersji docelowego interfejsu API REST. Najnowsze funkcje są przeznaczone dla najnowszego interfejsu API w wersji zapoznawczej.
| Najnowszy interfejs API ogólnie dostępnej wersji | Najnowszy interfejs API w wersji zapoznawczej |
|---|---|
2024-10-21 |
2025-01-01-preview |
npm install openai
Istnieje kilka sposobów uwierzytelniania za pomocą usługi Azure OpenAI przy użyciu tokenów identyfikatora Entra firmy Microsoft. Domyślnym sposobem jest użycie DefaultAzureCredential klasy z @azure/identity pakietu.
import { DefaultAzureCredential } from "@azure/identity";
const credential = new DefaultAzureCredential();
Ten obiekt jest następnie przekazywany jako część AzureClientOptions obiektu do AzureOpenAI konstruktorów klienta i AssistantsClient .
Aby uwierzytelnić AzureOpenAI klienta, musimy jednak użyć getBearerTokenProvider funkcji z @azure/identity pakietu. Ta funkcja tworzy dostawcę tokenów, który AzureOpenAI używa wewnętrznie do uzyskiwania tokenów dla każdego żądania. Dostawca tokenu jest tworzony w następujący sposób:
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
});
Aby uzyskać więcej informacji na temat uwierzytelniania bez klucza usługi Azure OpenAI, zobacz artykuł Szybki start "Rozpoczynanie pracy z blokiem konstrukcyjnym zabezpieczeń usługi Azure OpenAI".
Obiekt AzureClientOptions rozszerza obiekt OpenAI ClientOptions . Ten obiekt klienta specyficzny dla platformy Azure służy do konfigurowania połączenia i zachowania klienta usługi Azure OpenAI. Zawiera właściwości służące do określania właściwości unikatowych dla platformy Azure.
| Właściwości | Szczegóły |
|---|---|
apiVersion: string |
Określa wersję interfejsu API do użycia. |
azureADTokenProvider: (() => Promise<string>) |
Funkcja, która zwraca token dostępu dla firmy Microsoft Entra (wcześniej znanej jako Azure Active Directory), wywoływana na każdym żądaniu. |
Wdrażania: string |
Wdrożenie modelu. Jeśli zostanie podana, ustawia podstawowy adres URL klienta tak, aby zawierał /deployments/{deployment}wartość . Nie można używać punktów końcowych innych niż wdrożenie (nieobsługiwane w przypadku interfejsów API Asystentów). |
punkt końcowy: string |
Punkt końcowy usługi Azure OpenAI ma następujący format: https://RESOURCE-NAME.azure.openai.com/. |
import { createReadStream } from "fs";
const result = await client.audio.transcriptions.create({
model: '',
file: createReadStream(audioFilePath),
});
chat.completions.create
const result = await client.chat.completions.create({ messages, model: '', max_tokens: 100 });
const stream = await client.chat.completions.create({ model: '', messages, max_tokens: 100, stream: true });
const embeddings = await client.embeddings.create({ input, model: '' });
const results = await client.images.generate({ prompt, model: '', n, size });
| Kod stanu | Typ błędu |
|---|---|
| 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 |
Następujące błędy są domyślnie automatycznie wycofywały się dwukrotnie z krótkim wycofywaniem wykładniczym:
>=Błędy wewnętrzne 500Użyj maxRetries polecenia , aby ustawić/wyłączyć zachowanie ponawiania prób:
// 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,
});
Dokumentacja pakietu kodu | źródłowego biblioteki (PyPi) | |
Uwaga
Ta biblioteka jest utrzymywana przez interfejs OpenAI. Zapoznaj się z historią wydania, aby śledzić najnowsze aktualizacje biblioteki.
Dostępność funkcji w usłudze Azure OpenAI zależy od wersji docelowego interfejsu API REST. Najnowsze funkcje są przeznaczone dla najnowszego interfejsu API w wersji zapoznawczej.
| Najnowszy interfejs API ogólnie dostępnej wersji | Najnowszy interfejs API w wersji zapoznawczej |
|---|---|
2024-10-21 |
2025-01-01-preview |
pip install openai
Najnowsza wersja:
pip install openai --upgrade
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"
)
Aby uzyskać więcej informacji na temat uwierzytelniania bez klucza usługi Azure OpenAI, zobacz artykuł Szybki start "Rozpoczynanie pracy z blokiem konstrukcyjnym zabezpieczeń usługi Azure OpenAI".
Ta funkcja obecnie wymaga wersji zapoznawczej interfejsu API.
Ustaw api_version="2024-10-01-preview" wartość , aby użyć tej funkcji.
# 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)
# 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)
# 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)
# 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='',)
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))
# 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)
Dostrajanie za pomocą artykułu z instrukcjami dotyczącymi języka Python
Artykuł z instrukcjami dotyczącymi usługi Batch z językiem Python
# 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))
# 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))
# 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)
| Kod stanu | Typ błędu |
|---|---|
| 400 | BadRequestError |
| 401 | AuthenticationError |
| 403 | PermissionDeniedError |
| 404 | NotFoundError |
| 422 | UnprocessableEntityError |
| 429 | RateLimitError |
| >=500 | InternalServerError |
| Nie dotyczy | APIConnectionError |
Aby pobrać identyfikator żądania, możesz użyć _request_id właściwości odpowiadającej nagłówkowi x-request-id odpowiedzi.
print(completion._request_id)
print(legacy_completion._request_id)
Następujące błędy są domyślnie automatycznie wycofywały się dwukrotnie z krótkim wycofywaniem wykładniczym:
>=Błędy wewnętrzne 500Użyj max_retries polecenia , aby ustawić/wyłączyć zachowanie ponawiania prób:
# 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",
)
Zdarzenia
Tworzenie aplikacji i agentów sztucznej inteligencji
17 mar, 21 - 21 mar, 10
Dołącz do serii meetup, aby tworzyć skalowalne rozwiązania sztucznej inteligencji oparte na rzeczywistych przypadkach użycia z innymi deweloperami i ekspertami.
Zarejestruj się terazSzkolenie
Moduł
Dowiedz się, jak używać zestawu .NET SDK z usługą Azure OpenAI, aby aplikacje prowadziły rozmowy z użytkownikami w języku naturalnym.