Szybki start: rozpoczynanie pracy z generowaniem dźwięku usługi Azure OpenAI

2025-07-02

Modele gpt-4o-audio-preview i gpt-4o-mini-audio-preview wprowadzają modalność audio do istniejącego /chat/completions interfejsu API. Model audio rozszerza potencjał aplikacji sztucznej inteligencji w interakcjach tekstowych i głosowych oraz analizie audio. Modalności obsługiwane w modelach gpt-4o-audio-preview i gpt-4o-mini-audio-preview obejmują: tekst, dźwięk i tekst i dźwięk.

Oto tabela obsługiwanych modalności z przykładowymi przypadkami użycia:

Wejście modalne	Dane wyjściowe modalności	Przykładowy przypadek użycia
Tekst	Tekst i dźwięk	Zamiana tekstu na mowę, generowanie książki audio
Dźwięk	Tekst i dźwięk	Transkrypcja audio, generowanie książek audio
Dźwięk	Tekst	Transkrypcja audio
Tekst i dźwięk	Tekst i dźwięk	Generowanie książek audio
Tekst i dźwięk	Tekst	Transkrypcja audio

Dzięki możliwościom generowania dźwięku można osiągnąć bardziej dynamiczne i interaktywne aplikacje sztucznej inteligencji. Modele, które obsługują dane wejściowe i wyjściowe audio, umożliwiają generowanie mówionych odpowiedzi audio na zapytania oraz używanie danych wejściowych audio do monitowania modelu.

Obsługiwane modele

Obecnie tylko wersje gpt-4o-audio-preview i gpt-4o-mini-audio-preview: 2024-12-17 obsługują generowanie dźwięku.

Aby uzyskać więcej informacji na temat dostępności regionów, zobacz dokumentację modeli i wersji.

Obecnie następujące głosy są obsługiwane dla dźwięku wychodzącego: Alloy, Echo i Shimmer.

Maksymalny rozmiar pliku audio to 20 MB.

Uwaga / Notatka

Interfejs Realtime API używa tego samego podstawowego modelu audio GPT-4o co API uzupełnień, ale jest zoptymalizowany pod kątem interakcji audio w czasie rzeczywistym z małymi opóźnieniami.

Obsługa interfejsu API

Obsługa uzupełniania audio została po raz pierwszy dodana w wersji interfejsu API 2025-01-01-preview.

Wdrażanie modelu na potrzeby generowania dźwięku

Aby wdrożyć model gpt-4o-mini-audio-preview w portalu Azure AI Foundry:

Przejdź do portalu usługi Azure AI Foundry i utwórz lub wybierz projekt.
Wybierz pozycję Modele i punkty końcowe w obszarze Moje zasoby w okienku po lewej stronie.
Wybierz pozycję + Wdróż model>podstawowy, aby otworzyć okno wdrażania.
Wyszukaj i wybierz gpt-4o-mini-audio-preview model, a następnie wybierz pozycję Potwierdź.
Przejrzyj szczegóły wdrożenia i wybierz pozycję Wdróż.
Postępuj zgodnie z instrukcjami kreatora, aby zakończyć wdrażanie modelu.

Teraz, gdy masz wdrożenie gpt-4o-mini-audio-preview modelu, możesz wchodzić z nim w interakcję na portalu Azure AI Foundry w placu zabaw czatu Chat lub interfejsie API uzupełniania czatu.

Korzystanie z generowania dźwięku GPT-4o

Aby porozmawiać z wdrożonym gpt-4o-mini-audio-preview modelem w placu zabaw czatu portalu Azure AI Foundry, wykonaj następujące kroki:

Przejdź do portalu usługi Azure AI Foundry i wybierz projekt, który ma wdrożony gpt-4o-mini-audio-preview model.
Przejdź do projektu w usłudze Azure AI Foundry.
Wybierz pozycję Place zabaw w okienku po lewej stronie.
Wybierz Plac zabaw audio>Przetestuj plac zabaw czatu.

Uwaga / Notatka

Plac zabaw audio nie obsługuje gpt-4o-mini-audio-preview modelu. Skorzystaj z czatu w trybie zabawy zgodnie z opisem w tej sekcji.
Wybierz wdrożony gpt-4o-mini-audio-preview model z listy rozwijanej Wdrażanie .
Zacznij rozmawiać z modelem i słuchać odpowiedzi audio.

Masz następujące możliwości:
- Nagrywaj polecenia audio.
- Dołącz pliki audio do czatu.
- Wprowadź monity tekstowe.

Dokumentacja referencyjna | Kod źródłowy biblioteki | Pakiet (npm) | Przykłady

Oto tabela obsługiwanych modalności z przykładowymi przypadkami użycia:

Wejście modalne	Dane wyjściowe modalności	Przykładowy przypadek użycia
Tekst	Tekst i dźwięk	Zamiana tekstu na mowę, generowanie książki audio
Dźwięk	Tekst i dźwięk	Transkrypcja audio, generowanie książek audio
Dźwięk	Tekst	Transkrypcja audio
Tekst i dźwięk	Tekst i dźwięk	Generowanie książek audio
Tekst i dźwięk	Tekst	Transkrypcja audio

Obsługiwane modele

Obecnie tylko wersje gpt-4o-audio-preview i gpt-4o-mini-audio-preview: 2024-12-17 obsługują generowanie dźwięku.

Aby uzyskać więcej informacji na temat dostępności regionów, zobacz dokumentację modeli i wersji.

Obecnie następujące głosy są obsługiwane dla dźwięku wychodzącego: Alloy, Echo i Shimmer.

Maksymalny rozmiar pliku audio to 20 MB.

Uwaga / Notatka

Interfejs Realtime API używa tego samego podstawowego modelu audio GPT-4o co API uzupełnień, ale jest zoptymalizowany pod kątem interakcji audio w czasie rzeczywistym z małymi opóźnieniami.

Obsługa interfejsu API

Obsługa uzupełniania audio została po raz pierwszy dodana w wersji interfejsu API 2025-01-01-preview.

Wymagania wstępne

Subskrypcja platformy Azure - Utwórz ją za darmo
obsługa Node.js LTS lub ESM.
Zasób usługi Azure OpenAI utworzony w jednym z obsługiwanych regionów. Aby uzyskać więcej informacji na temat dostępności regionów, zobacz dokumentację modeli i wersji.
Następnie należy wdrożyć gpt-4o-mini-audio-preview model przy użyciu zasobu usługi Azure OpenAI. Aby uzyskać więcej informacji, zobacz Tworzenie zasobu i wdrażanie modelu za pomocą usługi Azure OpenAI.

Wymagania wstępne dotyczące Microsoft Entra ID

W przypadku zalecanego uwierzytelniania bez klucza za pomocą identyfikatora Entra firmy Microsoft należy wykonać następujące czynności:

Zainstaluj Azure CLI używane do uwierzytelniania bezkluczowego za pomocą Microsoft Entra ID.
Cognitive Services User Przypisz rolę do konta użytkownika. Role można przypisać w portalu Azure w sekcji Kontrola dostępu (IAM)>Dodawanie przypisania roli.

Ustawienia

Utwórz nowy folder audio-completions-quickstart i przejdź do folderu Szybki start za pomocą następującego polecenia:
```
mkdir audio-completions-quickstart && cd audio-completions-quickstart
```
Utwórz element package.json za pomocą następującego polecenia:
```
npm init -y
```
Zainstaluj bibliotekę klienta openAI dla języka JavaScript za pomocą następujących narzędzi:
```
npm install openai
```
Aby uzyskać zalecane uwierzytelnianie bez klucza za pomocą identyfikatora Entra firmy Microsoft, zainstaluj pakiet za @azure/identity pomocą polecenia:
```
npm install @azure/identity
```

Pobieranie informacji o zasobie

Aby uwierzytelnić aplikację przy użyciu zasobu usługi Azure OpenAI, musisz pobrać następujące informacje:

Microsoft Entra ID
Klucz interfejsu API

Nazwa zmiennej	Wartość
`AZURE_OPENAI_ENDPOINT`	Tę wartość można znaleźć w sekcji Klucze i punkt końcowy podczas badania zasobu w witrynie Azure Portal.
`AZURE_OPENAI_DEPLOYMENT_NAME`	Ta wartość będzie odpowiadać nazwie niestandardowej, którą wybrałeś dla swojego wdrożenia podczas wdrażania modelu. Tę wartość można znaleźć w obszarze Wdrożenia modelu zarządzania>zasobami w witrynie Azure Portal.
`OPENAI_API_VERSION`	Dowiedz się więcej o wersjach interfejsu API. Możesz zmienić wersję w kodzie lub użyć zmiennej środowiskowej.

Dowiedz się więcej na temat uwierzytelniania bez klucza i ustawiania zmiennych środowiskowych.

Nazwa zmiennej	Wartość
`AZURE_OPENAI_ENDPOINT`	Tę wartość można znaleźć w sekcji Klucze i punkt końcowy podczas badania zasobu w witrynie Azure Portal.
`AZURE_OPENAI_API_KEY`	Tę wartość można znaleźć w sekcji Klucze i punkt końcowy podczas badania zasobu w witrynie Azure Portal. Możesz użyć wartości `KEY1` lub `KEY2`.
`AZURE_OPENAI_DEPLOYMENT_NAME`	Ta wartość będzie odpowiadać nazwie niestandardowej, którą wybrałeś dla swojego wdrożenia podczas wdrażania modelu. Tę wartość można znaleźć w obszarze Wdrożenia modelu zarządzania>zasobami w witrynie Azure Portal.
`OPENAI_API_VERSION`	Dowiedz się więcej o wersjach interfejsu API.

Dowiedz się więcej na temat znajdowania kluczy interfejsu API i ustawiania zmiennych środowiskowych.

Ważne

Używaj kluczy interfejsu API z ostrożnością. Nie dołączaj klucza interfejsu API bezpośrednio do kodu i nigdy nie publikuj go publicznie. Jeśli używasz klucza interfejsu API, zapisz go bezpiecznie w usłudze Azure Key Vault. Aby uzyskać więcej informacji na temat bezpiecznego używania kluczy interfejsu API w aplikacjach, zobacz Klucze interfejsu API w usłudze Azure Key Vault.

Aby uzyskać więcej informacji na temat zabezpieczeń usług sztucznej inteligencji, zobacz Uwierzytelnianie żądań w usługach Azure AI.

Ostrzeżenie

Aby użyć zalecanego uwierzytelniania bez klucza z zestawem SDK, upewnij się, że zmienna AZURE_OPENAI_API_KEY środowiskowa nie jest ustawiona.

Generowanie dźwięku na podstawie wprowadzania tekstu

Microsoft Entra ID
Klucz interfejsu API

to-audio.js Utwórz plik przy użyciu następującego kodu:

require("dotenv").config();
const { AzureOpenAI } = require("openai");
const { DefaultAzureCredential, getBearerTokenProvider } = require("@azure/identity");
const { writeFileSync } = require("node:fs");

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

// Set environment variables or edit the corresponding values here.
const endpoint = process.env.AZURE_OPENAI_ENDPOINT || "AZURE_OPENAI_ENDPOINT";
const deployment = process.env.AZURE_OPENAI_DEPLOYMENT_NAME || "gpt-4o-mini-audio-preview"; 
const apiVersion = process.env.OPENAI_API_VERSION || "2025-01-01-preview"; 

const client = new AzureOpenAI({ 
    endpoint, 
    azureADTokenProvider, 
    apiVersion, 
    deployment 
}); 

async function main() {

    // Make the audio chat completions request
    const response = await client.chat.completions.create({ 
        model: "gpt-4o-mini-audio-preview", 
        modalities: ["text", "audio"], 
        audio: { voice: "alloy", format: "wav" }, 
        messages: [ 
        { 
            role: "user", 
            content: "Is a golden retriever a good family dog?" 
        } 
        ] 
    }); 

// Inspect returned data 
console.log(response.choices[0]); 

// Write the output audio data to a file
writeFileSync( 
    "dog.wav", 
    Buffer.from(response.choices[0].message.audio.data, 'base64'), 
    { encoding: "utf-8" } 
); 
}

main().catch((err) => {
  console.error("Error occurred:", err);
});

module.exports = { main };

Zaloguj się do platformy Azure przy użyciu następującego polecenia:
```
az login
```
Uruchom plik JavaScript.
```
node to-audio.js
```

to-audio.js Utwórz plik przy użyciu następującego kodu:

require("dotenv").config();
const { AzureOpenAI } = require("openai");
const { writeFileSync } = require("node:fs");

// Set environment variables or edit the corresponding values here.
const endpoint = process.env.AZURE_OPENAI_ENDPOINT || "AZURE_OPENAI_ENDPOINT";
const apiKey = process.env.AZURE_OPENAI_API_KEY || "AZURE_OPENAI_API_KEY";
const apiVersion = "2025-01-01-preview"; 
const deployment = "gpt-4o-mini-audio-preview"; 

const client = new AzureOpenAI({ 
    endpoint, 
    apiKey, 
    apiVersion, 
    deployment 
});  

async function main() {

    // Make the audio chat completions request
    const response = await client.chat.completions.create({ 
        model: "gpt-4o-mini-audio-preview", 
        modalities: ["text", "audio"], 
        audio: { voice: "alloy", format: "wav" }, 
        messages: [ 
        { 
            role: "user", 
            content: "Is a golden retriever a good family dog?" 
        } 
        ] 
    }); 

// Inspect returned data 
console.log(response.choices[0]); 

// Write the output audio data to a file
writeFileSync( 
    "dog.wav", 
    Buffer.from(response.choices[0].message.audio.data, 'base64'), 
    { encoding: "utf-8" } 
); 
}

main().catch((err) => {
  console.error("Error occurred:", err);
});

module.exports = { main };

Uruchom plik JavaScript.
```
node to-audio.js
```

Poczekaj chwilę, aby uzyskać odpowiedź.

Dane wyjściowe generowania dźwięku z wprowadzania tekstu

Skrypt generuje plik audio o nazwie dog.wav w tym samym katalogu co skrypt. Plik dźwiękowy zawiera szczerą odpowiedź na monit: "Czy złoty retriever jest dobrym psem rodzinnym?"

Generowanie dźwięku i tekstu na podstawie danych wejściowych audio

Microsoft Entra ID
Klucz interfejsu API

from-audio.js Utwórz plik przy użyciu następującego kodu:

require("dotenv").config();
const { AzureOpenAI } = require("openai");
const { DefaultAzureCredential, getBearerTokenProvider } = require("@azure/identity");
const fs = require('fs').promises;
const { writeFileSync } = require("node:fs");

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

// Set environment variables or edit the corresponding values here.
const endpoint = process.env.AZURE_OPENAI_ENDPOINT || "AZURE_OPENAI_ENDPOINT";
const apiVersion = "2025-01-01-preview"; 
const deployment = "gpt-4o-mini-audio-preview"; 

const client = new AzureOpenAI({ 
    endpoint, 
    azureADTokenProvider, 
    apiVersion, 
    deployment 
});    

async function main() {

    // Buffer the audio for input to the chat completion
    const wavBuffer = await fs.readFile("dog.wav"); 
    const base64str = Buffer.from(wavBuffer).toString("base64"); 

    // Make the audio chat completions request
    const response = await client.chat.completions.create({
        model: "gpt-4o-mini-audio-preview",
        modalities: ["text", "audio"],
        audio: { voice: "alloy", format: "wav" }, 
        messages: [
            {
                role: "user",
                content: [
                    { 
                        type: "text", 
                        text: "Describe in detail the spoken audio input." 
                    },
                    { 
                        type: "input_audio", 
                        input_audio: { 
                            data: base64str, 
                            format: "wav" 
                        } 
                    }
                ]
            }
        ]
    });

    console.log(response.choices[0]); 

    // Write the output audio data to a file
    writeFileSync( 
        "analysis.wav", 
        Buffer.from(response.choices[0].message.audio.data, 'base64'), 
        { encoding: "utf-8" } 
    ); 
}

main().catch((err) => {
    console.error("Error occurred:", err);
});

module.exports = { main };

Zaloguj się do platformy Azure przy użyciu następującego polecenia:
```
az login
```
Uruchom plik JavaScript.
```
node from-audio.js
```

from-audio.js Utwórz plik przy użyciu następującego kodu:

require("dotenv").config();
const { AzureOpenAI } = require("openai");
const fs = require('fs').promises;
const { writeFileSync } = require("node:fs");

// Set environment variables or edit the corresponding values here.
const endpoint = process.env.AZURE_OPENAI_ENDPOINT || "AZURE_OPENAI_ENDPOINT";
const apiKey = process.env.AZURE_OPENAI_API_KEY || "AZURE_OPENAI_API_KEY";
const apiVersion = "2025-01-01-preview"; 
const deployment = "gpt-4o-mini-audio-preview"; 

const client = new AzureOpenAI({ 
    endpoint, 
    apiKey, 
    apiVersion, 
    deployment 
});  

async function main() {

    // Buffer the audio for input to the chat completion
    const wavBuffer = await fs.readFile("dog.wav"); 
    const base64str = Buffer.from(wavBuffer).toString("base64"); 

    // Make the audio chat completions request
    const response = await client.chat.completions.create({
        model: "gpt-4o-mini-audio-preview",
        modalities: ["text", "audio"],
        audio: { voice: "alloy", format: "wav" }, 
        messages: [
            {
                role: "user",
                content: [
                    { 
                        type: "text", 
                        text: "Describe in detail the spoken audio input." 
                    },
                    { 
                        type: "input_audio", 
                        input_audio: { 
                            data: base64str, 
                            format: "wav" 
                        } 
                    }
                ]
            }
        ]
    });

    console.log(response.choices[0]); 

    // Write the output audio data to a file
    writeFileSync( 
        "analysis.wav", 
        Buffer.from(response.choices[0].message.audio.data, 'base64'), 
        { encoding: "utf-8" } 
    ); 
}

main().catch((err) => {
    console.error("Error occurred:", err);
});

module.exports = { main };

Uruchom plik JavaScript.
```
node from-audio.js
```

Poczekaj chwilę, aby uzyskać odpowiedź.

Wynik generowania dźwięku i tekstu z wejściowego sygnału audio

Skrypt generuje transkrypcję podsumowania danych wejściowych dźwięku mówionego. Generuje również plik audio o nazwie analysis.wav w tym samym katalogu co skrypt. Plik dźwiękowy zawiera wypowiedzianą odpowiedź na monit.

Generowanie dźwięku i używanie uzupełniania czatu wielowrackowego

Microsoft Entra ID
Klucz interfejsu API

multi-turn.js Utwórz plik przy użyciu następującego kodu:

require("dotenv").config();
const { AzureOpenAI } = require("openai");
const { DefaultAzureCredential, getBearerTokenProvider } = require("@azure/identity");
const fs = require('fs').promises;

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

// Set environment variables or edit the corresponding values here.
const endpoint = process.env.AZURE_OPENAI_ENDPOINT || "AZURE_OPENAI_ENDPOINT";
const apiVersion = "2025-01-01-preview"; 
const deployment = "gpt-4o-mini-audio-preview"; 

const client = new AzureOpenAI({ 
    endpoint, 
    azureADTokenProvider, 
    apiVersion, 
    deployment 
}); 

async function main() {

    // Buffer the audio for input to the chat completion
    const wavBuffer = await fs.readFile("dog.wav"); 
    const base64str = Buffer.from(wavBuffer).toString("base64"); 

    // Initialize messages with the first turn's user input 
    const messages = [
        {
            role: "user",
            content: [
                { 
                    type: "text", 
                    text: "Describe in detail the spoken audio input." 
                },
                { 
                    type: "input_audio", 
                    input_audio: { 
                        data: base64str, 
                        format: "wav" 
                    } 
                }
            ]
        }
    ];

    // Get the first turn's response 

    const response = await client.chat.completions.create({ 
        model: "gpt-4o-mini-audio-preview",
        modalities: ["text", "audio"], 
        audio: { voice: "alloy", format: "wav" }, 
        messages: messages
    }); 

    console.log(response.choices[0]); 

    // Add a history message referencing the previous turn's audio by ID 
    messages.push({ 
        role: "assistant", 
        audio: { id: response.choices[0].message.audio.id }
    });

    // Add a new user message for the second turn
    messages.push({ 
        role: "user", 
        content: [ 
            { 
                type: "text", 
                text: "Very concisely summarize the favorability." 
            } 
        ] 
    }); 

    // Send the follow-up request with the accumulated messages
    const followResponse = await client.chat.completions.create({ 
        model: "gpt-4o-mini-audio-preview",
        messages: messages
    });

    console.log(followResponse.choices[0].message.content); 
}

main().catch((err) => {
    console.error("Error occurred:", err);
});

module.exports = { main };

Zaloguj się do platformy Azure przy użyciu następującego polecenia:
```
az login
```
Uruchom plik JavaScript.
```
node multi-turn.js
```

multi-turn.js Utwórz plik przy użyciu następującego kodu:

require("dotenv").config();
const { AzureOpenAI } = require("openai");
const fs = require('fs').promises;

// Set environment variables or edit the corresponding values here.
const endpoint = process.env.AZURE_OPENAI_ENDPOINT || "AZURE_OPENAI_ENDPOINT";
const apiKey = process.env.AZURE_OPENAI_API_KEY || "AZURE_OPENAI_API_KEY";
const apiVersion = "2025-01-01-preview"; 
const deployment = "gpt-4o-mini-audio-preview"; 

const client = new AzureOpenAI({ 
    endpoint, 
    apiKey, 
    apiVersion, 
    deployment 
});  

async function main() {

    // Buffer the audio for input to the chat completion
    const wavBuffer = await fs.readFile("dog.wav"); 
    const base64str = Buffer.from(wavBuffer).toString("base64"); 

    // Initialize messages with the first turn's user input 
    const messages = [
        {
            role: "user",
            content: [
                { 
                    type: "text", 
                    text: "Describe in detail the spoken audio input." 
                },
                { 
                    type: "input_audio", 
                    input_audio: { 
                        data: base64str, 
                        format: "wav" 
                    } 
                }
            ]
        }
    ];

    // Get the first turn's response 

    const response = await client.chat.completions.create({ 
        model: "gpt-4o-mini-audio-preview",
        modalities: ["text", "audio"], 
        audio: { voice: "alloy", format: "wav" }, 
        messages: messages
    }); 

    console.log(response.choices[0]); 

    // Add a history message referencing the previous turn's audio by ID 
    messages.push({ 
        role: "assistant", 
        audio: { id: response.choices[0].message.audio.id }
    });

    // Add a new user message for the second turn
    messages.push({ 
        role: "user", 
        content: [ 
            { 
                type: "text", 
                text: "Very concisely summarize the favorability." 
            } 
        ] 
    }); 

    // Send the follow-up request with the accumulated messages
    const followResponse = await client.chat.completions.create({ 
        model: "gpt-4o-mini-audio-preview",
        messages: messages
    });

    console.log(followResponse.choices[0].message.content); 
}

main().catch((err) => {
    console.error("Error occurred:", err);
});

module.exports = { main };

Uruchom plik JavaScript.
```
node multi-turn.js
```

Poczekaj chwilę, aby uzyskać odpowiedź.

Dane wyjściowe dla uzupełniania czatu wielowrackowego

Skrypt generuje transkrypcję podsumowania danych wejściowych dźwięku mówionego. Następnie wykonuje rozmowę z wieloma wymianami w celu krótkiego podsumowania wypowiedzi audio.

Kod źródłowy biblioteki | Pakiet | Przykłady

Oto tabela obsługiwanych modalności z przykładowymi przypadkami użycia:

Wejście modalne	Dane wyjściowe modalności	Przykładowy przypadek użycia
Tekst	Tekst i dźwięk	Zamiana tekstu na mowę, generowanie książki audio
Dźwięk	Tekst i dźwięk	Transkrypcja audio, generowanie książek audio
Dźwięk	Tekst	Transkrypcja audio
Tekst i dźwięk	Tekst i dźwięk	Generowanie książek audio
Tekst i dźwięk	Tekst	Transkrypcja audio

Obsługiwane modele

Obecnie tylko wersje gpt-4o-audio-preview i gpt-4o-mini-audio-preview: 2024-12-17 obsługują generowanie dźwięku.

Aby uzyskać więcej informacji na temat dostępności regionów, zobacz dokumentację modeli i wersji.

Obecnie następujące głosy są obsługiwane dla dźwięku wychodzącego: Alloy, Echo i Shimmer.

Maksymalny rozmiar pliku audio to 20 MB.

Uwaga / Notatka

Interfejs Realtime API używa tego samego podstawowego modelu audio GPT-4o co API uzupełnień, ale jest zoptymalizowany pod kątem interakcji audio w czasie rzeczywistym z małymi opóźnieniami.

Obsługa interfejsu API

Obsługa uzupełniania audio została po raz pierwszy dodana w wersji interfejsu API 2025-01-01-preview.

Skorzystaj z tego przewodnika, aby rozpocząć generowanie dźwięku za pomocą zestawu Azure OpenAI SDK dla języka Python.

Wymagania wstępne

Subskrypcja platformy Azure. Utwórz je bezpłatnie.
Python 3.8 lub nowszy. Zalecamy używanie języka Python w wersji 3.10 lub nowszej, ale wymagana jest co najmniej wersja python 3.8. Jeśli nie masz zainstalowanej odpowiedniej wersji języka Python, możesz postępować zgodnie z instrukcjami w samouczku języka Python programu VS Code, aby uzyskać najprostszy sposób instalowania języka Python w systemie operacyjnym.
Zasób usługi Azure OpenAI utworzony w jednym z obsługiwanych regionów. Aby uzyskać więcej informacji na temat dostępności regionów, zobacz dokumentację modeli i wersji.
Następnie należy wdrożyć gpt-4o-mini-audio-preview model przy użyciu zasobu usługi Azure OpenAI. Aby uzyskać więcej informacji, zobacz Tworzenie zasobu i wdrażanie modelu za pomocą usługi Azure OpenAI.

Wymagania wstępne dotyczące Microsoft Entra ID

W przypadku zalecanego uwierzytelniania bez klucza za pomocą identyfikatora Entra firmy Microsoft należy wykonać następujące czynności:

Zainstaluj Azure CLI używane do uwierzytelniania bezkluczowego za pomocą Microsoft Entra ID.
Cognitive Services User Przypisz rolę do konta użytkownika. Role można przypisać w portalu Azure w sekcji Kontrola dostępu (IAM)>Dodawanie przypisania roli.

Ustawienia

Utwórz nowy folder audio-completions-quickstart i przejdź do folderu Szybki start za pomocą następującego polecenia:
```
mkdir audio-completions-quickstart && cd audio-completions-quickstart
```
Tworzenie środowiska wirtualnego. Jeśli masz już zainstalowany język Python w wersji 3.10 lub nowszej, możesz utworzyć środowisko wirtualne przy użyciu następujących poleceń:
- Windows
- Linux
- macOS
```
py -3 -m venv .venv
.venv\scripts\activate
```
```
python3 -m venv .venv
source .venv/bin/activate
```
```
python3 -m venv .venv
source .venv/bin/activate
```
Aktywowanie środowiska języka Python oznacza, że po uruchomieniu python lub pip w wierszu polecenia używasz interpretera języka Python zawartego w folderze .venv aplikacji. Możesz użyć deactivate polecenia , aby zamknąć środowisko wirtualne języka Python i później ponownie aktywować je w razie potrzeby.

Wskazówka

Zalecamy utworzenie i aktywowanie nowego środowiska języka Python w celu zainstalowania pakietów potrzebnych na potrzeby tego samouczka. Nie instaluj pakietów w globalnej instalacji języka Python. Zawsze należy używać środowiska wirtualnego lub conda podczas instalowania pakietów języka Python. W przeciwnym razie możesz przerwać globalną instalację języka Python.
Zainstaluj bibliotekę klienta OpenAI dla języka Python za pomocą następujących elementów:
```
pip install openai
```
Aby uzyskać zalecane uwierzytelnianie bez klucza za pomocą identyfikatora Entra firmy Microsoft, zainstaluj pakiet za azure-identity pomocą polecenia:
```
pip install azure-identity
```

Pobieranie informacji o zasobie

Aby uwierzytelnić aplikację przy użyciu zasobu usługi Azure OpenAI, musisz pobrać następujące informacje:

Microsoft Entra ID
Klucz interfejsu API

Nazwa zmiennej	Wartość
`AZURE_OPENAI_ENDPOINT`	Tę wartość można znaleźć w sekcji Klucze i punkt końcowy podczas badania zasobu w witrynie Azure Portal.
`AZURE_OPENAI_DEPLOYMENT_NAME`	Ta wartość będzie odpowiadać nazwie niestandardowej, którą wybrałeś dla swojego wdrożenia podczas wdrażania modelu. Tę wartość można znaleźć w obszarze Wdrożenia modelu zarządzania>zasobami w witrynie Azure Portal.
`OPENAI_API_VERSION`	Dowiedz się więcej o wersjach interfejsu API. Możesz zmienić wersję w kodzie lub użyć zmiennej środowiskowej.

Dowiedz się więcej na temat uwierzytelniania bez klucza i ustawiania zmiennych środowiskowych.

Nazwa zmiennej	Wartość
`AZURE_OPENAI_ENDPOINT`	Tę wartość można znaleźć w sekcji Klucze i punkt końcowy podczas badania zasobu w witrynie Azure Portal.
`AZURE_OPENAI_API_KEY`	Tę wartość można znaleźć w sekcji Klucze i punkt końcowy podczas badania zasobu w witrynie Azure Portal. Możesz użyć wartości `KEY1` lub `KEY2`.
`AZURE_OPENAI_DEPLOYMENT_NAME`	Ta wartość będzie odpowiadać nazwie niestandardowej, którą wybrałeś dla swojego wdrożenia podczas wdrażania modelu. Tę wartość można znaleźć w obszarze Wdrożenia modelu zarządzania>zasobami w witrynie Azure Portal.
`OPENAI_API_VERSION`	Dowiedz się więcej o wersjach interfejsu API.

Dowiedz się więcej na temat znajdowania kluczy interfejsu API i ustawiania zmiennych środowiskowych.

Ważne

Aby uzyskać więcej informacji na temat zabezpieczeń usług sztucznej inteligencji, zobacz Uwierzytelnianie żądań w usługach Azure AI.

Generowanie dźwięku na podstawie wprowadzania tekstu

Microsoft Entra ID
Klucz interfejsu API

to-audio.py Utwórz plik przy użyciu następującego kodu:

import requests
import base64 
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")

# Set environment variables or edit the corresponding values here.
endpoint = os.environ['AZURE_OPENAI_ENDPOINT']

# Keyless authentication
client=AzureOpenAI(
    azure_ad_token_provider=token_provider,
    azure_endpoint=endpoint,
    api_version="2025-01-01-preview"
)

# Make the audio chat completions request
completion=client.chat.completions.create(
    model="gpt-4o-mini-audio-preview",
    modalities=["text", "audio"],
    audio={"voice": "alloy", "format": "wav"},
    messages=[
        {
            "role": "user",
            "content": "Is a golden retriever a good family dog?"
        }
    ]
)

print(completion.choices[0])

# Write the output audio data to a file
wav_bytes=base64.b64decode(completion.choices[0].message.audio.data)
with open("dog.wav", "wb") as f:
    f.write(wav_bytes)

Uruchom plik języka Python.
```
python to-audio.py
```

to-audio.py Utwórz plik przy użyciu następującego kodu:

import base64 
import os 
from openai import AzureOpenAI 

# Set environment variables or edit the corresponding values here.
endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
api_key = os.environ['AZURE_OPENAI_API_KEY']

client = AzureOpenAI(
    api_version="2025-01-01-preview",  
    api_key=api_key,
    azure_endpoint=endpoint
)

# Make the audio chat completions request
completion = client.chat.completions.create(
    model="gpt-4o-mini-audio-preview",
    modalities=["text", "audio"],
    audio={"voice": "alloy", "format": "wav"},
    messages=[
        {
            "role": "user",
            "content": "Is a golden retriever a good family dog?"
        }
    ]
)

print(completion.choices[0])

# Write the output audio data to a file
wav_bytes = base64.b64decode(completion.choices[0].message.audio.data)
with open("dog.wav", "wb") as f:
    f.write(wav_bytes)

Uruchom plik języka Python.
```
python to-audio.py
```

Poczekaj chwilę, aby uzyskać odpowiedź.

Dane wyjściowe generowania dźwięku z wprowadzania tekstu

Skrypt generuje plik audio o nazwie dog.wav w tym samym katalogu co skrypt. Plik dźwiękowy zawiera szczerą odpowiedź na monit: "Czy złoty retriever jest dobrym psem rodzinnym?"

Generowanie dźwięku i tekstu na podstawie danych wejściowych audio

Microsoft Entra ID
Klucz interfejsu API

from-audio.py Utwórz plik przy użyciu następującego kodu:

import base64
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")

# Set environment variables or edit the corresponding values here.
endpoint = os.environ['AZURE_OPENAI_ENDPOINT']

# Keyless authentication
client=AzureOpenAI(
    azure_ad_token_provider=token_provider,
    azure_endpoint=endpoint,
    api_version="2025-01-01-preview"
)

# Read and encode audio file  
with open('dog.wav', 'rb') as wav_reader: 
    encoded_string = base64.b64encode(wav_reader.read()).decode('utf-8') 

# Make the audio chat completions request
completion = client.chat.completions.create( 
    model="gpt-4o-mini-audio-preview", 
    modalities=["text", "audio"], 
    audio={"voice": "alloy", "format": "wav"}, 
    messages=[ 
        { 
            "role": "user", 
            "content": [ 
                {  
                    "type": "text", 
                    "text": "Describe in detail the spoken audio input." 
                }, 
                { 
                    "type": "input_audio", 
                    "input_audio": { 
                        "data": encoded_string, 
                        "format": "wav" 
                    } 
                } 
            ] 
        }, 
    ] 
) 

print(completion.choices[0].message.audio.transcript)

# Write the output audio data to a file
wav_bytes = base64.b64decode(completion.choices[0].message.audio.data)
with open("analysis.wav", "wb") as f:
    f.write(wav_bytes)

Uruchom plik języka Python.
```
python from-audio.py
```

from-audio.py Utwórz plik przy użyciu następującego kodu:

import base64
import os
from openai import AzureOpenAI

# Set environment variables or edit the corresponding values here.
endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
api_key = os.environ['AZURE_OPENAI_API_KEY']

client = AzureOpenAI(
    api_version="2025-01-01-preview",  
    api_key=api_key, 
    azure_endpoint=endpoint,
)

# Read and encode audio file  
with open('dog.wav', 'rb') as wav_reader: 
    encoded_string = base64.b64encode(wav_reader.read()).decode('utf-8') 

# Make the audio chat completions request
completion = client.chat.completions.create( 
    model="gpt-4o-mini-audio-preview", 
    modalities=["text", "audio"], 
    audio={"voice": "alloy", "format": "wav"}, 
    messages=[ 
        { 
            "role": "user", 
            "content": [ 
                {  
                    "type": "text", 
                    "text": "Describe in detail the spoken audio input." 
                }, 
                { 
                    "type": "input_audio", 
                    "input_audio": { 
                        "data": encoded_string, 
                        "format": "wav" 
                    } 
                } 
            ] 
        }, 
    ] 
) 

print(completion.choices[0].message.audio.transcript)

# Write the output audio data to a file
wav_bytes = base64.b64decode(completion.choices[0].message.audio.data)
with open("analysis.wav", "wb") as f:
    f.write(wav_bytes)

Uruchom plik języka Python.
```
python from-audio.py
```

Poczekaj chwilę, aby uzyskać odpowiedź.

Wynik generowania dźwięku i tekstu z wejściowego sygnału audio

Generowanie dźwięku i używanie uzupełniania czatu wielowrackowego

Microsoft Entra ID
Klucz interfejsu API

multi-turn.py Utwórz plik przy użyciu następującego kodu:

import base64 
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")

# Set environment variables or edit the corresponding values here.
endpoint = os.environ['AZURE_OPENAI_ENDPOINT']

# Keyless authentication
client=AzureOpenAI(
    azure_ad_token_provider=token_provider,
    azure_endpoint=endpoint,
    api_version="2025-01-01-preview"
)

# Read and encode audio file  
with open('dog.wav', 'rb') as wav_reader: 
    encoded_string = base64.b64encode(wav_reader.read()).decode('utf-8') 

# Initialize messages with the first turn's user input 
messages = [
    { 
        "role": "user", 
        "content": [ 
            { "type": "text", "text": "Describe in detail the spoken audio input." }, 
            { "type": "input_audio", 
                "input_audio": { 
                    "data": encoded_string, 
                    "format": "wav" 
                } 
            } 
        ] 
    }] 

# Get the first turn's response

completion = client.chat.completions.create( 
    model="gpt-4o-mini-audio-preview", 
    modalities=["text", "audio"], 
    audio={"voice": "alloy", "format": "wav"}, 
    messages=messages
) 

print("Get the first turn's response:")
print(completion.choices[0].message.audio.transcript) 

print("Add a history message referencing the first turn's audio by ID:")
print(completion.choices[0].message.audio.id)

# Add a history message referencing the first turn's audio by ID 
messages.append({ 
    "role": "assistant", 
    "audio": { "id": completion.choices[0].message.audio.id } 
}) 

# Add the next turn's user message 
messages.append({ 
    "role": "user", 
    "content": "Very briefly, summarize the favorability." 
}) 

# Send the follow-up request with the accumulated messages
completion = client.chat.completions.create( 
    model="gpt-4o-mini-audio-preview", 
    messages=messages
) 

print("Very briefly, summarize the favorability.")
print(completion.choices[0].message.content)

Uruchom plik języka Python.
```
python multi-turn.py
```

multi-turn.py Utwórz plik przy użyciu następującego kodu:

import base64 
import os 
from openai import AzureOpenAI 

# Set environment variables or edit the corresponding values here.
endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
api_key = os.environ['AZURE_OPENAI_API_KEY']

client = AzureOpenAI(
    api_version="2025-01-01-preview",  
    api_key=api_key, 
    azure_endpoint=endpoint
)

# Read and encode audio file  
with open('dog.wav', 'rb') as wav_reader: 
    encoded_string = base64.b64encode(wav_reader.read()).decode('utf-8') 

# Initialize messages with the first turn's user input 
messages = [
    { 
        "role": "user", 
        "content": [ 
            { "type": "text", "text": "Describe in detail the spoken audio input." }, 
            { "type": "input_audio", 
                "input_audio": { 
                    "data": encoded_string, 
                    "format": "wav" 
                } 
            } 
        ] 
    }] 

# Get the first turn's response 

completion = client.chat.completions.create( 
    model="gpt-4o-mini-audio-preview", 
    modalities=["text", "audio"], 
    audio={"voice": "alloy", "format": "wav"}, 
    messages=messages
) 

print("Get the first turn's response:")
print(completion.choices[0].message.audio.transcript) 

print("Add a history message referencing the first turn's audio by ID:")
print(completion.choices[0].message.audio.id)

# Add a history message referencing the first turn's audio by ID 
messages.append({ 
    "role": "assistant", 
    "audio": { "id": completion.choices[0].message.audio.id } 
}) 

# Add the next turn's user message 
messages.append({ 
    "role": "user", 
    "content": "Very briefly, summarize the favorability." 
}) 

# Send the follow-up request with the accumulated messages 
completion = client.chat.completions.create( 
    model="gpt-4o-mini-audio-preview", 
    messages=messages
) 

print("Very briefly, summarize the favorability.")
print(completion.choices[0].message.content)

Uruchom plik języka Python.
```
python multi-turn.py
```

Poczekaj chwilę, aby uzyskać odpowiedź.

Dane wyjściowe dla uzupełniania czatu wielowrackowego

Skrypt generuje transkrypcję podsumowania danych wejściowych dźwięku mówionego. Następnie wykonuje rozmowę z wieloma wymianami w celu krótkiego podsumowania wypowiedzi audio.

Specyfikacje interfejsu API REST |

Oto tabela obsługiwanych modalności z przykładowymi przypadkami użycia:

Wejście modalne	Dane wyjściowe modalności	Przykładowy przypadek użycia
Tekst	Tekst i dźwięk	Zamiana tekstu na mowę, generowanie książki audio
Dźwięk	Tekst i dźwięk	Transkrypcja audio, generowanie książek audio
Dźwięk	Tekst	Transkrypcja audio
Tekst i dźwięk	Tekst i dźwięk	Generowanie książek audio
Tekst i dźwięk	Tekst	Transkrypcja audio

Obsługiwane modele

Obecnie tylko wersje gpt-4o-audio-preview i gpt-4o-mini-audio-preview: 2024-12-17 obsługują generowanie dźwięku.

Aby uzyskać więcej informacji na temat dostępności regionów, zobacz dokumentację modeli i wersji.

Obecnie następujące głosy są obsługiwane dla dźwięku wychodzącego: Alloy, Echo i Shimmer.

Maksymalny rozmiar pliku audio to 20 MB.

Uwaga / Notatka

Interfejs Realtime API używa tego samego podstawowego modelu audio GPT-4o co API uzupełnień, ale jest zoptymalizowany pod kątem interakcji audio w czasie rzeczywistym z małymi opóźnieniami.

Obsługa interfejsu API

Obsługa uzupełniania audio została po raz pierwszy dodana w wersji interfejsu API 2025-01-01-preview.

Wymagania wstępne

Subskrypcja platformy Azure. Utwórz je bezpłatnie.
Python 3.8 lub nowszy. Zalecamy używanie języka Python w wersji 3.10 lub nowszej, ale wymagana jest co najmniej wersja python 3.8. Jeśli nie masz zainstalowanej odpowiedniej wersji języka Python, możesz postępować zgodnie z instrukcjami w samouczku języka Python programu VS Code, aby uzyskać najprostszy sposób instalowania języka Python w systemie operacyjnym.
Zasób usługi Azure OpenAI utworzony w jednym z obsługiwanych regionów. Aby uzyskać więcej informacji na temat dostępności regionów, zobacz dokumentację modeli i wersji.
Następnie należy wdrożyć gpt-4o-mini-audio-preview model przy użyciu zasobu usługi Azure OpenAI. Aby uzyskać więcej informacji, zobacz Tworzenie zasobu i wdrażanie modelu za pomocą usługi Azure OpenAI.

Wymagania wstępne dotyczące Microsoft Entra ID

W przypadku zalecanego uwierzytelniania bez klucza za pomocą identyfikatora Entra firmy Microsoft należy wykonać następujące czynności:

Zainstaluj Azure CLI używane do uwierzytelniania bezkluczowego za pomocą Microsoft Entra ID.
Cognitive Services User Przypisz rolę do konta użytkownika. Role można przypisać w portalu Azure w sekcji Kontrola dostępu (IAM)>Dodawanie przypisania roli.

Ustawienia

Utwórz nowy folder audio-completions-quickstart i przejdź do folderu Szybki start za pomocą następującego polecenia:
```
mkdir audio-completions-quickstart && cd audio-completions-quickstart
```
Tworzenie środowiska wirtualnego. Jeśli masz już zainstalowany język Python w wersji 3.10 lub nowszej, możesz utworzyć środowisko wirtualne przy użyciu następujących poleceń:
- Windows
- Linux
- macOS
```
py -3 -m venv .venv
.venv\scripts\activate
```
```
python3 -m venv .venv
source .venv/bin/activate
```
```
python3 -m venv .venv
source .venv/bin/activate
```
Aktywowanie środowiska języka Python oznacza, że po uruchomieniu python lub pip w wierszu polecenia używasz interpretera języka Python zawartego w folderze .venv aplikacji. Możesz użyć deactivate polecenia , aby zamknąć środowisko wirtualne języka Python i później ponownie aktywować je w razie potrzeby.

Wskazówka

Zalecamy utworzenie i aktywowanie nowego środowiska języka Python w celu zainstalowania pakietów potrzebnych na potrzeby tego samouczka. Nie instaluj pakietów w globalnej instalacji języka Python. Zawsze należy używać środowiska wirtualnego lub conda podczas instalowania pakietów języka Python. W przeciwnym razie możesz przerwać globalną instalację języka Python.
Zainstaluj bibliotekę klienta OpenAI dla języka Python za pomocą następujących elementów:
```
pip install openai
```
Aby uzyskać zalecane uwierzytelnianie bez klucza za pomocą identyfikatora Entra firmy Microsoft, zainstaluj pakiet za azure-identity pomocą polecenia:
```
pip install azure-identity
```

Pobieranie informacji o zasobie

Aby uwierzytelnić aplikację przy użyciu zasobu usługi Azure OpenAI, musisz pobrać następujące informacje:

Microsoft Entra ID
Klucz interfejsu API

Nazwa zmiennej	Wartość
`AZURE_OPENAI_ENDPOINT`	Tę wartość można znaleźć w sekcji Klucze i punkt końcowy podczas badania zasobu w witrynie Azure Portal.
`AZURE_OPENAI_DEPLOYMENT_NAME`	Ta wartość będzie odpowiadać nazwie niestandardowej, którą wybrałeś dla swojego wdrożenia podczas wdrażania modelu. Tę wartość można znaleźć w obszarze Wdrożenia modelu zarządzania>zasobami w witrynie Azure Portal.
`OPENAI_API_VERSION`	Dowiedz się więcej o wersjach interfejsu API. Możesz zmienić wersję w kodzie lub użyć zmiennej środowiskowej.

Dowiedz się więcej na temat uwierzytelniania bez klucza i ustawiania zmiennych środowiskowych.

Nazwa zmiennej	Wartość
`AZURE_OPENAI_ENDPOINT`	Tę wartość można znaleźć w sekcji Klucze i punkt końcowy podczas badania zasobu w witrynie Azure Portal.
`AZURE_OPENAI_API_KEY`	Tę wartość można znaleźć w sekcji Klucze i punkt końcowy podczas badania zasobu w witrynie Azure Portal. Możesz użyć wartości `KEY1` lub `KEY2`.
`AZURE_OPENAI_DEPLOYMENT_NAME`	Ta wartość będzie odpowiadać nazwie niestandardowej, którą wybrałeś dla swojego wdrożenia podczas wdrażania modelu. Tę wartość można znaleźć w obszarze Wdrożenia modelu zarządzania>zasobami w witrynie Azure Portal.
`OPENAI_API_VERSION`	Dowiedz się więcej o wersjach interfejsu API.

Dowiedz się więcej na temat znajdowania kluczy interfejsu API i ustawiania zmiennych środowiskowych.

Ważne

Aby uzyskać więcej informacji na temat zabezpieczeń usług sztucznej inteligencji, zobacz Uwierzytelnianie żądań w usługach Azure AI.

Generowanie dźwięku na podstawie wprowadzania tekstu

Microsoft Entra ID
Klucz interfejsu API

to-audio.py Utwórz plik przy użyciu następującego kodu:

import requests
import base64 
import os 
from openai import AzureOpenAI
from azure.identity import DefaultAzureCredential

# Set environment variables or edit the corresponding values here.
endpoint = os.environ['AZURE_OPENAI_ENDPOINT']

# Keyless authentication
credential = DefaultAzureCredential()
token = credential.get_token("https://cognitiveservices.azure.com/.default")

api_version = '2025-01-01-preview'
url = f"{endpoint}/openai/deployments/gpt-4o-mini-audio-preview/chat/completions?api-version={api_version}"
headers= { "Authorization": f"Bearer {token.token}", "Content-Type": "application/json" }
body = {
  "modalities": ["audio", "text"],
  "model": "gpt-4o-mini-audio-preview",
  "audio": {
      "format": "wav",
      "voice": "alloy"
  },
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "text",
          "text": "Is a golden retriever a good family dog?"
        }
      ]
    }
  ]
}

# Make the audio chat completions request
completion = requests.post(url, headers=headers, json=body)
audio_data = completion.json()['choices'][0]['message']['audio']['data']

# Write the output audio data to a file
wav_bytes = base64.b64decode(audio_data)
with open("dog.wav", "wb") as f: 
  f.write(wav_bytes)

Uruchom plik języka Python.
```
python to-audio.py
```

to-audio.py Utwórz plik przy użyciu następującego kodu:

import requests
import base64 
import os 
from openai import AzureOpenAI 

# Set environment variables or edit the corresponding values here.
endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
api_key = os.environ['AZURE_OPENAI_API_KEY']

api_version = '2025-01-01-preview'
url = f"{endpoint}/openai/deployments/gpt-4o-mini-audio-preview/chat/completions?api-version={api_version}"
headers= { "api-key": api_key, "Content-Type": "application/json" }
body = {
  "modalities": ["audio", "text"],
  "model": "gpt-4o-mini-audio-preview",
  "audio": {
      "format": "wav",
      "voice": "alloy"
  },
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "text",
          "text": "Is a golden retriever a good family dog?"
        }
      ]
    }
  ]
}

# Make the audio chat completions request
completion = requests.post(url, headers=headers, json=body)
audio_data = completion.json()['choices'][0]['message']['audio']['data']

# Write the output audio data to a file 
wav_bytes = base64.b64decode(audio_data)
with open("dog.wav", "wb") as f: 
  f.write(wav_bytes)

Uruchom plik języka Python.
```
python to-audio.py
```

Poczekaj chwilę, aby uzyskać odpowiedź.

Dane wyjściowe generowania dźwięku z wprowadzania tekstu

Skrypt generuje plik audio o nazwie dog.wav w tym samym katalogu co skrypt. Plik dźwiękowy zawiera szczerą odpowiedź na monit: "Czy złoty retriever jest dobrym psem rodzinnym?"

Generowanie dźwięku i tekstu na podstawie danych wejściowych audio

Microsoft Entra ID
Klucz interfejsu API

from-audio.py Utwórz plik przy użyciu następującego kodu:

import requests
import base64
import os
from azure.identity import DefaultAzureCredential

# Set environment variables or edit the corresponding values here.
endpoint = os.environ['AZURE_OPENAI_ENDPOINT']

# Keyless authentication
credential = DefaultAzureCredential()
token = credential.get_token("https://cognitiveservices.azure.com/.default")

# Read and encode audio file  
with open('dog.wav', 'rb') as wav_reader: 
  encoded_string = base64.b64encode(wav_reader.read()).decode('utf-8') 

api_version = '2025-01-01-preview'
url = f"{endpoint}/openai/deployments/gpt-4o-mini-audio-preview/chat/completions?api-version={api_version}"
headers= { "Authorization": f"Bearer {token.token}", "Content-Type": "application/json" }
body = {
  "modalities": ["audio", "text"],
  "model": "gpt-4o-mini-audio-preview",
  "audio": {
      "format": "wav",
      "voice": "alloy"
  },
  "messages": [
    { 
        "role": "user", 
        "content": [ 
            {  
                "type": "text", 
                "text": "Describe in detail the spoken audio input." 
            }, 
            { 
                "type": "input_audio", 
                "input_audio": { 
                    "data": encoded_string, 
                    "format": "wav" 
                } 
            } 
        ] 
    }, 
  ]
}

completion = requests.post(url, headers=headers, json=body)

print(completion.json()['choices'][0]['message']['audio']['transcript'])

# Write the output audio data to a file
audio_data = completion.json()['choices'][0]['message']['audio']['data'] 
wav_bytes = base64.b64decode(audio_data)
with open("analysis.wav", "wb") as f: 
  f.write(wav_bytes)

Uruchom plik języka Python.
```
python from-audio.py
```

from-audio.py Utwórz plik przy użyciu następującego kodu:

import requests
import base64
import os

# Set environment variables or edit the corresponding values here.
endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
api_key = os.environ['AZURE_OPENAI_API_KEY']

# Read and encode audio file  
with open('dog.wav', 'rb') as wav_reader: 
  encoded_string = base64.b64encode(wav_reader.read()).decode('utf-8') 

api_version = '2025-01-01-preview'
url = f"{endpoint}/openai/deployments/gpt-4o-mini-audio-preview/chat/completions?api-version={api_version}"
headers= { "api-key": api_key, "Content-Type": "application/json" }
body = {
  "modalities": ["audio", "text"],
  "model": "gpt-4o-mini-audio-preview",
  "audio": {
      "format": "wav",
      "voice": "alloy"
  },
  "messages": [
    { 
        "role": "user", 
        "content": [ 
            {  
                "type": "text", 
                "text": "Describe in detail the spoken audio input." 
            }, 
            { 
                "type": "input_audio", 
                "input_audio": { 
                    "data": encoded_string, 
                    "format": "wav" 
                } 
            } 
        ] 
    }, 
  ]
}

completion = requests.post(url, headers=headers, json=body)

print(completion.json()['choices'][0]['message']['audio']['transcript'])

# Write the output audio data to a file
audio_data = completion.json()['choices'][0]['message']['audio']['data'] 
wav_bytes = base64.b64decode(audio_data)
with open("analysis.wav", "wb") as f: 
  f.write(wav_bytes)

Uruchom plik języka Python.
```
python from-audio.py
```

Poczekaj chwilę, aby uzyskać odpowiedź.

Wynik generowania dźwięku i tekstu z wejściowego sygnału audio

Generowanie dźwięku i używanie uzupełniania czatu wielowrackowego

Microsoft Entra ID
Klucz interfejsu API

multi-turn.py Utwórz plik przy użyciu następującego kodu:

import requests
import base64 
import os 
from openai import AzureOpenAI 
from azure.identity import DefaultAzureCredential

# Set environment variables or edit the corresponding values here.
endpoint = os.environ['AZURE_OPENAI_ENDPOINT']

# Keyless authentication
credential = DefaultAzureCredential()
token = credential.get_token("https://cognitiveservices.azure.com/.default")

api_version = '2025-01-01-preview'
url = f"{endpoint}/openai/deployments/gpt-4o-mini-audio-preview/chat/completions?api-version={api_version}"
headers= { "Authorization": f"Bearer {token.token}", "Content-Type": "application/json" }

# Read and encode audio file  
with open('dog.wav', 'rb') as wav_reader: 
  encoded_string = base64.b64encode(wav_reader.read()).decode('utf-8') 

# Initialize messages with the first turn's user input 
messages = [
    { 
        "role": "user", 
        "content": [ 
            {  
                "type": "text", 
                "text": "Describe in detail the spoken audio input." 
            }, 
            { 
                "type": "input_audio", 
                "input_audio": { 
                    "data": encoded_string, 
                    "format": "wav" 
                } 
            } 
        ] 
    }] 

body = {
  "modalities": ["audio", "text"],
  "model": "gpt-4o-mini-audio-preview",
  "audio": {
      "format": "wav",
      "voice": "alloy"
  },
  "messages": messages
}

# Get the first turn's response, including generated audio 
completion = requests.post(url, headers=headers, json=body)

print("Get the first turn's response:")
print(completion.json()['choices'][0]['message']['audio']['transcript']) 

print("Add a history message referencing the first turn's audio by ID:")
print(completion.json()['choices'][0]['message']['audio']['id'])

# Add a history message referencing the first turn's audio by ID 
messages.append({ 
    "role": "assistant", 
    "audio": { "id": completion.json()['choices'][0]['message']['audio']['id'] } 
}) 

# Add the next turn's user message 
messages.append({ 
    "role": "user", 
    "content": "Very briefly, summarize the favorability." 
}) 

body = {
  "model": "gpt-4o-mini-audio-preview",
  "messages": messages
}

# Send the follow-up request with the accumulated messages
completion = requests.post(url, headers=headers, json=body) 

print("Very briefly, summarize the favorability.")
print(completion.json()['choices'][0]['message']['content'])

Uruchom plik języka Python.
```
python multi-turn.py
```

multi-turn.py Utwórz plik przy użyciu następującego kodu:

import requests
import base64 
import os 
from openai import AzureOpenAI 

# Set environment variables or edit the corresponding values here.
endpoint = os.environ['AZURE_OPENAI_ENDPOINT']
api_key = os.environ['AZURE_OPENAI_API_KEY']

api_version = '2025-01-01-preview'
url = f"{endpoint}/openai/deployments/gpt-4o-mini-audio-preview/chat/completions?api-version={api_version}"
headers= { "api-key": api_key, "Content-Type": "application/json" }

# Read and encode audio file  
with open('dog.wav', 'rb') as wav_reader: 
  encoded_string = base64.b64encode(wav_reader.read()).decode('utf-8') 

# Initialize messages with the first turn's user input 
messages = [
    { 
        "role": "user", 
        "content": [ 
            {  
                "type": "text", 
                "text": "Describe in detail the spoken audio input." 
            }, 
            { 
                "type": "input_audio", 
                "input_audio": { 
                    "data": encoded_string, 
                    "format": "wav" 
                } 
            } 
        ] 
    }] 

body = {
  "modalities": ["audio", "text"],
  "model": "gpt-4o-mini-audio-preview",
  "audio": {
      "format": "wav",
      "voice": "alloy"
  },
  "messages": messages
}


# Get the first turn's response, including generated audio 
completion = requests.post(url, headers=headers, json=body)

print("Get the first turn's response:")
print(completion.json()['choices'][0]['message']['audio']['transcript']) 

print("Add a history message referencing the first turn's audio by ID:")
print(completion.json()['choices'][0]['message']['audio']['id'])

# Add a history message referencing the first turn's audio by ID 
messages.append({ 
    "role": "assistant", 
    "audio": { "id": completion.json()['choices'][0]['message']['audio']['id'] } 
}) 

# Add the next turn's user message 
messages.append({ 
    "role": "user", 
    "content": "Very briefly, summarize the favorability." 
}) 

body = {
  "model": "gpt-4o-mini-audio-preview",
  "messages": messages
}

# Send the follow-up request with the accumulated messages
completion = requests.post(url, headers=headers, json=body) 

print("Very briefly, summarize the favorability.")
print(completion.json()['choices'][0]['message']['content'])

Uruchom plik języka Python.
```
python multi-turn.py
```

Poczekaj chwilę, aby uzyskać odpowiedź.

Dane wyjściowe dla uzupełniania czatu wielowrackowego

Skrypt generuje transkrypcję podsumowania danych wejściowych dźwięku mówionego. Następnie wykonuje rozmowę z wieloma wymianami w celu krótkiego podsumowania wypowiedzi audio.

Dokumentacja referencyjna | Kod źródłowy biblioteki | Pakiet (npm) | Przykłady

Oto tabela obsługiwanych modalności z przykładowymi przypadkami użycia:

Wejście modalne	Dane wyjściowe modalności	Przykładowy przypadek użycia
Tekst	Tekst i dźwięk	Zamiana tekstu na mowę, generowanie książki audio
Dźwięk	Tekst i dźwięk	Transkrypcja audio, generowanie książek audio
Dźwięk	Tekst	Transkrypcja audio
Tekst i dźwięk	Tekst i dźwięk	Generowanie książek audio
Tekst i dźwięk	Tekst	Transkrypcja audio

Obsługiwane modele

Obecnie tylko wersje gpt-4o-audio-preview i gpt-4o-mini-audio-preview: 2024-12-17 obsługują generowanie dźwięku.

Aby uzyskać więcej informacji na temat dostępności regionów, zobacz dokumentację modeli i wersji.

Obecnie następujące głosy są obsługiwane dla dźwięku wychodzącego: Alloy, Echo i Shimmer.

Maksymalny rozmiar pliku audio to 20 MB.

Uwaga / Notatka

Interfejs Realtime API używa tego samego podstawowego modelu audio GPT-4o co API uzupełnień, ale jest zoptymalizowany pod kątem interakcji audio w czasie rzeczywistym z małymi opóźnieniami.

Obsługa interfejsu API

Obsługa uzupełniania audio została po raz pierwszy dodana w wersji interfejsu API 2025-01-01-preview.

Wymagania wstępne

Subskrypcja platformy Azure - Utwórz ją za darmo
obsługa Node.js LTS lub ESM.
Język TypeScript zainstalowany globalnie.
Zasób usługi Azure OpenAI utworzony w jednym z obsługiwanych regionów. Aby uzyskać więcej informacji na temat dostępności regionów, zobacz dokumentację modeli i wersji.
Następnie należy wdrożyć gpt-4o-mini-audio-preview model przy użyciu zasobu usługi Azure OpenAI. Aby uzyskać więcej informacji, zobacz Tworzenie zasobu i wdrażanie modelu za pomocą usługi Azure OpenAI.

Wymagania wstępne dotyczące Microsoft Entra ID

W przypadku zalecanego uwierzytelniania bez klucza za pomocą identyfikatora Entra firmy Microsoft należy wykonać następujące czynności:

Zainstaluj Azure CLI używane do uwierzytelniania bezkluczowego za pomocą Microsoft Entra ID.
Cognitive Services User Przypisz rolę do konta użytkownika. Role można przypisać w portalu Azure w sekcji Kontrola dostępu (IAM)>Dodawanie przypisania roli.

Ustawienia

Utwórz nowy folder audio-completions-quickstart i przejdź do folderu Szybki start za pomocą następującego polecenia:
```
mkdir audio-completions-quickstart && cd audio-completions-quickstart
```
Utwórz element package.json za pomocą następującego polecenia:
```
npm init -y
```
Zaktualizuj package.json do ECMAScript za pomocą następującego polecenia:
```
npm pkg set type=module
```
Zainstaluj bibliotekę klienta openAI dla języka JavaScript za pomocą następujących narzędzi:
```
npm install openai
```
Aby uzyskać zalecane uwierzytelnianie bez klucza za pomocą identyfikatora Entra firmy Microsoft, zainstaluj pakiet za @azure/identity pomocą polecenia:
```
npm install @azure/identity
```

Pobieranie informacji o zasobie

Aby uwierzytelnić aplikację przy użyciu zasobu usługi Azure OpenAI, musisz pobrać następujące informacje:

Microsoft Entra ID
Klucz interfejsu API

Nazwa zmiennej	Wartość
`AZURE_OPENAI_ENDPOINT`	Tę wartość można znaleźć w sekcji Klucze i punkt końcowy podczas badania zasobu w witrynie Azure Portal.
`AZURE_OPENAI_DEPLOYMENT_NAME`	Ta wartość będzie odpowiadać nazwie niestandardowej, którą wybrałeś dla swojego wdrożenia podczas wdrażania modelu. Tę wartość można znaleźć w obszarze Wdrożenia modelu zarządzania>zasobami w witrynie Azure Portal.
`OPENAI_API_VERSION`	Dowiedz się więcej o wersjach interfejsu API. Możesz zmienić wersję w kodzie lub użyć zmiennej środowiskowej.

Dowiedz się więcej na temat uwierzytelniania bez klucza i ustawiania zmiennych środowiskowych.

Nazwa zmiennej	Wartość
`AZURE_OPENAI_ENDPOINT`	Tę wartość można znaleźć w sekcji Klucze i punkt końcowy podczas badania zasobu w witrynie Azure Portal.
`AZURE_OPENAI_API_KEY`	Tę wartość można znaleźć w sekcji Klucze i punkt końcowy podczas badania zasobu w witrynie Azure Portal. Możesz użyć wartości `KEY1` lub `KEY2`.
`AZURE_OPENAI_DEPLOYMENT_NAME`	Ta wartość będzie odpowiadać nazwie niestandardowej, którą wybrałeś dla swojego wdrożenia podczas wdrażania modelu. Tę wartość można znaleźć w obszarze Wdrożenia modelu zarządzania>zasobami w witrynie Azure Portal.
`OPENAI_API_VERSION`	Dowiedz się więcej o wersjach interfejsu API.

Dowiedz się więcej na temat znajdowania kluczy interfejsu API i ustawiania zmiennych środowiskowych.

Ważne

Aby uzyskać więcej informacji na temat zabezpieczeń usług sztucznej inteligencji, zobacz Uwierzytelnianie żądań w usługach Azure AI.

Ostrzeżenie

Aby użyć zalecanego uwierzytelniania bez klucza z zestawem SDK, upewnij się, że zmienna AZURE_OPENAI_API_KEY środowiskowa nie jest ustawiona.

Generowanie dźwięku na podstawie wprowadzania tekstu

Microsoft Entra ID
Klucz interfejsu API

to-audio.ts Utwórz plik przy użyciu następującego kodu:

import { writeFileSync } from "node:fs";
import { AzureOpenAI } from "openai/index.mjs";
import {
    DefaultAzureCredential,
    getBearerTokenProvider,
  } from "@azure/identity";

// Set environment variables or edit the corresponding values here.
const endpoint: string = process.env.AZURE_OPENAI_ENDPOINT || "AZURE_OPENAI_ENDPOINT";
const deployment: string = process.env.AZURE_OPENAI_DEPLOYMENT_NAME || "gpt-4o-mini-audio-preview"; 
const apiVersion: string = process.env.OPENAI_API_VERSION || "2025-01-01-preview"; 

// Keyless authentication 
const getClient = (): AzureOpenAI => {
    const credential = new DefaultAzureCredential();
    const scope = "https://cognitiveservices.azure.com/.default";
    const azureADTokenProvider = getBearerTokenProvider(credential, scope);
    const client = new AzureOpenAI({
      endpoint: endpoint,
      apiVersion: apiVersion,
      azureADTokenProvider,
    });
    return client;
};

const client = getClient();

async function main(): Promise<void> {

    // Make the audio chat completions request
    const response = await client.chat.completions.create({ 
        model: "gpt-4o-mini-audio-preview", 
        modalities: ["text", "audio"], 
        audio: { voice: "alloy", format: "wav" }, 
        messages: [ 
        { 
            role: "user", 
            content: "Is a golden retriever a good family dog?" 
        } 
        ] 
    }); 

  // Inspect returned data 
  console.log(response.choices[0]); 

  // Write the output audio data to a file
  if (response.choices[0].message.audio) {
    writeFileSync( 
      "dog.wav", 
      Buffer.from(response.choices[0].message.audio.data, 'base64'), 
      { encoding: "utf-8" } 
    ); 
  } else {
    console.error("Audio data is null or undefined.");
  }
}

main().catch((err: Error) => {
  console.error("Error occurred:", err);
});

export { main };

Utwórz plik tsconfig.json do transpilacji kodu TypeScript i skopiuj następujący kod dla ECMAScript.

{
    "compilerOptions": {
      "module": "NodeNext",
      "target": "ES2022", // Supports top-level await
      "moduleResolution": "NodeNext",
      "skipLibCheck": true, // Avoid type errors from node_modules
      "strict": true // Enable strict type-checking options
    },
    "include": ["*.ts"]
}

Transpiluj z języka TypeScript do języka JavaScript.
```
tsc
```
Zaloguj się do platformy Azure przy użyciu następującego polecenia:
```
az login
```
Uruchom kod za pomocą następującego polecenia:
```
node to-audio.js
```

to-audio.ts Utwórz plik przy użyciu następującego kodu:

import { writeFileSync } from "node:fs";
import { AzureOpenAI } from "openai/index.mjs";

// Set environment variables or edit the corresponding values here.
const endpoint: string = process.env.AZURE_OPENAI_ENDPOINT || "AZURE_OPENAI_ENDPOINT";
const apiKey: string = process.env.AZURE_OPENAI_API_KEY || "AZURE_OPENAI_API_KEY";
const apiVersion: string = "2025-01-01-preview"; 
const deployment: string = "gpt-4o-mini-audio-preview"; 

const client = new AzureOpenAI({ 
  endpoint, 
  apiKey, 
  apiVersion, 
  deployment 
});  

async function main(): Promise<void> {

    // Make the audio chat completions request
    const response = await client.chat.completions.create({ 
        model: "gpt-4o-mini-audio-preview", 
        modalities: ["text", "audio"], 
        audio: { voice: "alloy", format: "wav" }, 
        messages: [ 
        { 
            role: "user", 
            content: "Is a golden retriever a good family dog?" 
        } 
        ] 
    }); 

  // Inspect returned data 
  console.log(response.choices[0]); 

  // Write the output audio data to a file
  if (response.choices[0].message.audio) {
    writeFileSync( 
      "dog.wav", 
      Buffer.from(response.choices[0].message.audio.data, 'base64'), 
      { encoding: "utf-8" } 
    ); 
  } else {
    console.error("Audio data is null or undefined.");
  }
}

main().catch((err: Error) => {
  console.error("Error occurred:", err);
});

export { main };

Utwórz plik tsconfig.json do transpilacji kodu TypeScript i skopiuj następujący kod dla ECMAScript.

{
    "compilerOptions": {
      "module": "NodeNext",
      "target": "ES2022", // Supports top-level await
      "moduleResolution": "NodeNext",
      "skipLibCheck": true, // Avoid type errors from node_modules
      "strict": true // Enable strict type-checking options
    },
    "include": ["*.ts"]
}

Transpiluj z języka TypeScript do języka JavaScript.
```
tsc
```
Uruchom kod za pomocą następującego polecenia:
```
node to-audio.js
```

Poczekaj chwilę, aby uzyskać odpowiedź.

Dane wyjściowe generowania dźwięku z wprowadzania tekstu

Skrypt generuje plik audio o nazwie dog.wav w tym samym katalogu co skrypt. Plik dźwiękowy zawiera szczerą odpowiedź na monit: "Czy złoty retriever jest dobrym psem rodzinnym?"

Generowanie dźwięku i tekstu na podstawie danych wejściowych audio

Microsoft Entra ID
Klucz interfejsu API

from-audio.ts Utwórz plik przy użyciu następującego kodu:

import { AzureOpenAI } from "openai";
import { writeFileSync } from "node:fs";
import { promises as fs } from 'fs';
import {
    DefaultAzureCredential,
    getBearerTokenProvider,
  } from "@azure/identity";

// Set environment variables or edit the corresponding values here.
const endpoint: string = process.env.AZURE_OPENAI_ENDPOINT || "AZURE_OPENAI_ENDPOINT";
const apiVersion: string = "2025-01-01-preview"; 
const deployment: string = "gpt-4o-mini-audio-preview"; 

// Keyless authentication 
const getClient = (): AzureOpenAI => {
    const credential = new DefaultAzureCredential();
    const scope = "https://cognitiveservices.azure.com/.default";
    const azureADTokenProvider = getBearerTokenProvider(credential, scope);
    const client = new AzureOpenAI({
      endpoint: endpoint,
      apiVersion: apiVersion,
      azureADTokenProvider,
    });
    return client;
};

const client = getClient();

async function main(): Promise<void> {

    // Buffer the audio for input to the chat completion
    const wavBuffer = await fs.readFile("dog.wav"); 
    const base64str = Buffer.from(wavBuffer).toString("base64"); 

    // Make the audio chat completions request
    const response = await client.chat.completions.create({ 
      model: "gpt-4o-mini-audio-preview",
      modalities: ["text", "audio"], 
      audio: { voice: "alloy", format: "wav" },
      messages: [ 
        { 
          role: "user", 
          content: [ 
            { 
              type: "text", 
              text: "Describe in detail the spoken audio input." 
            }, 
            { 
              type: "input_audio", 
              input_audio: { 
                data: base64str, 
                format: "wav" 
              } 
            } 
          ] 
        } 
      ] 
    }); 

    console.log(response.choices[0]); 

    // Write the output audio data to a file
    if (response.choices[0].message.audio) {
        writeFileSync("analysis.wav", Buffer.from(response.choices[0].message.audio.data, 'base64'), { encoding: "utf-8" });
    }
    else {
        console.error("Audio data is null or undefined.");
  }
}

main().catch((err: Error) => {
  console.error("Error occurred:", err);
});

export { main };

Utwórz plik tsconfig.json do transpilacji kodu TypeScript i skopiuj następujący kod dla ECMAScript.

{
    "compilerOptions": {
      "module": "NodeNext",
      "target": "ES2022", // Supports top-level await
      "moduleResolution": "NodeNext",
      "skipLibCheck": true, // Avoid type errors from node_modules
      "strict": true // Enable strict type-checking options
    },
    "include": ["*.ts"]
}

Transpiluj z języka TypeScript do języka JavaScript.
```
tsc
```
Zaloguj się do platformy Azure przy użyciu następującego polecenia:
```
az login
```
Uruchom kod za pomocą następującego polecenia:
```
node from-audio.js
```

from-audio.ts Utwórz plik przy użyciu następującego kodu:

import { AzureOpenAI } from "openai";
import { writeFileSync } from "node:fs";
import { promises as fs } from 'fs';

// Set environment variables or edit the corresponding values here.
const endpoint: string = process.env.AZURE_OPENAI_ENDPOINT || "AZURE_OPENAI_ENDPOINT";
const apiKey: string = process.env.AZURE_OPENAI_API_KEY || "AZURE_OPENAI_API_KEY";
const apiVersion: string = "2025-01-01-preview"; 
const deployment: string = "gpt-4o-mini-audio-preview"; 

const client = new AzureOpenAI({ 
  endpoint, 
  apiKey, 
  apiVersion, 
  deployment 
});  

async function main(): Promise<void> {

  // Buffer the audio for input to the chat completion
  const wavBuffer = await fs.readFile("dog.wav"); 
  const base64str = Buffer.from(wavBuffer).toString("base64"); 

  // Make the audio chat completions request
  const response = await client.chat.completions.create({ 
    model: "gpt-4o-mini-audio-preview",
    modalities: ["text", "audio"], 
    audio: { voice: "alloy", format: "wav" },
    messages: [ 
      { 
        role: "user", 
        content: [ 
          { 
            type: "text", 
            text: "Describe in detail the spoken audio input." 
          }, 
          { 
            type: "input_audio", 
            input_audio: { 
              data: base64str, 
              format: "wav" 
            } 
          } 
        ] 
      } 
    ] 
  }); 

  console.log(response.choices[0]); 

  // Write the output audio data to a file
  if (response.choices[0].message.audio) {
      writeFileSync("analysis.wav", Buffer.from(response.choices[0].message.audio.data, 'base64'), { encoding: "utf-8" });
  }
  else {
      console.error("Audio data is null or undefined.");
}
}

main().catch((err: Error) => {
console.error("Error occurred:", err);
});

export { main };

Utwórz plik tsconfig.json do transpilacji kodu TypeScript i skopiuj następujący kod dla ECMAScript.

{
    "compilerOptions": {
      "module": "NodeNext",
      "target": "ES2022", // Supports top-level await
      "moduleResolution": "NodeNext",
      "skipLibCheck": true, // Avoid type errors from node_modules
      "strict": true // Enable strict type-checking options
    },
    "include": ["*.ts"]
}

Transpiluj z języka TypeScript do języka JavaScript.
```
tsc
```
Uruchom kod za pomocą następującego polecenia:
```
node from-audio.js
```

Poczekaj chwilę, aby uzyskać odpowiedź.

Wynik generowania dźwięku i tekstu z wejściowego sygnału audio

Generowanie dźwięku i używanie uzupełniania czatu wielowrackowego

Microsoft Entra ID
Klucz interfejsu API

multi-turn.ts Utwórz plik przy użyciu następującego kodu:

import { AzureOpenAI } from "openai/index.mjs";
import { promises as fs } from 'fs';
import { ChatCompletionMessageParam } from "openai/resources/index.mjs";
import {
    DefaultAzureCredential,
    getBearerTokenProvider,
  } from "@azure/identity";

// Set environment variables or edit the corresponding values here.
const endpoint: string = process.env.AZURE_OPENAI_ENDPOINT || "AZURE_OPENAI_ENDPOINT";
const apiVersion: string = "2025-01-01-preview"; 
const deployment: string = "gpt-4o-mini-audio-preview"; 

// Keyless authentication 
const getClient = (): AzureOpenAI => {
    const credential = new DefaultAzureCredential();
    const scope = "https://cognitiveservices.azure.com/.default";
    const azureADTokenProvider = getBearerTokenProvider(credential, scope);
    const client = new AzureOpenAI({
      endpoint: endpoint,
      apiVersion: apiVersion,
      azureADTokenProvider,
    });
    return client;
};

const client = getClient(); 

async function main(): Promise<void> {

    // Buffer the audio for input to the chat completion
    const wavBuffer = await fs.readFile("dog.wav"); 
    const base64str = Buffer.from(wavBuffer).toString("base64"); 

    // Initialize messages with the first turn's user input 
    const messages: ChatCompletionMessageParam[] = [
      {
        role: "user",
        content: [
          { 
            type: "text", 
            text: "Describe in detail the spoken audio input." 
          },
          { 
            type: "input_audio", 
            input_audio: { 
              data: base64str, 
              format: "wav" 
            } 
          }
        ]
      }
    ];

    // Get the first turn's response 

    const response = await client.chat.completions.create({ 
        model: "gpt-4o-mini-audio-preview",
        modalities: ["text", "audio"], 
        audio: { voice: "alloy", format: "wav" }, 
        messages: messages
    }); 

    console.log(response.choices[0]); 

    // Add a history message referencing the previous turn's audio by ID 
    messages.push({ 
        role: "assistant", 
        audio: response.choices[0].message.audio ? { id: response.choices[0].message.audio.id } : undefined
    });

    // Add a new user message for the second turn
    messages.push({ 
        role: "user", 
        content: [ 
            { 
              type: "text", 
              text: "Very concisely summarize the favorability." 
            } 
        ] 
    }); 

    // Send the follow-up request with the accumulated messages
    const followResponse = await client.chat.completions.create({ 
        model: "gpt-4o-mini-audio-preview",
        messages: messages
    });

    console.log(followResponse.choices[0].message.content); 
}

main().catch((err: Error) => {
  console.error("Error occurred:", err);
});

export { main };

Utwórz plik tsconfig.json do transpilacji kodu TypeScript i skopiuj następujący kod dla ECMAScript.

{
    "compilerOptions": {
      "module": "NodeNext",
      "target": "ES2022", // Supports top-level await
      "moduleResolution": "NodeNext",
      "skipLibCheck": true, // Avoid type errors from node_modules
      "strict": true // Enable strict type-checking options
    },
    "include": ["*.ts"]
}

Transpiluj z języka TypeScript do języka JavaScript.
```
tsc
```
Zaloguj się do platformy Azure przy użyciu następującego polecenia:
```
az login
```
Uruchom kod za pomocą następującego polecenia:
```
node multi-turn.js
```

multi-turn.ts Utwórz plik przy użyciu następującego kodu:

import { AzureOpenAI } from "openai/index.mjs";
import { promises as fs } from 'fs';
import { ChatCompletionMessageParam } from "openai/resources/index.mjs";

// Set environment variables or edit the corresponding values here.
const endpoint: string = process.env.AZURE_OPENAI_ENDPOINT || "AZURE_OPENAI_ENDPOINT" as string;
const apiKey: string = process.env.AZURE_OPENAI_API_KEY || "AZURE_OPENAI_API_KEY";
const apiVersion: string = "2025-01-01-preview"; 
const deployment: string = "gpt-4o-mini-audio-preview"; 

const client = new AzureOpenAI({ 
  endpoint, 
  apiKey, 
  apiVersion, 
  deployment 
});  

async function main(): Promise<void> {

    // Buffer the audio for input to the chat completion
    const wavBuffer = await fs.readFile("dog.wav"); 
    const base64str = Buffer.from(wavBuffer).toString("base64"); 

    // Initialize messages with the first turn's user input 
    const messages: ChatCompletionMessageParam[] = [
      {
        role: "user",
        content: [
          { 
            type: "text", 
            text: "Describe in detail the spoken audio input." 
          },
          { 
            type: "input_audio", 
            input_audio: { 
              data: base64str, 
              format: "wav" 
            } 
          }
        ]
      }
    ];

    // Get the first turn's response 

    const response = await client.chat.completions.create({ 
      model: "gpt-4o-mini-audio-preview",
      modalities: ["text", "audio"], 
      audio: { voice: "alloy", format: "wav" }, 
      messages: messages
    }); 

    console.log(response.choices[0]); 

    // Add a history message referencing the previous turn's audio by ID 
    messages.push({ 
        role: "assistant", 
        audio: response.choices[0].message.audio ? { id: response.choices[0].message.audio.id } : undefined
    });

    // Add a new user message for the second turn
    messages.push({ 
        role: "user", 
        content: [ 
            { 
              type: "text", 
              text: "Very concisely summarize the favorability." 
            } 
        ] 
    }); 

    // Send the follow-up request with the accumulated messages
    const followResponse = await client.chat.completions.create({ 
        model: "gpt-4o-mini-audio-preview",
        messages: messages
    });

    console.log(followResponse.choices[0].message.content); 
}

main().catch((err: Error) => {
  console.error("Error occurred:", err);
});

export { main };

Utwórz plik tsconfig.json do transpilacji kodu TypeScript i skopiuj następujący kod dla ECMAScript.

{
    "compilerOptions": {
      "module": "NodeNext",
      "target": "ES2022", // Supports top-level await
      "moduleResolution": "NodeNext",
      "skipLibCheck": true, // Avoid type errors from node_modules
      "strict": true // Enable strict type-checking options
    },
    "include": ["*.ts"]
}

Transpiluj z języka TypeScript do języka JavaScript.
```
tsc
```
Uruchom kod za pomocą następującego polecenia:
```
node multi-turn.js
```

Poczekaj chwilę, aby uzyskać odpowiedź.

Dane wyjściowe dla uzupełniania czatu wielowrackowego

Skrypt generuje transkrypcję podsumowania danych wejściowych dźwięku mówionego. Następnie wykonuje rozmowę z wieloma wymianami w celu krótkiego podsumowania wypowiedzi audio.

Czyszczenie zasobów

Jeśli chcesz wyczyścić i usunąć zasób usługi Azure OpenAI, możesz usunąć zasób. Przed usunięciem zasobu należy najpierw usunąć wszystkie wdrożone modele.

Rozwiązywanie problemów

Uwaga / Notatka

W przypadku korzystania z gpt-4o-audio-preview do uzupełniania czatu w trybie audio i gdy stream jest ustawione na true, jedynym obsługiwanym formatem audio jest pcm16.

Dowiedz się więcej o typach wdrożeń usługi Azure OpenAI.
Dowiedz się więcej o przydziałach i limitach usługi Azure OpenAI.

Udostępnij za pośrednictwem

Szybki start: rozpoczynanie pracy z generowaniem dźwięku usługi Azure OpenAI

Obsługiwane modele

Obsługa interfejsu API

Wdrażanie modelu na potrzeby generowania dźwięku

Korzystanie z generowania dźwięku GPT-4o

Obsługiwane modele

Obsługa interfejsu API

Wymagania wstępne

Wymagania wstępne dotyczące Microsoft Entra ID

Ustawienia

Pobieranie informacji o zasobie

Generowanie dźwięku na podstawie wprowadzania tekstu

Dane wyjściowe generowania dźwięku z wprowadzania tekstu

Generowanie dźwięku i tekstu na podstawie danych wejściowych audio

Wynik generowania dźwięku i tekstu z wejściowego sygnału audio

Generowanie dźwięku i używanie uzupełniania czatu wielowrackowego

Dane wyjściowe dla uzupełniania czatu wielowrackowego

Obsługiwane modele

Obsługa interfejsu API

Wymagania wstępne

Wymagania wstępne dotyczące Microsoft Entra ID

Ustawienia

Pobieranie informacji o zasobie

Generowanie dźwięku na podstawie wprowadzania tekstu

Dane wyjściowe generowania dźwięku z wprowadzania tekstu

Generowanie dźwięku i tekstu na podstawie danych wejściowych audio

Wynik generowania dźwięku i tekstu z wejściowego sygnału audio

Generowanie dźwięku i używanie uzupełniania czatu wielowrackowego

Dane wyjściowe dla uzupełniania czatu wielowrackowego

Obsługiwane modele

Obsługa interfejsu API

Wymagania wstępne

Wymagania wstępne dotyczące Microsoft Entra ID

Ustawienia

Pobieranie informacji o zasobie

Generowanie dźwięku na podstawie wprowadzania tekstu

Dane wyjściowe generowania dźwięku z wprowadzania tekstu

Generowanie dźwięku i tekstu na podstawie danych wejściowych audio

Wynik generowania dźwięku i tekstu z wejściowego sygnału audio

Generowanie dźwięku i używanie uzupełniania czatu wielowrackowego

Dane wyjściowe dla uzupełniania czatu wielowrackowego

Obsługiwane modele

Obsługa interfejsu API

Wymagania wstępne

Wymagania wstępne dotyczące Microsoft Entra ID

Ustawienia

Pobieranie informacji o zasobie

Generowanie dźwięku na podstawie wprowadzania tekstu

Dane wyjściowe generowania dźwięku z wprowadzania tekstu

Generowanie dźwięku i tekstu na podstawie danych wejściowych audio

Wynik generowania dźwięku i tekstu z wejściowego sygnału audio

Generowanie dźwięku i używanie uzupełniania czatu wielowrackowego

Dane wyjściowe dla uzupełniania czatu wielowrackowego

Czyszczenie zasobów

Rozwiązywanie problemów

Treści powiązane

Opinia

Dodatkowe zasoby