如何识别和翻译语音

本作指南介绍如何识别人工语音并将其翻译为其他语言。

有关以下内容的详细信息，请参阅语音翻译概述：

将语音转换为文本
将语音翻译为多个目标语言
进行直接语音到语音翻译

敏感数据和环境变量

本文中的示例源代码取决于用于存储敏感数据的环境变量，例如语音资源的密钥和区域。 C# 代码文件包含两 static readonly string 个值，这些值是从主机的环境变量分配的： SPEECH__SUBSCRIPTION__KEY 和 SPEECH__SERVICE__REGION。这两个字段都属于类的作用域，因此可以在类的方法内部访问这些字段。

public class Program
{
    static readonly string SPEECH__SUBSCRIPTION__KEY =
        Environment.GetEnvironmentVariable(nameof(SPEECH__SUBSCRIPTION__KEY));
    
    static readonly string SPEECH__SERVICE__REGION =
        Environment.GetEnvironmentVariable(nameof(SPEECH__SERVICE__REGION));

    public static void Main(string[] args) { }
}

有关环境变量的详细信息，请参阅环境变量和应用程序配置。

重要

请谨慎使用 API 密钥。请不要直接在代码中包含 API 密钥，并且切勿公开发布该密钥。如果使用 API 密钥，请安全地将其存储在Azure Key Vault中。有关在应用中安全地使用 API 密钥的详细信息，请参阅 API 密钥和 Azure Key Vault。

有关 AI 服务安全性的详细信息，请参阅对 Azure AI 服务进行请求身份验证。

创建语音翻译配置

若要使用语音 SDK 调用语音服务，需要创建 SpeechTranslationConfig 实例。此类包含有关您的语音服务资源的信息，例如您的密钥、关联的区域、终结点、服务器或授权令牌。

小窍门

无论你是执行语音识别、语音合成、翻译还是意向识别，你都会始终创建配置。

可以通过以下几种方式初始化 SpeechTranslationConfig 实例：

在订阅中传入密钥和关联的区域。
使用终结点：传入语音服务终结点。密钥或授权令牌是可选的。
使用主机：传入主机地址。密钥或授权令牌是可选的。
使用授权令牌：传入授权令牌和关联的区域。

让我们看看如何使用密钥和区域创建 SpeechTranslationConfig 实例。获取 Azure 门户中的语音资源密钥和区域。

public class Program
{
    static readonly string SPEECH__SUBSCRIPTION__KEY =
        Environment.GetEnvironmentVariable(nameof(SPEECH__SUBSCRIPTION__KEY));
    
    static readonly string SPEECH__SERVICE__REGION =
        Environment.GetEnvironmentVariable(nameof(SPEECH__SERVICE__REGION));

    public static void Main(string[] args)
    {
        try
        {
            TranslateSpeechAsync().Wait();
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex);
        }
    }

    static async Task TranslateSpeechAsync()
    {
        var speechTranslationConfig =
            SpeechTranslationConfig.FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    }
}

更改源语言

语音翻译的一个常见任务是指定输入（或源）语言。以下示例演示如何将输入语言更改为意大利语。在代码中，通过将 SpeechTranslationConfig 实例分配给 SpeechRecognitionLanguage 属性，与 SpeechTranslationConfig 实例进行交互：

static async Task TranslateSpeechAsync()
{
    var speechTranslationConfig =
        SpeechTranslationConfig.FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    // Source (input) language
    speechTranslationConfig.SpeechRecognitionLanguage = "it-IT";
}

SpeechRecognitionLanguage 属性需要语言区域设置格式字符串。请参阅支持的语音翻译区域设置列表。

添加翻译语言

语音翻译的另一个常见任务是指定目标翻译语言。至少需要一个，但支持多个。以下代码片段将法语和德语设置为翻译语言目标：

static async Task TranslateSpeechAsync()
{
    var speechTranslationConfig =
        SpeechTranslationConfig.FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    speechTranslationConfig.SpeechRecognitionLanguage = "it-IT";
    
    speechTranslationConfig.AddTargetLanguage("fr");
    speechTranslationConfig.AddTargetLanguage("de");
}

每次调用 AddTargetLanguage 时，都会指定一种新的目标翻译语言。换句话说，从源语言识别语音时，每个目标翻译都可用作生成的翻译作的一部分。

初始化翻译识别器

创建 SpeechTranslationConfig 实例后，下一步是初始化 TranslationRecognizer。初始化 TranslationRecognizer 时，需要向其传递 speechTranslationConfig 实例。配置对象提供语音服务验证请求所需的凭据。

如果使用设备的默认麦克风识别语音，则 TranslationRecognizer 实例应如下所示：

static async Task TranslateSpeechAsync()
{
    var speechTranslationConfig =
        SpeechTranslationConfig.FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    var fromLanguage = "en-US";
    var toLanguages = new List<string> { "it", "fr", "de" };
    speechTranslationConfig.SpeechRecognitionLanguage = fromLanguage;
    toLanguages.ForEach(speechTranslationConfig.AddTargetLanguage);

    using var translationRecognizer = new TranslationRecognizer(speechTranslationConfig);
}

如果要指定音频输入设备，则需要创建一个 AudioConfig 类实例并在初始化 audioConfig 时提供 TranslationRecognizer 参数。

小窍门

了解如何获取音频输入设备的设备 ID。

首先，引用 AudioConfig 对象，如下所示：

static async Task TranslateSpeechAsync()
{
    var speechTranslationConfig =
        SpeechTranslationConfig.FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    
    var fromLanguage = "en-US";
    var toLanguages = new List<string> { "it", "fr", "de" };
    speechTranslationConfig.SpeechRecognitionLanguage = fromLanguage;
    toLanguages.ForEach(speechTranslationConfig.AddTargetLanguage);

    using var audioConfig = AudioConfig.FromDefaultMicrophoneInput();
    using var translationRecognizer = new TranslationRecognizer(speechTranslationConfig, audioConfig);
}

如果要提供音频文件而不是使用麦克风，则仍需要提供 audioConfig 参数。但是，在创建 AudioConfig 类实例时，需要调用 FromDefaultMicrophoneInput（而不是调用 FromWavFileInput）并传递 filename 参数：

static async Task TranslateSpeechAsync()
{
    var speechTranslationConfig =
        SpeechTranslationConfig.FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    
    var fromLanguage = "en-US";
    var toLanguages = new List<string> { "it", "fr", "de" };
    speechTranslationConfig.SpeechRecognitionLanguage = fromLanguage;
    toLanguages.ForEach(speechTranslationConfig.AddTargetLanguage);

    using var audioConfig = AudioConfig.FromWavFileInput("YourAudioFile.wav");
    using var translationRecognizer = new TranslationRecognizer(speechTranslationConfig, audioConfig);
}

语音翻译

若要翻译语音，语音 SDK 依赖于麦克风或音频文件输入。语音识别发生在语音翻译之前。初始化所有对象后，调用识别一次函数并获取结果：

static async Task TranslateSpeechAsync()
{
    var speechTranslationConfig =
        SpeechTranslationConfig.FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    
    var fromLanguage = "en-US";
    var toLanguages = new List<string> { "it", "fr", "de" };
    speechTranslationConfig.SpeechRecognitionLanguage = fromLanguage;
    toLanguages.ForEach(speechTranslationConfig.AddTargetLanguage);

    using var translationRecognizer = new TranslationRecognizer(speechTranslationConfig);

    Console.Write($"Say something in '{fromLanguage}' and ");
    Console.WriteLine($"we'll translate into '{string.Join("', '", toLanguages)}'.\n");
    
    var result = await translationRecognizer.RecognizeOnceAsync();
    if (result.Reason == ResultReason.TranslatedSpeech)
    {
        Console.WriteLine($"Recognized: \"{result.Text}\":");
        foreach (var element in result.Translations)
        {
            Console.WriteLine($"    TRANSLATED into '{element.Key}': {element.Value}");
        }
    }
}

有关语音转文本的详细信息，请参阅语音识别基础知识。

基于事件的翻译

TranslationRecognizer 对象公开了 Recognizing 事件。该事件多次触发，并提供检索中间转换结果的机制。

注释

在没有源语言候选项的情况下使用多语言语音翻译时，中间翻译结果不可用。

以下示例将中间翻译结果输出到控制台：

using Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Audio;
using Microsoft.CognitiveServices.Speech.Translation;

public class Program
{
    private static readonly string SPEECH__SUBSCRIPTION__KEY = Environment.GetEnvironmentVariable(nameof(SPEECH__SUBSCRIPTION__KEY));
    private static readonly string SPEECH__SERVICE__REGION = Environment.GetEnvironmentVariable(nameof(SPEECH__SERVICE__REGION));

    public static void Main(string[] args)
    {
        try
        {
            EventTranslationAsync().Wait();
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex);
        }
    }

    static async Task EventTranslationAsync()
    {
        var speechTranslationConfig =
            SpeechTranslationConfig.FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

        var fromLanguage = "en-US";
        speechTranslationConfig.SpeechRecognitionLanguage = fromLanguage;
        speechTranslationConfig.AddTargetLanguage("de");
        speechTranslationConfig.AddTargetLanguage("fr");

        var stopTranslation = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);

        using (var audioInput = AudioConfig.FromWavFileInput(@"whatstheweatherlike.wav"))
        {
            using (var translationRecognizer = new TranslationRecognizer(speechTranslationConfig, audioInput))
            {
                // Subscribes to events.
                translationRecognizer.Recognizing += (s, e) =>
                {
                    Console.WriteLine($"RECOGNIZING in '{fromLanguage}': Text={e.Result.Text}");
                    foreach (var element in e.Result.Translations)
                    {
                        Console.WriteLine($"    TRANSLATING into '{element.Key}': {element.Value}");
                    }
                };

                translationRecognizer.Recognized += (s, e) => {
                    if (e.Result.Reason == ResultReason.TranslatedSpeech)
                    {
                        Console.WriteLine($"RECOGNIZED in '{fromLanguage}': Text={e.Result.Text}");
                        foreach (var element in e.Result.Translations)
                        {
                            Console.WriteLine($"    TRANSLATED into '{element.Key}': {element.Value}");
                        }
                    }
                    else if (e.Result.Reason == ResultReason.RecognizedSpeech)
                    {
                        Console.WriteLine($"RECOGNIZED: Text={e.Result.Text}");
                        Console.WriteLine($"    Speech not translated.");
                    }
                    else if (e.Result.Reason == ResultReason.NoMatch)
                    {
                        Console.WriteLine($"NOMATCH: Speech could not be recognized.");
                    }
                };

                translationRecognizer.Canceled += (s, e) =>
                {
                    Console.WriteLine($"CANCELED: Reason={e.Reason}");
                    if (e.Reason == CancellationReason.Error)
                    {
                        Console.WriteLine($"CANCELED: ErrorDetails={e.ErrorDetails}");
                        Console.WriteLine($"CANCELED: Did you set the speech resource key and region values?");
                    }
                    stopTranslation.TrySetResult(0);
                };

                translationRecognizer.SessionStopped += (s, e) =>
                {
                    Console.WriteLine("Session stopped.");
                    stopTranslation.TrySetResult(0);
                };

                // Starts continuous recognition. Uses StopContinuousRecognitionAsync() to stop recognition.
                Console.WriteLine("Start translation...");
                await translationRecognizer.StartContinuousRecognitionAsync();

                // Waits for completion.
                // Use Task.WaitAny to keep the task rooted.
                Task.WaitAny(new[] { stopTranslation.Task });

                // Stops translation.
                await translationRecognizer.StopContinuousRecognitionAsync();
            }
        }
    }
}

合成翻译

成功语音识别和翻译后，结果将包含字典中的所有翻译。 Translations 字典键是目标翻译语言，其值是已翻译的文本。已识别的语音可以被翻译，并以另一种语言合成出来，实现语音转语音功能。

基于事件的合成

TranslationRecognizer 对象公开了 Synthesizing 事件。该事件会触发多次，并提供一种机制以从翻译识别结果中检索合成音频。若要翻译为多种语言，请参阅手动合成。

通过分配 VoiceName 实例指定合成语音，并为 Synthesizing 事件提供事件处理程序，以获取音频。以下示例将翻译后的音频保存为.wav文件。

重要

基于事件的合成仅适用于单个翻译。请勿添加多种目标翻译语言。此外，VoiceName 值应与目标翻译语言相同。例如，"de" 可映射到 "de-DE-Hedda"。

static async Task TranslateSpeechAsync()
{
    var speechTranslationConfig =
        SpeechTranslationConfig.FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    
    var fromLanguage = "en-US";
    var toLanguage = "de";
    speechTranslationConfig.SpeechRecognitionLanguage = fromLanguage;
    speechTranslationConfig.AddTargetLanguage(toLanguage);

    speechTranslationConfig.VoiceName = "de-DE-Hedda";

    using var translationRecognizer = new TranslationRecognizer(speechTranslationConfig);

    translationRecognizer.Synthesizing += (_, e) =>
    {
        var audio = e.Result.GetAudio();
        Console.WriteLine($"Audio synthesized: {audio.Length:#,0} byte(s) {(audio.Length == 0 ? "(Complete)" : "")}");

        if (audio.Length > 0)
        {
            File.WriteAllBytes("YourAudioFile.wav", audio);
        }
    };

    Console.Write($"Say something in '{fromLanguage}' and ");
    Console.WriteLine($"we'll translate into '{toLanguage}'.\n");

    var result = await translationRecognizer.RecognizeOnceAsync();
    if (result.Reason == ResultReason.TranslatedSpeech)
    {
        Console.WriteLine($"Recognized: \"{result.Text}\"");
        Console.WriteLine($"Translated into '{toLanguage}': {result.Translations[toLanguage]}");
    }
}

手动合成

Translations 字典可用于从翻译文本合成音频。迭代每个翻译并进行综合。创建 SpeechSynthesizer 实例时，SpeechConfig 对象需要将其 SpeechSynthesisVoiceName 属性设为所需的语音。

以下示例翻译为五种语言。然后，将每个翻译合成为相应神经网络语言的音频文件。

static async Task TranslateSpeechAsync()
{
    var speechTranslationConfig =
        SpeechTranslationConfig.FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    var fromLanguage = "en-US";
    var toLanguages = new List<string> { "de", "en", "it", "pt", "zh-Hans" };
    speechTranslationConfig.SpeechRecognitionLanguage = fromLanguage;
    toLanguages.ForEach(speechTranslationConfig.AddTargetLanguage);

    using var translationRecognizer = new TranslationRecognizer(speechTranslationConfig);

    Console.Write($"Say something in '{fromLanguage}' and ");
    Console.WriteLine($"we'll translate into '{string.Join("', '", toLanguages)}'.\n");

    var result = await translationRecognizer.RecognizeOnceAsync();
    if (result.Reason == ResultReason.TranslatedSpeech)
    {
        var languageToVoiceMap = new Dictionary<string, string>
        {
            ["de"] = "de-DE-KatjaNeural",
            ["en"] = "en-US-AriaNeural",
            ["it"] = "it-IT-ElsaNeural",
            ["pt"] = "pt-BR-FranciscaNeural",
            ["zh-Hans"] = "zh-cn-XiaoxiaoNeural"
        };

        Console.WriteLine($"Recognized: \"{result.Text}\"");

        foreach (var (language, translation) in result.Translations)
        {
            Console.WriteLine($"Translated into '{language}': {translation}");

            var speechConfig =
                SpeechConfig.FromSubscription(
                    SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
            speechConfig.SpeechSynthesisVoiceName = languageToVoiceMap[language];

            using var audioConfig = AudioConfig.FromWavFileOutput($"{language}-translation.wav");
            using var speechSynthesizer = new SpeechSynthesizer(speechConfig, audioConfig);
            
            await speechSynthesizer.SpeakTextAsync(translation);
        }
    }
}

有关语音合成的详细信息，请参阅语音合成基础知识。

使用语言识别进行多语言翻译

在许多情况下，你可能不知道要指定的输入语言。使用语言识别，可以检测最多 10 种可能的输入语言，并自动将其翻译成目标语言。

以下示例预期检测到 en-US 或 zh-cn，因为它们是在 AutoDetectSourceLanguageConfig 中定义的。然后，语音将被转换为 de 和 fr，如对 AddTargetLanguage() 的调用中指定的那样。

speechTranslationConfig.AddTargetLanguage("de");
speechTranslationConfig.AddTargetLanguage("fr");
var autoDetectSourceLanguageConfig = AutoDetectSourceLanguageConfig.FromLanguages(new string[] { "en-US", "zh-cn" });
var translationRecognizer = new TranslationRecognizer(speechTranslationConfig, autoDetectSourceLanguageConfig, audioConfig);

有关完整的代码示例，请参阅语言识别。

不使用源语言候选语言的多语言语音翻译

多语言语音翻译实现了一种新的语音翻译技术，可解锁各种功能，包括没有指定的输入语言，以及在同一会话中处理语言切换。这些功能可实现可实施到产品中的新级别的语音翻译功能。

当前在语音翻译中使用语言 ID 时，必须从 v2 终结点创建SpeechTranslationConfig对象。将字符串“YourServiceRegion”替换为语音资源区域（如“chinanorth”）。将“YourSpeechResourceKey”替换为语音资源密钥。

var v2EndpointInString = String.Format("wss://{0}.stt.speech.azure.cn/speech/universal/v2", "YourServiceRegion");
var v2EndpointUrl = new Uri(v2EndpointInString);
var speechTranslationConfig = SpeechTranslationConfig.FromEndpoint(v2EndpointUrl, "YourSpeechResourceKey");

指定翻译目标语言。请替换成您选择的语言。可以添加更多行。

speechTranslationConfig.AddTargetLanguage("de");
speechTranslationConfig.AddTargetLanguage("fr");

使用多语言语音翻译的主要区别在于，无需指定源语言。这是因为服务会自动检测源语言。使用AutoDetectSourceLanguageConfig方法创建FromOpenRange对象，让服务知道你要使用无指定源语言的多语言语音翻译。

AutoDetectSourceLanguageConfig autoDetectSourceLanguageConfig = AutoDetectSourceLanguageConfig.FromOpenRange(); 
var translationRecognizer = new TranslationRecognizer(speechTranslationConfig, autoDetectSourceLanguageConfig, audioConfig);

有关语音 SDK 的完整代码示例，请参阅 GitHub 上的语音翻译示例。

参考文档 | 包（NuGet） | 在 GitHub 上的更多示例

本作指南介绍如何识别人工语音并将其翻译为其他语言。

有关以下内容的详细信息，请参阅语音翻译概述：

将语音转换为文本
将语音翻译为多个目标语言
进行直接语音到语音翻译

敏感数据和环境变量

本文中的示例源代码取决于用于存储敏感数据的环境变量，例如语音资源的密钥和区域。 C++ 代码文件包含从主机环境变量（SPEECH__SUBSCRIPTION__KEY 和 SPEECH__SERVICE__REGION）分配的两个字符串值。这两个字段都属于类的作用域，因此可以在类的方法内部访问这些字段。

auto SPEECH__SUBSCRIPTION__KEY = getenv("SPEECH__SUBSCRIPTION__KEY");
auto SPEECH__SERVICE__REGION = getenv("SPEECH__SERVICE__REGION");

有关环境变量的详细信息，请参阅环境变量和应用程序配置。

重要

有关 AI 服务安全性的详细信息，请参阅对 Azure AI 服务进行请求身份验证。

创建语音翻译配置

小窍门

无论你是执行语音识别、语音合成、翻译还是意向识别，你都会始终创建配置。

可以通过以下几种方式初始化 SpeechTranslationConfig：

在订阅中传入密钥和关联的区域。
使用终结点：传入语音服务终结点。密钥或授权令牌是可选的。
使用主机：传入主机地址。密钥或授权令牌是可选的。
使用授权令牌：传入授权令牌和关联的区域。

让我们看看如何使用密钥和区域创建 SpeechTranslationConfig 实例。获取 Azure 门户中的语音资源密钥和区域。

auto SPEECH__SUBSCRIPTION__KEY = getenv("SPEECH__SUBSCRIPTION__KEY");
auto SPEECH__SERVICE__REGION = getenv("SPEECH__SERVICE__REGION");

void translateSpeech() {
    auto speechTranslationConfig =
        SpeechTranslationConfig::FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
}

int main(int argc, char** argv) {
    setlocale(LC_ALL, "");
    translateSpeech();
    return 0;
}

更改源语言

语音翻译的一个常见任务是指定输入（或源）语言。以下示例演示如何将输入语言更改为意大利语。在代码中，通过调用 SpeechTranslationConfig 方法与 SetSpeechRecognitionLanguage 实例交互。

void translateSpeech() {
    auto speechTranslationConfig =
        SpeechTranslationConfig::FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    // Source (input) language
    speechTranslationConfig->SetSpeechRecognitionLanguage("it-IT");
}

SpeechRecognitionLanguage 属性需要语言区域设置格式字符串。请参阅支持的语音翻译区域设置列表。

添加翻译语言

语音翻译的另一个常见任务是指定目标翻译语言。至少需要一个，但支持多个。以下代码片段将法语和德语设置为翻译语言目标：

void translateSpeech() {
    auto speechTranslationConfig =
        SpeechTranslationConfig::FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    speechTranslationConfig->SetSpeechRecognitionLanguage("it-IT");

    speechTranslationConfig->AddTargetLanguage("fr");
    speechTranslationConfig->AddTargetLanguage("de");
}

每次调用 AddTargetLanguage 时，都会指定一种新的目标翻译语言。换句话说，从源语言识别语音时，每个目标翻译都可用作生成的翻译作的一部分。

初始化翻译识别器

创建 SpeechTranslationConfig 实例后，下一步是初始化 TranslationRecognizer。初始化 TranslationRecognizer 时，需要向其传递 translationConfig 实例。配置对象提供语音服务验证请求所需的凭据。

如果使用设备的默认麦克风识别语音，则 TranslationRecognizer 应如下所示：

void translateSpeech() {
    auto speechTranslationConfig =
        SpeechTranslationConfig::FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    auto fromLanguage = "en-US";
    auto toLanguages = { "it", "fr", "de" };
    speechTranslationConfig->SetSpeechRecognitionLanguage(fromLanguage);
    for (auto language : toLanguages) {
        speechTranslationConfig->AddTargetLanguage(language);
    }

    auto translationRecognizer = TranslationRecognizer::FromConfig(speechTranslationConfig);
}

如果要指定音频输入设备，则需要创建一个 AudioConfig 类实例并在初始化 audioConfig 时提供 TranslationRecognizer 参数。

小窍门

了解如何获取音频输入设备的设备 ID。

首先，引用 AudioConfig 对象，如下所示：

void translateSpeech() {
    auto speechTranslationConfig =
        SpeechTranslationConfig::FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    auto fromLanguage = "en-US";
    auto toLanguages = { "it", "fr", "de" };
    speechTranslationConfig->SetSpeechRecognitionLanguage(fromLanguage);
    for (auto language : toLanguages) {
        speechTranslationConfig->AddTargetLanguage(language);
    }

    auto audioConfig = AudioConfig::FromDefaultMicrophoneInput();
    auto translationRecognizer = TranslationRecognizer::FromConfig(speechTranslationConfig, audioConfig);
}

void translateSpeech() {
    auto speechTranslationConfig =
        SpeechTranslationConfig::FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    auto fromLanguage = "en-US";
    auto toLanguages = { "it", "fr", "de" };
    speechTranslationConfig->SetSpeechRecognitionLanguage(fromLanguage);
    for (auto language : toLanguages) {
        speechTranslationConfig->AddTargetLanguage(language);
    }

    auto audioConfig = AudioConfig::FromWavFileInput("YourAudioFile.wav");
    auto translationRecognizer = TranslationRecognizer::FromConfig(speechTranslationConfig, audioConfig);
}

语音翻译

若要翻译语音，语音 SDK 依赖于麦克风或音频文件输入。语音识别发生在语音翻译之前。初始化所有对象后，调用识别一次函数并获取结果：

void translateSpeech() {
    auto speechTranslationConfig =
        SpeechTranslationConfig::FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    string fromLanguage = "en-US";
    string toLanguages[3] = { "it", "fr", "de" };
    speechTranslationConfig->SetSpeechRecognitionLanguage(fromLanguage);
    for (auto language : toLanguages) {
        speechTranslationConfig->AddTargetLanguage(language);
    }

    auto translationRecognizer = TranslationRecognizer::FromConfig(speechTranslationConfig);
    cout << "Say something in '" << fromLanguage << "' and we'll translate...\n";

    auto result = translationRecognizer->RecognizeOnceAsync().get();
    if (result->Reason == ResultReason::TranslatedSpeech)
    {
        cout << "Recognized: \"" << result->Text << "\"" << std::endl;
        for (auto pair : result->Translations)
        {
            auto language = pair.first;
            auto translation = pair.second;
            cout << "Translated into '" << language << "': " << translation << std::endl;
        }
    }
}

有关语音转文本的详细信息，请参阅语音识别基础知识。

基于事件的翻译

TranslationRecognizer 对象公开了 Recognizing 事件。该事件多次触发，并提供检索中间转换结果的机制。

注释

使用多语言语音翻译时，中间翻译结果不可用。

以下示例将中间翻译结果输出到控制台：

void translateSpeechContinuous() {
    auto speechTranslationConfig =
        SpeechTranslationConfig::FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    auto fromLanguage = "en-US";
    auto toLanguage = "de";
    speechTranslationConfig->SetSpeechRecognitionLanguage(fromLanguage);
    speechTranslationConfig->AddTargetLanguage(toLanguage);

    auto audioConfig = AudioConfig::FromWavFileInput("whatstheweatherlike.wav");
    auto translationRecognizer = TranslationRecognizer::FromConfig(speechTranslationConfig, audioConfig);

    // Promise for synchronization of recognition end.
    promise<void> recognitionEnd;

    // Subscribes to events.
    translationRecognizer->Recognizing.Connect([&fromLanguage](const TranslationRecognitionEventArgs& e) {
        cout << "RECOGNIZING in '" << fromLanguage << "': Text=" << e.Result->Text << std::endl;
        for (const auto& pair : e.Result->Translations) {
            cout << "    TRANSLATING into '" << pair.first << "': " << pair.second << std::endl;
        }
    });

    translationRecognizer->Recognized.Connect([&fromLanguage](const TranslationRecognitionEventArgs& e) {
        if (e.Result->Reason == ResultReason::TranslatedSpeech) {
            cout << "RECOGNIZED in '" << fromLanguage << "': Text=" << e.Result->Text << std::endl;
            for (const auto& pair : e.Result->Translations) {
                cout << "    TRANSLATED into '" << pair.first << "': " << pair.second << std::endl;
            }
        }
        else if (e.Result->Reason == ResultReason::RecognizedSpeech) {
            cout << "RECOGNIZED: Text=" << e.Result->Text << std::endl;
            cout << "    Speech not translated." << std::endl;
        }
        else if (e.Result->Reason == ResultReason::NoMatch) {
            cout << "NOMATCH: Speech could not be recognized." << std::endl;
        }
    });

    translationRecognizer->Canceled.Connect([&recognitionEnd](const TranslationRecognitionCanceledEventArgs& e) {
        cout << "CANCELED: Reason=" << (int)e.Reason << std::endl;
        if (e.Reason == CancellationReason::Error) {
            cout << "CANCELED: ErrorDetails=" << e.ErrorDetails << std::endl;
        }
        recognitionEnd.set_value();
    });

    translationRecognizer->SessionStopped.Connect([&recognitionEnd](const SessionEventArgs& e) {
        cout << "SESSION STOPPED" << std::endl;
        recognitionEnd.set_value();
    });

    // Start continuous recognition
    cout << "Start translation..." << std::endl;
    translationRecognizer->StartContinuousRecognitionAsync().get();

    // Wait for completion
    recognitionEnd.get_future().get();

    // Stop recognition
    translationRecognizer->StopContinuousRecognitionAsync().get();
}

合成翻译

基于事件的合成

通过分配 SetVoiceName 实例指定合成语音，并为 Synthesizing 事件提供事件处理程序，以获取音频。以下示例将翻译后的音频保存为.wav文件。

重要

基于事件的合成仅适用于单个翻译。请勿添加多种目标翻译语言。此外，SetVoiceName 值应与目标翻译语言相同。例如，"de" 可映射到 "de-DE-Hedda"。

void translateSpeech() {
    auto speechTranslationConfig =
        SpeechTranslationConfig::FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    auto fromLanguage = "en-US";
    auto toLanguage = "de";
    speechTranslationConfig->SetSpeechRecognitionLanguage(fromLanguage);
    speechTranslationConfig->AddTargetLanguage(toLanguage);

    speechTranslationConfig->SetVoiceName("de-DE-Hedda");

    auto translationRecognizer = TranslationRecognizer::FromConfig(speechTranslationConfig);
    translationRecognizer->Synthesizing.Connect([](const TranslationSynthesisEventArgs& e)
        {
            auto audio = e.Result->Audio;
            auto size = audio.size();
            cout << "Audio synthesized: " << size << " byte(s)" << (size == 0 ? "(COMPLETE)" : "") << std::endl;

            if (size > 0) {
                ofstream file("translation.wav", ios::out | ios::binary);
                auto audioData = audio.data();
                file.write((const char*)audioData, sizeof(audio[0]) * size);
                file.close();
            }
        });

    cout << "Say something in '" << fromLanguage << "' and we'll translate...\n";

    auto result = translationRecognizer->RecognizeOnceAsync().get();
    if (result->Reason == ResultReason::TranslatedSpeech)
    {
        cout << "Recognized: \"" << result->Text << "\"" << std::endl;
        for (auto pair : result->Translations)
        {
            auto language = pair.first;
            auto translation = pair.second;
            cout << "Translated into '" << language << "': " << translation << std::endl;
        }
    }
}

手动合成

Translations 字典可用于从翻译文本合成音频。迭代每个翻译并进行综合。创建 SpeechSynthesizer 实例时，SpeechConfig 对象需要将其 SetSpeechSynthesisVoiceName 属性设为所需的语音。

以下示例翻译为五种语言。然后，将每个翻译合成为相应神经网络语言的音频文件。

void translateSpeech() {
    auto speechTranslationConfig =
        SpeechTranslationConfig::FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    auto fromLanguage = "en-US";
    auto toLanguages = { "de", "en", "it", "pt", "zh-Hans" };
    speechTranslationConfig->SetSpeechRecognitionLanguage(fromLanguage);
    for (auto language : toLanguages) {
        speechTranslationConfig->AddTargetLanguage(language);
    }

    auto translationRecognizer = TranslationRecognizer::FromConfig(speechTranslationConfig);

    cout << "Say something in '" << fromLanguage << "' and we'll translate...\n";

    auto result = translationRecognizer->RecognizeOnceAsync().get();
    if (result->Reason == ResultReason::TranslatedSpeech)
    {
        map<string, string> languageToVoiceMap;
        languageToVoiceMap["de"] = "de-DE-KatjaNeural";
        languageToVoiceMap["en"] = "en-US-AriaNeural";
        languageToVoiceMap["it"] = "it-IT-ElsaNeural";
        languageToVoiceMap["pt"] = "pt-BR-FranciscaNeural";
        languageToVoiceMap["zh-Hans"] = "zh-cn-XiaoxiaoNeural";

        cout << "Recognized: \"" << result->Text << "\"" << std::endl;
        for (auto pair : result->Translations)
        {
            auto language = pair.first;
            auto translation = pair.second;
            cout << "Translated into '" << language << "': " << translation << std::endl;

            auto speechConfig =
                SpeechConfig::FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
            speechConfig->SetSpeechSynthesisVoiceName(languageToVoiceMap[language]);

            auto audioConfig = AudioConfig::FromWavFileOutput(language + "-translation.wav");
            auto speechSynthesizer = SpeechSynthesizer::FromConfig(speechConfig, audioConfig);

            speechSynthesizer->SpeakTextAsync(translation).get();
        }
    }
}

有关语音合成的详细信息，请参阅语音合成基础知识。

使用语言识别进行多语言翻译

在许多情况下，你可能不知道要指定的输入语言。使用语言识别，可以检测最多 10 种可能的输入语言，并自动将其翻译成目标语言。

speechTranslationConfig->AddTargetLanguage("de");
speechTranslationConfig->AddTargetLanguage("fr");
auto autoDetectSourceLanguageConfig = AutoDetectSourceLanguageConfig::FromLanguages({ "en-US", "zh-cn" });
auto translationRecognizer = TranslationRecognizer::FromConfig(speechTranslationConfig, autoDetectSourceLanguageConfig, audioConfig);

有关完整的代码示例，请参阅语言识别。

参考文档 | Package （Go） | GitHub 上的附加示例

本作指南介绍如何识别人工语音并将其翻译为其他语言。

有关以下内容的详细信息，请参阅语音翻译概述：

将语音转换为文本
将语音翻译为多个目标语言
进行直接语音到语音翻译

敏感数据和环境变量

本文中的示例源代码取决于用于存储敏感数据的环境变量，例如语音资源的密钥和区域。 Go 代码文件包含两个值，这些值是从主机的环境变量中分配的： SPEECH_KEY 和 SPEECH_REGION。这两个变量都在包范围内，因此可以在包的函数中访问它们：

speechKey := os.Getenv("SPEECH_KEY")
speechRegion := os.Getenv("SPEECH_REGION")

有关环境变量的详细信息，请参阅环境变量和应用程序配置。

重要

有关 AI 服务安全性的详细信息，请参阅对 Azure AI 服务进行请求身份验证。

创建语音翻译配置

小窍门

无论你是执行语音识别、语音合成、翻译还是意向识别，你都会始终创建配置。

可以通过以下几种方式初始化 SpeechTranslationConfig 实例：

在订阅中传入密钥和关联的区域。
使用终结点：传入语音服务终结点。密钥或授权令牌是可选的。
使用主机：传入主机地址。密钥或授权令牌是可选的。
使用授权令牌：传入授权令牌和关联的区域。

让我们看看如何使用密钥和区域创建 SpeechTranslationConfig 实例。获取 Azure 门户中的语音资源密钥和区域。

import (
    "fmt"
    "os"

    "github.com/Microsoft/cognitive-services-speech-sdk-go/audio"
    "github.com/Microsoft/cognitive-services-speech-sdk-go/speech"
)

func translateSpeech() {
    speechKey := os.Getenv("SPEECH_KEY")
    speechRegion := os.Getenv("SPEECH_REGION")

    translationConfig, err := speech.NewSpeechTranslationConfigFromSubscription(speechKey, speechRegion)
    if err != nil {
        fmt.Println("Error creating translation config:", err)
        return
    }
    defer translationConfig.Close()
}

更改源语言

语音翻译的一个常见任务是指定输入（或源）语言。以下示例演示如何将输入语言更改为意大利语。在代码中，通过调用 SpeechTranslationConfig 方法与 SetSpeechRecognitionLanguage 实例交互：

func translateSpeech() {
    speechKey := os.Getenv("SPEECH_KEY")
    speechRegion := os.Getenv("SPEECH_REGION")

    translationConfig, err := speech.NewSpeechTranslationConfigFromSubscription(speechKey, speechRegion)
    if err != nil {
        fmt.Println("Error creating translation config:", err)
        return
    }
    defer translationConfig.Close()

    // Source (input) language
    translationConfig.SetSpeechRecognitionLanguage("it-IT")
}

该SetSpeechRecognitionLanguage方法要求提供一个语言-区域格式字符串。请参阅支持的语音翻译区域设置列表。

添加翻译语言

语音翻译的另一个常见任务是指定目标翻译语言。至少需要一个，但支持多个。以下代码片段将法语和德语设置为翻译语言目标：

func translateSpeech() {
    speechKey := os.Getenv("SPEECH_KEY")
    speechRegion := os.Getenv("SPEECH_REGION")

    translationConfig, err := speech.NewSpeechTranslationConfigFromSubscription(speechKey, speechRegion)
    if err != nil {
        fmt.Println("Error creating translation config:", err)
        return
    }
    defer translationConfig.Close()

    translationConfig.SetSpeechRecognitionLanguage("it-IT")

    // Translate to languages. See https://aka.ms/speech/sttt-languages
    translationConfig.AddTargetLanguage("fr")
    translationConfig.AddTargetLanguage("de")
}

每次调用 AddTargetLanguage 时，都会指定一种新的目标翻译语言。换句话说，从源语言识别语音时，每个目标翻译都可用作生成的翻译作的一部分。

初始化翻译识别器

如果使用设备的默认麦克风识别语音，则 TranslationRecognizer 应如下所示：

func translateSpeech() {
    speechKey := os.Getenv("SPEECH_KEY")
    speechRegion := os.Getenv("SPEECH_REGION")

    translationConfig, err := speech.NewSpeechTranslationConfigFromSubscription(speechKey, speechRegion)
    if err != nil {
        fmt.Println("Error creating translation config:", err)
        return
    }
    defer translationConfig.Close()

    fromLanguage := "en-US"
    toLanguages := []string{"it", "fr", "de"}

    translationConfig.SetSpeechRecognitionLanguage(fromLanguage)
    for _, language := range toLanguages {
        translationConfig.AddTargetLanguage(language)
    }

    audioConfig, err := audio.NewAudioConfigFromDefaultMicrophoneInput()
    if err != nil {
        fmt.Println("Error creating audio config:", err)
        return
    }
    defer audioConfig.Close()

    translationRecognizer, err := speech.NewTranslationRecognizerFromConfig(translationConfig, audioConfig)
    if err != nil {
        fmt.Println("Error creating translation recognizer:", err)
        return
    }
    defer translationRecognizer.Close()
}

如果要提供音频文件而不是使用麦克风，则仍需要提供 audioConfig 参数。但是，在创建 AudioConfig 实例而不是调用 NewAudioConfigFromDefaultMicrophoneInput时，调用 NewAudioConfigFromWavFileInput 并传递文件名：

audioConfig, err := audio.NewAudioConfigFromWavFileInput("YourAudioFile.wav")
if err != nil {
    fmt.Println("Error creating audio config:", err)
    return
}
defer audioConfig.Close()

语音翻译

若要翻译语音，语音 SDK 依赖于麦克风或音频文件输入。语音识别发生在语音翻译之前。初始化所有对象后，调用识别一次函数并获取结果：

package main

import (
    "fmt"
    "os"

    "github.com/Microsoft/cognitive-services-speech-sdk-go/audio"
    "github.com/Microsoft/cognitive-services-speech-sdk-go/speech"
)

func main() {
    speechKey := os.Getenv("SPEECH_KEY")
    speechRegion := os.Getenv("SPEECH_REGION")

    translationConfig, err := speech.NewSpeechTranslationConfigFromSubscription(speechKey, speechRegion)
    if err != nil {
        fmt.Println("Error creating translation config:", err)
        return
    }
    defer translationConfig.Close()

    fromLanguage := "en-US"
    toLanguages := []string{"it", "fr", "de"}

    translationConfig.SetSpeechRecognitionLanguage(fromLanguage)
    for _, language := range toLanguages {
        translationConfig.AddTargetLanguage(language)
    }

    audioConfig, err := audio.NewAudioConfigFromDefaultMicrophoneInput()
    if err != nil {
        fmt.Println("Error creating audio config:", err)
        return
    }
    defer audioConfig.Close()

    translationRecognizer, err := speech.NewTranslationRecognizerFromConfig(translationConfig, audioConfig)
    if err != nil {
        fmt.Println("Error creating translation recognizer:", err)
        return
    }
    defer translationRecognizer.Close()

    fmt.Printf("Say something in '%s' and we'll translate...\n", fromLanguage)

    outcome := <-translationRecognizer.RecognizeOnceAsync()
    if outcome.Error != nil {
        fmt.Println("Recognition error:", outcome.Error)
        return
    }

    result := outcome.Result
    defer result.Close()

    translations := result.GetTranslations()
    fmt.Printf("Recognized: \"%s\"\n", result.Text)
    for lang, translation := range translations {
        fmt.Printf("Translated into '%s': %s\n", lang, translation)
    }
}

有关语音转文本的详细信息，请参阅语音识别基础知识。

基于事件的翻译

上一个示例使用单次处理翻译，用于翻译单个话语。还可以对长时间运行的会话使用基于事件的翻译。基于事件的翻译要求你订阅事件才能接收翻译结果。

注释

使用多语言语音翻译时，中间翻译结果不可用。

以下示例演示如何使用基于事件的转换：

package main

import (
    "bufio"
    "fmt"
    "os"

    "github.com/Microsoft/cognitive-services-speech-sdk-go/audio"
    "github.com/Microsoft/cognitive-services-speech-sdk-go/speech"
)

func main() {
    speechKey := os.Getenv("SPEECH_KEY")
    speechRegion := os.Getenv("SPEECH_REGION")

    translationConfig, err := speech.NewSpeechTranslationConfigFromSubscription(speechKey, speechRegion)
    if err != nil {
        fmt.Println("Error creating translation config:", err)
        return
    }
    defer translationConfig.Close()

    fromLanguage := "en-US"
    toLanguages := []string{"de", "fr"}

    translationConfig.SetSpeechRecognitionLanguage(fromLanguage)
    for _, language := range toLanguages {
        translationConfig.AddTargetLanguage(language)
    }

    audioConfig, err := audio.NewAudioConfigFromDefaultMicrophoneInput()
    if err != nil {
        fmt.Println("Error creating audio config:", err)
        return
    }
    defer audioConfig.Close()

    translationRecognizer, err := speech.NewTranslationRecognizerFromConfig(translationConfig, audioConfig)
    if err != nil {
        fmt.Println("Error creating translation recognizer:", err)
        return
    }
    defer translationRecognizer.Close()

    // Subscribe to events
    translationRecognizer.Recognizing(func(event speech.TranslationRecognitionEventArgs) {
        fmt.Printf("RECOGNIZING: %s\n", event.Result.Text)
    })

    translationRecognizer.Recognized(func(event speech.TranslationRecognitionEventArgs) {
        if event.Result.Reason == speech.ResultReason.TranslatedSpeech {
            fmt.Printf("RECOGNIZED: %s\n", event.Result.Text)
            for lang, translation := range event.Result.GetTranslations() {
                fmt.Printf("TRANSLATED into '%s': %s\n", lang, translation)
            }
        }
    })

    translationRecognizer.Canceled(func(event speech.TranslationRecognitionCanceledEventArgs) {
        fmt.Printf("CANCELED: Reason=%d\n", event.Reason)
        if event.Reason == speech.CancellationReason.Error {
            fmt.Printf("CANCELED: ErrorDetails=%s\n", event.ErrorDetails)
        }
    })

    translationRecognizer.SessionStopped(func(event speech.SessionEventArgs) {
        fmt.Println("Session stopped.")
    })

    // Start continuous recognition
    err = <-translationRecognizer.StartContinuousRecognitionAsync()
    if err != nil {
        fmt.Println("Error starting continuous recognition:", err)
        return
    }

    fmt.Println("Event based translation started. Press Enter to stop...")
    bufio.NewReader(os.Stdin).ReadBytes('\n')

    // Stop continuous recognition
    err = <-translationRecognizer.StopContinuousRecognitionAsync()
    if err != nil {
        fmt.Println("Error stopping continuous recognition:", err)
        return
    }
}

合成翻译

成功语音识别和翻译后，结果将包含地图中的所有翻译。该方法GetTranslations()返回一个映射，其中键是目标翻译语言，值是翻译后的文本。已识别的语音可以被翻译，并以另一种语言合成出来，实现语音转语音功能。

基于事件的合成

该 TranslationRecognizer 对象公开一个 Synthesizing 回调。该事件会触发多次，并提供一种机制以从翻译识别结果中检索合成音频。若要翻译为多种语言，请参阅手动合成。

通过对配置调用 SetVoiceName 方法来指定合成语音，并为事件提供一个回调函数 Synthesizing 来获取音频。以下示例将翻译后的音频保存为.wav文件。

重要

基于事件的合成仅适用于单个翻译。请勿添加多种目标翻译语言。此外，SetVoiceName 值应与目标翻译语言相同。例如，"de" 可映射到 "de-DE-Hedda"。

package main

import (
    "fmt"
    "os"

    "github.com/Microsoft/cognitive-services-speech-sdk-go/audio"
    "github.com/Microsoft/cognitive-services-speech-sdk-go/speech"
)

func main() {
    speechKey := os.Getenv("SPEECH_KEY")
    speechRegion := os.Getenv("SPEECH_REGION")

    translationConfig, err := speech.NewSpeechTranslationConfigFromSubscription(speechKey, speechRegion)
    if err != nil {
        fmt.Println("Error creating translation config:", err)
        return
    }
    defer translationConfig.Close()

    fromLanguage := "en-US"
    toLanguage := "de"

    translationConfig.SetSpeechRecognitionLanguage(fromLanguage)
    translationConfig.AddTargetLanguage(toLanguage)

    // See: https://aka.ms/speech/sdkregion#standard-and-neural-voices
    translationConfig.SetVoiceName("de-DE-Hedda")

    audioConfig, err := audio.NewAudioConfigFromDefaultMicrophoneInput()
    if err != nil {
        fmt.Println("Error creating audio config:", err)
        return
    }
    defer audioConfig.Close()

    translationRecognizer, err := speech.NewTranslationRecognizerFromConfig(translationConfig, audioConfig)
    if err != nil {
        fmt.Println("Error creating translation recognizer:", err)
        return
    }
    defer translationRecognizer.Close()

    translationRecognizer.Synthesizing(func(event speech.TranslationSynthesisEventArgs) {
        audioData := event.Result.GetAudio()
        size := len(audioData)
        fmt.Printf("Audio synthesized: %d byte(s) %s\n", size, map[bool]string{true: "(COMPLETE)", false: ""}[size == 0])

        if size > 0 {
            file, err := os.Create("translation.wav")
            if err != nil {
                fmt.Println("Error creating file:", err)
                return
            }
            defer file.Close()
            file.Write(audioData)
        }
    })

    fmt.Printf("Say something in '%s' and we'll translate to '%s'...\n", fromLanguage, toLanguage)

    outcome := <-translationRecognizer.RecognizeOnceAsync()
    if outcome.Error != nil {
        fmt.Println("Recognition error:", outcome.Error)
        return
    }

    result := outcome.Result
    defer result.Close()

    if result.Reason == speech.ResultReason.TranslatedSpeech {
        fmt.Printf("Recognized: \"%s\"\n", result.Text)
        translations := result.GetTranslations()
        fmt.Printf("Translated into '%s': %s\n", toLanguage, translations[toLanguage])
    }
}

手动合成

可以使用翻译映射从翻译文本合成音频。迭代每个翻译并进行综合。在创建 SpeechSynthesizer 实例时，SpeechConfig 对象需要通过所需的语音调用其 SetSpeechSynthesisVoiceName 方法。

以下示例翻译为五种语言。然后，将每个翻译合成为相应神经网络语言的音频文件。

package main

import (
    "fmt"
    "os"

    "github.com/Microsoft/cognitive-services-speech-sdk-go/audio"
    "github.com/Microsoft/cognitive-services-speech-sdk-go/speech"
)

func main() {
    speechKey := os.Getenv("SPEECH_KEY")
    speechRegion := os.Getenv("SPEECH_REGION")

    translationConfig, err := speech.NewSpeechTranslationConfigFromSubscription(speechKey, speechRegion)
    if err != nil {
        fmt.Println("Error creating translation config:", err)
        return
    }
    defer translationConfig.Close()

    fromLanguage := "en-US"
    toLanguages := []string{"de", "fr", "it", "pt", "zh-Hans"}

    translationConfig.SetSpeechRecognitionLanguage(fromLanguage)
    for _, language := range toLanguages {
        translationConfig.AddTargetLanguage(language)
    }

    audioConfig, err := audio.NewAudioConfigFromDefaultMicrophoneInput()
    if err != nil {
        fmt.Println("Error creating audio config:", err)
        return
    }
    defer audioConfig.Close()

    translationRecognizer, err := speech.NewTranslationRecognizerFromConfig(translationConfig, audioConfig)
    if err != nil {
        fmt.Println("Error creating translation recognizer:", err)
        return
    }
    defer translationRecognizer.Close()

    fmt.Println("Say something...")

    outcome := <-translationRecognizer.RecognizeOnceAsync()
    if outcome.Error != nil {
        fmt.Println("Recognition error:", outcome.Error)
        return
    }

    result := outcome.Result
    defer result.Close()

    if result.Reason == speech.ResultReason.TranslatedSpeech {
        languageToVoiceMap := map[string]string{
            "de":      "de-DE-KatjaNeural",
            "fr":      "fr-FR-DeniseNeural",
            "it":      "it-IT-ElsaNeural",
            "pt":      "pt-BR-FranciscaNeural",
            "zh-Hans": "zh-cn-XiaoxiaoNeural",
        }

        fmt.Printf("Recognized: \"%s\"\n", result.Text)
        translations := result.GetTranslations()

        for language, translation := range translations {
            fmt.Printf("Translated into '%s': %s\n", language, translation)

            speechConfig, err := speech.NewSpeechConfigFromSubscription(speechKey, speechRegion)
            if err != nil {
                fmt.Println("Error creating speech config:", err)
                continue
            }

            speechConfig.SetSpeechSynthesisVoiceName(languageToVoiceMap[language])

            outputFile := fmt.Sprintf("%s-translation.wav", language)
            audioOutput, err := audio.NewAudioConfigFromWavFileOutput(outputFile)
            if err != nil {
                fmt.Println("Error creating audio output config:", err)
                speechConfig.Close()
                continue
            }

            synthesizer, err := speech.NewSpeechSynthesizerFromConfig(speechConfig, audioOutput)
            if err != nil {
                fmt.Println("Error creating synthesizer:", err)
                audioOutput.Close()
                speechConfig.Close()
                continue
            }

            <-synthesizer.SpeakTextAsync(translation)

            synthesizer.Close()
            audioOutput.Close()
            speechConfig.Close()
        }
    }
}

有关语音合成的详细信息，请参阅语音合成基础知识。

使用语言识别进行多语言翻译

在许多情况下，你可能不知道要指定的输入语言。使用语言识别，可以检测最多 10 种可能的输入语言，并自动将其翻译成目标语言。

translationConfig.AddTargetLanguage("de")
translationConfig.AddTargetLanguage("fr")
autoDetectSourceLanguageConfig, err := speech.NewAutoDetectSourceLanguageConfigFromLanguages([]string{"en-US", "zh-cn"})
if err != nil {
    fmt.Println("Error creating auto detect config:", err)
    return
}
defer autoDetectSourceLanguageConfig.Close()

translationRecognizer, err := speech.NewTranslationRecognizerFromAutoDetectSourceLangConfig(translationConfig, autoDetectSourceLanguageConfig, audioConfig)

有关完整的代码示例，请参阅语言识别。

清理资源

可以使用 Azure 门户或 Azure命令行接口（CLI）删除创建的语音资源。

参考文档 | GitHub 上的更多示例

本作指南介绍如何识别人工语音并将其翻译为其他语言。

有关以下内容的详细信息，请参阅语音翻译概述：

将语音转换为文本
将语音翻译为多个目标语言
进行直接语音到语音翻译

敏感数据和环境变量

本文中的示例源代码取决于用于存储敏感数据的环境变量，例如语音资源的密钥和区域。 Java代码文件包含两个从主机环境变量分配的 static final String 值：SPEECH__SUBSCRIPTION__KEY 和 SPEECH__SERVICE__REGION。这两个字段都属于类的作用域，因此可以在类的方法内部访问这些字段。

public class App {

    static final String SPEECH__SUBSCRIPTION__KEY = System.getenv("SPEECH__SUBSCRIPTION__KEY");
    static final String SPEECH__SERVICE__REGION = System.getenv("SPEECH__SERVICE__REGION");

    public static void main(String[] args) { }
}

有关环境变量的详细信息，请参阅环境变量和应用程序配置。

重要

有关 AI 服务安全性的详细信息，请参阅对 Azure AI 服务进行请求身份验证。

创建语音翻译配置

小窍门

无论你是执行语音识别、语音合成、翻译还是意向识别，你都会始终创建配置。

可以通过以下几种方式初始化 SpeechTranslationConfig 实例：

在订阅中传入密钥和关联的区域。
使用终结点：传入语音服务终结点。密钥或授权令牌是可选的。
使用主机：传入主机地址。密钥或授权令牌是可选的。
使用授权令牌：传入授权令牌和关联的区域。

让我们看看如何使用密钥和区域创建 SpeechTranslationConfig 实例。获取 Azure 门户中的语音资源密钥和区域。

public class App {

    static final String SPEECH__SUBSCRIPTION__KEY = System.getenv("SPEECH__SERVICE__KEY");
    static final String SPEECH__SERVICE__REGION = System.getenv("SPEECH__SERVICE__REGION");

    public static void main(String[] args) {
        try {
            translateSpeech();
            System.exit(0);
        } catch (Exception ex) {
            System.out.println(ex);
            System.exit(1);
        }
    }

    static void translateSpeech() {
        SpeechTranslationConfig speechTranslationConfig = SpeechTranslationConfig.fromSubscription(
            SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    }
}

更改源语言

语音翻译的一个常见任务是指定输入（或源）语言。以下示例演示如何将输入语言更改为意大利语。在代码中，通过调用 SpeechTranslationConfig 方法与 setSpeechRecognitionLanguage 实例交互：

static void translateSpeech() {
    SpeechTranslationConfig speechTranslationConfig = SpeechTranslationConfig.fromSubscription(
        SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    
    // Source (input) language
    speechTranslationConfig.setSpeechRecognitionLanguage("it-IT");
}

setSpeechRecognitionLanguage 函数需要语言区域设置格式字符串。请参阅支持的语音翻译区域设置列表。

添加翻译语言

语音翻译的另一个常见任务是指定目标翻译语言。至少需要一个，但支持多个。以下代码片段将法语和德语设置为翻译语言目标：

static void translateSpeech() {
    SpeechTranslationConfig speechTranslationConfig = SpeechTranslationConfig.fromSubscription(
        SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    
    speechTranslationConfig.setSpeechRecognitionLanguage("it-IT");

    // Translate to languages. See https://aka.ms/speech/sttt-languages
    speechTranslationConfig.addTargetLanguage("fr");
    speechTranslationConfig.addTargetLanguage("de");
}

每次调用 addTargetLanguage 时，都会指定一种新的目标翻译语言。换句话说，从源语言识别语音时，每个目标翻译都可用作生成的翻译作的一部分。

初始化翻译识别器

如果使用设备的默认麦克风识别语音，则 TranslationRecognizer 应如下所示：

static void translateSpeech() {
    SpeechTranslationConfig speechTranslationConfig = SpeechTranslationConfig.fromSubscription(
        SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    
    String fromLanguage = "en-US";
    String[] toLanguages = { "it", "fr", "de" };
    speechTranslationConfig.setSpeechRecognitionLanguage(fromLanguage);
    for (String language : toLanguages) {
        speechTranslationConfig.addTargetLanguage(language);
    }

    try (TranslationRecognizer translationRecognizer = new TranslationRecognizer(speechTranslationConfig)) {
    }
}

如果要指定音频输入设备，则需要创建一个 AudioConfig 类实例并在初始化 audioConfig 时提供 TranslationRecognizer 参数。

小窍门

了解如何获取音频输入设备的设备 ID。

首先，引用 AudioConfig 对象，如下所示：

static void translateSpeech() {
    SpeechTranslationConfig speechTranslationConfig = SpeechTranslationConfig.fromSubscription(
        SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    
    String fromLanguage = "en-US";
    String[] toLanguages = { "it", "fr", "de" };
    speechTranslationConfig.setSpeechRecognitionLanguage(fromLanguage);
    for (String language : toLanguages) {
        speechTranslationConfig.addTargetLanguage(language);
    }

    AudioConfig audioConfig = AudioConfig.fromDefaultMicrophoneInput();
    try (TranslationRecognizer translationRecognizer = new TranslationRecognizer(speechTranslationConfig, audioConfig)) {
        
    }
}

如果要提供音频文件而不是使用麦克风，则仍需要提供 audioConfig 参数。但是，在创建 AudioConfig 类实例时，需要调用 fromDefaultMicrophoneInput（而不是调用 fromWavFileInput）并传递 filename 参数：

static void translateSpeech() {
    SpeechTranslationConfig speechTranslationConfig = SpeechTranslationConfig.fromSubscription(
        SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    
    String fromLanguage = "en-US";
    String[] toLanguages = { "it", "fr", "de" };
    speechTranslationConfig.setSpeechRecognitionLanguage(fromLanguage);
    for (String language : toLanguages) {
        speechTranslationConfig.addTargetLanguage(language);
    }

    AudioConfig audioConfig = AudioConfig.fromWavFileInput("YourAudioFile.wav");
    try (TranslationRecognizer translationRecognizer = new TranslationRecognizer(speechTranslationConfig, audioConfig)) {
        
    }
}

语音翻译

若要翻译语音，语音 SDK 依赖于麦克风或音频文件输入。语音识别发生在语音翻译之前。初始化所有对象后，调用识别一次函数并获取结果：

static void translateSpeech() throws ExecutionException, InterruptedException {
    SpeechTranslationConfig speechTranslationConfig = SpeechTranslationConfig.fromSubscription(
        SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    
    String fromLanguage = "en-US";
    String[] toLanguages = { "it", "fr", "de" };
    speechTranslationConfig.setSpeechRecognitionLanguage(fromLanguage);
    for (String language : toLanguages) {
        speechTranslationConfig.addTargetLanguage(language);
    }

    try (TranslationRecognizer translationRecognizer = new TranslationRecognizer(speechTranslationConfig)) {
        System.out.printf("Say something in '%s' and we'll translate...", fromLanguage);

        TranslationRecognitionResult translationRecognitionResult = translationRecognizer.recognizeOnceAsync().get();
        if (translationRecognitionResult.getReason() == ResultReason.TranslatedSpeech) {
            System.out.printf("Recognized: \"%s\"\n", translationRecognitionResult.getText());
            for (Map.Entry<String, String> pair : translationRecognitionResult.getTranslations().entrySet()) {
                System.out.printf("Translated into '%s': %s\n", pair.getKey(), pair.getValue());
            }
        }
    }
}

有关语音转文本的详细信息，请参阅语音识别基础知识。

基于事件的翻译

TranslationRecognizer 对象公开了 recognizing 事件。该事件多次触发，并提供检索中间转换结果的机制。

注释

使用多语言语音翻译时，中间翻译结果不可用。

以下示例将中间翻译结果输出到控制台：

import com.microsoft.cognitiveservices.speech.*;
import com.microsoft.cognitiveservices.speech.audio.AudioConfig;
import com.microsoft.cognitiveservices.speech.translation.*;

import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Semaphore;

public class TranslationContinuous {
    private static String SPEECH__SUBSCRIPTION__KEY = System.getenv("SPEECH__SUBSCRIPTION__KEY");
    private static String SPEECH__SERVICE__REGION = System.getenv("SPEECH__SERVICE__REGION");

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        SpeechTranslationConfig speechTranslationConfig = SpeechTranslationConfig.fromSubscription(
            SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

        String fromLanguage = "en-US";
        speechTranslationConfig.setSpeechRecognitionLanguage(fromLanguage);
        speechTranslationConfig.addTargetLanguage("de");
        speechTranslationConfig.addTargetLanguage("fr");

        AudioConfig audioConfig = AudioConfig.fromWavFileInput("YourAudioFile.wav");
        TranslationRecognizer translationRecognizer = new TranslationRecognizer(speechTranslationConfig, audioConfig);

        Semaphore stopTranslationSemaphore = new Semaphore(0);

        // Subscribes to events
        translationRecognizer.recognizing.addEventListener((s, e) -> {
            System.out.println("RECOGNIZING: Text=" + e.getResult().getText());
            for (Map.Entry<String, String> pair : e.getResult().getTranslations().entrySet()) {
                System.out.printf("    TRANSLATING into '%s': %s\n", pair.getKey(), pair.getValue());
            }
        });

        translationRecognizer.recognized.addEventListener((s, e) -> {
            if (e.getResult().getReason() == ResultReason.TranslatedSpeech) {
                System.out.println("RECOGNIZED: Text=" + e.getResult().getText());
                for (Map.Entry<String, String> pair : e.getResult().getTranslations().entrySet()) {
                    System.out.printf("    TRANSLATED into '%s': %s\n", pair.getKey(), pair.getValue());
                }
            } else if (e.getResult().getReason() == ResultReason.RecognizedSpeech) {
                System.out.println("RECOGNIZED: Text=" + e.getResult().getText());
                System.out.println("    Speech not translated.");
            } else if (e.getResult().getReason() == ResultReason.NoMatch) {
                System.out.println("NOMATCH: Speech could not be recognized.");
            }
        });

        translationRecognizer.canceled.addEventListener((s, e) -> {
            System.out.println("CANCELED: Reason=" + e.getReason());
            if (e.getReason() == CancellationReason.Error) {
                System.out.println("CANCELED: ErrorDetails=" + e.getErrorDetails());
            }
            stopTranslationSemaphore.release();
        });

        translationRecognizer.sessionStopped.addEventListener((s, e) -> {
            System.out.println("Session stopped.");
            stopTranslationSemaphore.release();
        });

        // Starts continuous recognition
        System.out.println("Start translation...");
        translationRecognizer.startContinuousRecognitionAsync().get();

        // Waits for completion
        stopTranslationSemaphore.acquire();

        // Stops translation
        translationRecognizer.stopContinuousRecognitionAsync().get();
    }
}

合成翻译

成功语音识别和翻译后，结果将包含字典中的所有翻译。 getTranslations 函数会返回一个字典，其键是目标翻译语言，其值是已翻译的文本。已识别的语音可以被翻译，并以另一种语言合成出来，实现语音转语音功能。

基于事件的合成

TranslationRecognizer 对象公开了 synthesizing 事件。该事件会触发多次，并提供一种机制以从翻译识别结果中检索合成音频。若要翻译为多种语言，请参阅手动合成。

通过分配 setVoiceName 实例指定合成语音，并为 synthesizing 事件提供事件处理程序，以获取音频。以下示例将翻译后的音频保存为.wav文件。

重要

基于事件的合成仅适用于单个翻译。请勿添加多种目标翻译语言。此外，setVoiceName 值应与目标翻译语言相同。例如，"de" 可映射到 "de-DE-Hedda"。

static void translateSpeech() throws ExecutionException, FileNotFoundException, InterruptedException, IOException {
    SpeechTranslationConfig speechTranslationConfig = SpeechTranslationConfig.fromSubscription(
        SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    String fromLanguage = "en-US";
    String toLanguage = "de";
    speechTranslationConfig.setSpeechRecognitionLanguage(fromLanguage);
    speechTranslationConfig.addTargetLanguage(toLanguage);

    // See: https://aka.ms/speech/sdkregion#standard-and-neural-voices
    speechTranslationConfig.setVoiceName("de-DE-Hedda");

    try (TranslationRecognizer translationRecognizer = new TranslationRecognizer(speechTranslationConfig)) {
        translationRecognizer.synthesizing.addEventListener((s, e) -> {
            byte[] audio = e.getResult().getAudio();
            int size = audio.length;
            System.out.println("Audio synthesized: " + size + " byte(s)" + (size == 0 ? "(COMPLETE)" : ""));

            if (size > 0) {
                try (FileOutputStream file = new FileOutputStream("translation.wav")) {
                    file.write(audio);
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
            }
        });

        System.out.printf("Say something in '%s' and we'll translate...", fromLanguage);

        TranslationRecognitionResult translationRecognitionResult = translationRecognizer.recognizeOnceAsync().get();
        if (translationRecognitionResult.getReason() == ResultReason.TranslatedSpeech) {
            System.out.printf("Recognized: \"%s\"\n", translationRecognitionResult.getText());
            for (Map.Entry<String, String> pair : translationRecognitionResult.getTranslations().entrySet()) {
                String language = pair.getKey();
                String translation = pair.getValue();
                System.out.printf("Translated into '%s': %s\n", language, translation);
            }
        }
    }
}

手动合成

getTranslations 函数返回一个字典，可使用该字典从翻译文本合成音频。迭代每个翻译并进行综合。创建 SpeechSynthesizer 实例时，SpeechConfig 对象需要将其 setSpeechSynthesisVoiceName 属性设为所需的语音。

以下示例翻译为五种语言。然后，将每个翻译合成为相应神经网络语言的音频文件。

static void translateSpeech() throws ExecutionException, InterruptedException {
    SpeechTranslationConfig speechTranslationConfig = SpeechTranslationConfig.fromSubscription(
        SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    
    String fromLanguage = "en-US";
    String[] toLanguages = { "de", "en", "it", "pt", "zh-Hans" };
    speechTranslationConfig.setSpeechRecognitionLanguage(fromLanguage);
    for (String language : toLanguages) {
        speechTranslationConfig.addTargetLanguage(language);
    }

    try (TranslationRecognizer translationRecognizer = new TranslationRecognizer(speechTranslationConfig)) {
        System.out.printf("Say something in '%s' and we'll translate...", fromLanguage);

        TranslationRecognitionResult translationRecognitionResult = translationRecognizer.recognizeOnceAsync().get();
        if (translationRecognitionResult.getReason() == ResultReason.TranslatedSpeech) {
            // See: https://aka.ms/speech/sdkregion#standard-and-neural-voices
            Map<String, String> languageToVoiceMap = new HashMap<String, String>();
            languageToVoiceMap.put("de", "de-DE-KatjaNeural");
            languageToVoiceMap.put("en", "en-US-AriaNeural");
            languageToVoiceMap.put("it", "it-IT-ElsaNeural");
            languageToVoiceMap.put("pt", "pt-BR-FranciscaNeural");
            languageToVoiceMap.put("zh-Hans", "zh-cn-XiaoxiaoNeural");

            System.out.printf("Recognized: \"%s\"\n", translationRecognitionResult.getText());
            for (Map.Entry<String, String> pair : translationRecognitionResult.getTranslations().entrySet()) {
                String language = pair.getKey();
                String translation = pair.getValue();
                System.out.printf("Translated into '%s': %s\n", language, translation);

                SpeechConfig speechConfig =
                    SpeechConfig.fromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
                speechConfig.setSpeechSynthesisVoiceName(languageToVoiceMap.get(language));

                AudioConfig audioConfig = AudioConfig.fromWavFileOutput(language + "-translation.wav");
                try (SpeechSynthesizer speechSynthesizer = new SpeechSynthesizer(speechConfig, audioConfig)) {
                    speechSynthesizer.SpeakTextAsync(translation).get();
                }
            }
        }
    }
}

有关语音合成的详细信息，请参阅语音合成基础知识。

使用语言识别进行多语言翻译

在许多情况下，你可能不知道要指定的输入语言。使用语言识别，可以检测最多 10 种可能的输入语言，并自动将其翻译成目标语言。

以下示例预期检测到 en-US 或 zh-cn，因为它们是在 AutoDetectSourceLanguageConfig 中定义的。然后，语音将被转换为 de 和 fr，如对 addTargetLanguage() 的调用中指定的那样。

speechTranslationConfig.addTargetLanguage("de");
speechTranslationConfig.addTargetLanguage("fr");
AutoDetectSourceLanguageConfig autoDetectSourceLanguageConfig = 
    AutoDetectSourceLanguageConfig.fromLanguages(Arrays.asList("en-US", "zh-cn"));
TranslationRecognizer translationRecognizer = 
    new TranslationRecognizer(speechTranslationConfig, autoDetectSourceLanguageConfig, audioConfig);

有关完整的代码示例，请参阅语言识别。

参考文档包（npm）GitHub上的附加样例库源代码

本作指南介绍如何识别人工语音并将其翻译为其他语言。

有关以下内容的详细信息，请参阅语音翻译概述：

将语音转换为文本
将语音翻译为多个目标语言
进行直接语音到语音翻译

创建翻译配置

若要使用语音 SDK 调用翻译服务，需要创建 SpeechTranslationConfig 实例。此类包含有关您的语音服务资源的信息，例如您的密钥、关联的区域、终结点、服务器或授权令牌。

注释

无论你是执行语音识别、语音合成、翻译还是意向识别，你都会始终创建配置。

可以通过以下几种方式初始化 SpeechTranslationConfig：

在订阅中传入密钥和关联的区域。
使用终结点：传入语音服务终结点。密钥或授权令牌是可选的。
使用主机：传入主机地址。密钥或授权令牌是可选的。
使用授权令牌：传入授权令牌和关联的区域。

让我们看看如何使用密钥和区域创建 SpeechTranslationConfig 实例。获取 Azure 门户中的语音资源密钥和区域。

const speechTranslationConfig = SpeechTranslationConfig.fromSubscription("YourSpeechResourceKey", "YourServiceRegion");

初始化翻译器

创建 SpeechTranslationConfig 实例后，下一步是初始化 TranslationRecognizer。初始化 TranslationRecognizer 时，需要向其传递 speechTranslationConfig 实例。配置对象提供翻译服务验证请求所需的凭据。

如果使用设备的默认麦克风翻译提供的语音，则 TranslationRecognizer 应如下所示：

const translationRecognizer = new TranslationRecognizer(speechTranslationConfig);

如果要指定音频输入设备，则需要创建一个 AudioConfig 类实例并在初始化 audioConfig 时提供 TranslationRecognizer 参数。

小窍门

了解如何获取音频输入设备的设备 ID。

引用 AudioConfig 对象，如下所示：

const audioConfig = AudioConfig.fromDefaultMicrophoneInput();
const translationRecognizer = new TranslationRecognizer(speechTranslationConfig, audioConfig);

如果要提供音频文件而不是使用麦克风，则仍需要提供 audioConfig 参数。但是，只有在以 Node.js为目标时，才能执行此作。在创建 AudioConfig 类实例时，需要调用 fromDefaultMicrophoneInput（而不是调用 fromWavFileOutput）并传递 filename 参数：

const audioConfig = AudioConfig.fromWavFileInput("YourAudioFile.wav");
const translationRecognizer = new TranslationRecognizer(speechTranslationConfig, audioConfig);

语音翻译

JavaScript 的语音 SDK 的 TranslationRecognizer 类公开了可用于语音翻译的方法：

单步翻译（异步）- 在非阻塞（异步）模式下执行翻译。它翻译单句话。它通过在单个话语的末尾监听静音，或者最多处理 15 秒的音频，来确定其结束。
连续翻译（异步）：异步启动连续翻译操作。用户注册参加活动并管理各种应用状态。若要停止异步连续翻译，请调用 stopContinuousRecognitionAsync。

若要详细了解如何选择语音识别模式，请参阅语音转文本入门。

指定目标语言

若要翻译，必须同时指定源语言和至少一种目标语言。

可以使用语音翻译表中列出的区域设置来选择源语言。在同一链接中找到翻译语言的选项。

当你想要查看文本或想要听到合成翻译语音时，目标语言的选项会有所不同。若要从英语翻译为德语，请修改翻译配置对象：

speechTranslationConfig.speechRecognitionLanguage = "en-US";
speechTranslationConfig.addTargetLanguage("de");

单次识别

下面是通过 recognizeOnceAsync 进行异步单步翻译的示例：

translationRecognizer.recognizeOnceAsync(result => {
    // Interact with result
});

需要编写一些代码来处理结果。此示例对翻译为德语的 result.reason 进行评估：

translationRecognizer.recognizeOnceAsync(
  function (result) {
    let translation = result.translations.get("de");
    window.console.log(translation);
    translationRecognizer.close();
  },
  function (err) {
    window.console.log(err);
    translationRecognizer.close();
});

代码还可以处理翻译处理时提供的更新。可以使用这些更新提供有关翻译进度的视觉反馈。以下 JavaScript Node.js 示例显示了这些类型的更新。以下代码还显示翻译过程中生成的详细信息：

translationRecognizer.recognizing = function (s, e) {
    var str = ("(recognizing) Reason: " + SpeechSDK.ResultReason[e.result.reason] +
            " Text: " +  e.result.text +
            " Translation:");
    str += e.result.translations.get("de");
    console.log(str);
};
translationRecognizer.recognized = function (s, e) {
    var str = "\r\n(recognized)  Reason: " + SpeechSDK.ResultReason[e.result.reason] +
            " Text: " + e.result.text +
            " Translation:";
    str += e.result.translations.get("de");
    str += "\r\n";
    console.log(str);
};

基于事件的翻译

基于事件的翻译比单次识别更加复杂。它要求你订阅 recognizing、recognized 和 canceled 事件以获取识别结果。若要停止翻译，必须调用 stopContinuousRecognitionAsync。

注释

使用多语言语音翻译时，中间翻译结果不可用。

下面是如何对音频输入文件执行基于事件的翻译的示例。首先，我们将定义输入并初始化一个 TranslationRecognizer：

const translationRecognizer = new TranslationRecognizer(speechTranslationConfig);

在下面的代码中，你会订阅从 TranslationRecognizer 发送的事件：

recognizing：事件信号，包含中间翻译结果。
recognized：事件信号，包含最终翻译结果。这些结果表示成功翻译尝试。
sessionStopped：事件信号，指示翻译会话的结束（操作）。
canceled：事件信号，包含已取消的翻译结果。这些事件表明由于直接取消而取消的翻译尝试。或者，它们表示传输或协议失败。

translationRecognizer.recognizing = (s, e) => {
    console.log(`TRANSLATING: Text=${e.result.text}`);
};
translationRecognizer.recognized = (s, e) => {
    if (e.result.reason == ResultReason.RecognizedSpeech) {
        console.log(`TRANSLATED: Text=${e.result.text}`);
    }
    else if (e.result.reason == ResultReason.NoMatch) {
        console.log("NOMATCH: Speech could not be translated.");
    }
};
translationRecognizer.canceled = (s, e) => {
    console.log(`CANCELED: Reason=${e.reason}`);
    if (e.reason == CancellationReason.Error) {
        console.log(`"CANCELED: ErrorCode=${e.errorCode}`);
        console.log(`"CANCELED: ErrorDetails=${e.errorDetails}`);
        console.log("CANCELED: Did you set the speech resource key and region values?");
    }
    translationRecognizer.stopContinuousRecognitionAsync();
};
translationRecognizer.sessionStopped = (s, e) => {
    console.log("\n    Session stopped event.");
    translationRecognizer.stopContinuousRecognitionAsync();
};

完成所有设置后，可以调用 startContinuousRecognitionAsync：

// Starts continuous recognition. Uses stopContinuousRecognitionAsync() to stop recognition.
translationRecognizer.startContinuousRecognitionAsync();
// Something later can call. Stops recognition.
// translationRecognizer.StopContinuousRecognitionAsync();

选择源语言

语音翻译的常见任务是指定输入（或源）语言。以下示例演示如何将输入语言更改为意大利语。在代码中找到 SpeechTranslationConfig 实例，并直接在其下方添加下面的行：

speechTranslationConfig.speechRecognitionLanguage = "it-IT";

speechRecognitionLanguage 属性需要语言区域设置格式字符串。请参阅支持的语音翻译区域设置列表。

选择一个或多个目标语言

语音 SDK 可以并行转换为多个目标语言。可用的目标语言与源语言列表略有不同。使用语言代码而不是区域设置来指定目标语言。

有关文本目标的语言代码列表，请参阅语言支持页上的语音翻译表。还可以在此处找到有关翻译到合成语言的详细信息。

以下代码将德语添加为目标语言：

speechTranslationConfig.addTargetLanguage("de");

由于可以翻译多个目标语言，因此代码在检查结果时必须指定目标语言。以下代码获取德语的翻译结果：

translationRecognizer.recognized = function (s, e) {
    var str = "\r\n(recognized)  Reason: " +
            sdk.ResultReason[e.result.reason] +
            " Text: " + e.result.text + " Translations:";
    var language = "de";
    str += " [" + language + "] " + e.result.translations.get(language);
    str += "\r\n";
    // show str somewhere
};

合成翻译

成功语音识别和翻译后，结果将包含字典中的所有翻译。该 translations 属性返回一个字典，其中键表示目标翻译语言，值为翻译后的文本。已识别的语音可以被翻译，并以另一种语言合成出来，实现语音转语音功能。

基于事件的合成

通过分配 voiceName 属性来指定合成语音，并为 synthesizing 事件提供事件处理程序以获取音频。以下示例将翻译后的音频保存为.wav文件。

重要

基于事件的合成仅适用于单个翻译。请勿添加多种目标翻译语言。此外，voiceName 值应与目标翻译语言相同。例如，"de" 可映射到 "de-DE-Hedda"。

const speechTranslationConfig = SpeechTranslationConfig.fromSubscription("YourSpeechResourceKey", "YourServiceRegion");

speechTranslationConfig.speechRecognitionLanguage = "en-US";
speechTranslationConfig.addTargetLanguage("de");

// See: https://aka.ms/speech/sdkregion#standard-and-neural-voices
speechTranslationConfig.voiceName = "de-DE-Hedda";

const translationRecognizer = new TranslationRecognizer(speechTranslationConfig);

translationRecognizer.synthesizing = (s, e) => {
    const audio = e.result.audio;
    console.log(`Audio synthesized: ${audio.byteLength} byte(s) ${audio.byteLength === 0 ? "(COMPLETE)" : ""}`);
    
    if (audio.byteLength > 0) {
        // In Node.js, save to file
        const fs = require("fs");
        fs.writeFileSync("translation.wav", Buffer.from(audio));
    }
};

console.log("Say something in English and we'll translate to German...");

translationRecognizer.recognizeOnceAsync(result => {
    if (result.reason === ResultReason.TranslatedSpeech) {
        console.log(`Recognized: "${result.text}"`);
        console.log(`Translated into German: ${result.translations.get("de")}`);
    }
    translationRecognizer.close();
});

手动合成

translations 字典可用于从翻译文本合成音频。迭代每个翻译并进行综合。创建 SpeechSynthesizer 实例时，SpeechConfig 对象需要将其 speechSynthesisVoiceName 属性设为所需的语音。

以下示例翻译为五种语言。然后，将每个翻译合成为相应神经网络语言的音频文件。

const speechTranslationConfig = SpeechTranslationConfig.fromSubscription("YourSpeechResourceKey", "YourServiceRegion");

speechTranslationConfig.speechRecognitionLanguage = "en-US";
speechTranslationConfig.addTargetLanguage("de");
speechTranslationConfig.addTargetLanguage("fr");
speechTranslationConfig.addTargetLanguage("it");
speechTranslationConfig.addTargetLanguage("pt");
speechTranslationConfig.addTargetLanguage("zh-Hans");

const translationRecognizer = new TranslationRecognizer(speechTranslationConfig);

console.log("Say something...");

translationRecognizer.recognizeOnceAsync(async result => {
    if (result.reason === ResultReason.TranslatedSpeech) {
        const languageToVoiceMap = {
            "de": "de-DE-KatjaNeural",
            "fr": "fr-FR-DeniseNeural",
            "it": "it-IT-ElsaNeural",
            "pt": "pt-BR-FranciscaNeural",
            "zh-Hans": "zh-cn-XiaoxiaoNeural"
        };

        console.log(`Recognized: "${result.text}"`);

        for (const [language, translation] of result.translations) {
            console.log(`Translated into '${language}': ${translation}`);

            const speechConfig = SpeechConfig.fromSubscription("YourSpeechResourceKey", "YourServiceRegion");
            speechConfig.speechSynthesisVoiceName = languageToVoiceMap[language];

            const audioConfig = AudioConfig.fromAudioFileOutput(`${language}-translation.wav`);
            const speechSynthesizer = new SpeechSynthesizer(speechConfig, audioConfig);

            await new Promise((resolve, reject) => {
                speechSynthesizer.speakTextAsync(
                    translation,
                    synthesisResult => {
                        speechSynthesizer.close();
                        resolve();
                    },
                    error => {
                        speechSynthesizer.close();
                        reject(error);
                    }
                );
            });
        }
    }
    translationRecognizer.close();
});

有关语音合成的详细信息，请参阅语音合成基础知识。

使用语言识别进行多语言翻译

在许多情况下，你可能不知道要指定的输入语言。使用语言识别，可以检测最多 10 种可能的输入语言，并自动将其翻译成目标语言。

speechTranslationConfig.addTargetLanguage("de");
speechTranslationConfig.addTargetLanguage("fr");
const autoDetectSourceLanguageConfig = AutoDetectSourceLanguageConfig.fromLanguages(["en-US", "zh-cn"]);
const translationRecognizer = TranslationRecognizer.FromConfig(speechTranslationConfig, autoDetectSourceLanguageConfig, audioConfig);

有关完整的代码示例，请参阅语言识别。

参考文档 | Package（下载） | GitHub 上的额外示例

适用于 Objective-C 的语音 SDK 支持语音翻译，但此处尚未包含指南。请选择另一种编程语言来开始了解概念，或查看本文开头链接的 Objective-C 参考和示例。

参考文档 | Package（下载） | GitHub 上的额外示例

适用于 Swift 的语音 SDK 支持语音翻译，但此处尚未包含指南。请选择另一种编程语言以开始了解概念，或查看本文开头链接的 Swift 参考和示例。

参考文档 | 软件包（PyPi） | GitHub 上的其他示例

本作指南介绍如何识别人工语音并将其翻译为其他语言。

有关以下内容的详细信息，请参阅语音翻译概述：

将语音转换为文本
将语音翻译为多个目标语言
进行直接语音到语音翻译

敏感数据和环境变量

本文中的示例源代码取决于用于存储敏感数据的环境变量，例如语音资源的订阅密钥和区域。 Python代码文件包含从主机环境变量中分配的两个值：SPEECH__SUBSCRIPTION__KEY 和 SPEECH__SERVICE__REGION。这两个变量都在全局范围内，因此可以在代码文件的函数定义中访问它们：

speech_key, service_region = os.environ['SPEECH__SUBSCRIPTION__KEY'], os.environ['SPEECH__SERVICE__REGION']

有关环境变量的详细信息，请参阅环境变量和应用程序配置。

重要

有关 AI 服务安全性的详细信息，请参阅对 Azure AI 服务进行请求身份验证。

创建语音翻译配置

小窍门

无论你是执行语音识别、语音合成、翻译还是意向识别，你都会始终创建配置。

可以通过以下几种方式初始化 SpeechTranslationConfig：

在订阅中传入密钥和关联的区域。
使用终结点：传入语音服务终结点。密钥或授权令牌是可选的。
使用主机：传入主机地址。密钥或授权令牌是可选的。
使用授权令牌：传入授权令牌和关联的区域。

让我们看看如何使用密钥和区域创建 SpeechTranslationConfig 实例。获取 Azure 门户中的语音资源密钥和区域。

from_language, to_language = 'en-US', 'de'

def translate_speech_to_text():
    translation_config = speechsdk.translation.SpeechTranslationConfig(
            subscription=speech_key, region=service_region)

更改源语言

语音翻译的一个常见任务是指定输入（或源）语言。以下示例演示如何将输入语言更改为意大利语。在代码中，通过将 SpeechTranslationConfig 实例分配给 speech_recognition_language 属性，与该实例进行交互。

def translate_speech_to_text():
    translation_config = speechsdk.translation.SpeechTranslationConfig(
            subscription=speech_key, region=service_region)

    # Source (input) language
    from_language = "it-IT"
    translation_config.speech_recognition_language = from_language

speech_recognition_language 属性需要语言区域设置格式字符串。请参阅支持的语音翻译区域设置列表。

添加翻译语言

语音翻译的另一个常见任务是指定目标翻译语言。至少需要一个，但支持多个。以下代码片段将法语和德语设置为翻译语言目标：

def translate_speech_to_text():
    translation_config = speechsdk.translation.SpeechTranslationConfig(
            subscription=speech_key, region=service_region)

    translation_config.speech_recognition_language = "it-IT"

    # Translate to languages. See, https://aka.ms/speech/sttt-languages
    translation_config.add_target_language("fr")
    translation_config.add_target_language("de")

每次调用 add_target_language 时，都会指定一种新的目标翻译语言。换句话说，从源语言识别语音时，每个目标翻译都可用作生成的翻译作的一部分。

初始化翻译识别器

创建 SpeechTranslationConfig 实例后，下一步是初始化 TranslationRecognizer。初始化 TranslationRecognizer 时，需要向其传递 translation_config 实例。配置对象提供语音服务验证请求所需的凭据。

如果使用设备的默认麦克风识别语音，则 TranslationRecognizer 应如下所示：

def translate_speech_to_text():
    translation_config = speechsdk.translation.SpeechTranslationConfig(
            subscription=speech_key, region=service_region)

    translation_config.speech_recognition_language = from_language
    translation_config.add_target_language(to_language)

    translation_recognizer = speechsdk.translation.TranslationRecognizer(
            translation_config=translation_config)

如果要指定音频输入设备，则需要创建一个 AudioConfig 类实例并在初始化 audio_config 时提供 TranslationRecognizer 参数。

小窍门

了解如何获取音频输入设备的设备 ID。

首先，引用 AudioConfig 对象，如下所示：

def translate_speech_to_text():
    translation_config = speechsdk.translation.SpeechTranslationConfig(
            subscription=speech_key, region=service_region)

    translation_config.speech_recognition_language = from_language
    for lang in to_languages:
        translation_config.add_target_language(lang)

    audio_config = speechsdk.audio.AudioConfig(use_default_microphone=True)
    translation_recognizer = speechsdk.translation.TranslationRecognizer(
            translation_config=translation_config, audio_config=audio_config)

如果要提供音频文件而不是使用麦克风，则仍需要提供 audioConfig 参数。但是，在创建 AudioConfig 类实例时，需要使用 use_default_microphone=True 进行调用（而不是使用 filename="path-to-file.wav" 进行调用），并提供 filename 参数：

def translate_speech_to_text():
    translation_config = speechsdk.translation.SpeechTranslationConfig(
            subscription=speech_key, region=service_region)

    translation_config.speech_recognition_language = from_language
    for lang in to_languages:
        translation_config.add_target_language(lang)

    audio_config = speechsdk.audio.AudioConfig(filename="path-to-file.wav")
    translation_recognizer = speechsdk.translation.TranslationRecognizer(
            translation_config=translation_config, audio_config=audio_config)

语音翻译

若要翻译语音，语音 SDK 依赖于麦克风或音频文件输入。语音识别发生在语音翻译之前。初始化所有对象后，调用识别一次函数并获取结果：

import os
import azure.cognitiveservices.speech as speechsdk

speech_key, service_region = os.environ['SPEECH__SERVICE__KEY'], os.environ['SPEECH__SERVICE__REGION']
from_language, to_languages = 'en-US', 'de'

def translate_speech_to_text():
    translation_config = speechsdk.translation.SpeechTranslationConfig(
            subscription=speech_key, region=service_region)

    translation_config.speech_recognition_language = from_language
    translation_config.add_target_language(to_language)

    translation_recognizer = speechsdk.translation.TranslationRecognizer(
            translation_config=translation_config)
    
    print('Say something...')
    translation_recognition_result = translation_recognizer.recognize_once()
    print(get_result_text(reason=translation_recognition_result.reason, result=translation_recognition_result))

def get_result_text(reason, translation_recognition_result):
    reason_format = {
        speechsdk.ResultReason.TranslatedSpeech:
            f'RECOGNIZED "{from_language}": {translation_recognition_result.text}\n' +
            f'TRANSLATED into "{to_language}"": {translation_recognition_result.translations[to_language]}',
        speechsdk.ResultReason.RecognizedSpeech: f'Recognized: "{translation_recognition_result.text}"',
        speechsdk.ResultReason.NoMatch: f'No speech could be recognized: {translation_recognition_result.no_match_details}',
        speechsdk.ResultReason.Canceled: f'Speech Recognition canceled: {translation_recognition_result.cancellation_details}'
    }
    return reason_format.get(reason, 'Unable to recognize speech')

translate_speech_to_text()

有关语音转文本的详细信息，请参阅语音识别基础知识。

基于事件的翻译

TranslationRecognizer 对象公开了 recognizing 事件。该事件多次触发，并提供检索中间转换结果的机制。

注释

使用多语言语音翻译时，中间翻译结果不可用。

以下示例将中间翻译结果输出到控制台：

import os
import azure.cognitiveservices.speech as speechsdk

speech_key, service_region = os.environ['SPEECH__SERVICE__KEY'], os.environ['SPEECH__SERVICE__REGION']
from_language, to_language = 'en-US', 'de'

def translate_speech_continuous():
    translation_config = speechsdk.translation.SpeechTranslationConfig(
        subscription=speech_key, region=service_region)
    
    translation_config.speech_recognition_language = from_language
    translation_config.add_target_language(to_language)
    
    audio_config = speechsdk.audio.AudioConfig(filename="whatstheweatherlike.wav")
    translation_recognizer = speechsdk.translation.TranslationRecognizer(
        translation_config=translation_config, audio_config=audio_config)
    
    done = False
    
    def recognizing_cb(evt):
        print(f'RECOGNIZING in "{from_language}": Text={evt.result.text}')
        for language, translation in evt.result.translations.items():
            print(f'    TRANSLATING into "{language}": {translation}')
    
    def recognized_cb(evt):
        if evt.result.reason == speechsdk.ResultReason.TranslatedSpeech:
            print(f'RECOGNIZED in "{from_language}": Text={evt.result.text}')
            for language, translation in evt.result.translations.items():
                print(f'    TRANSLATED into "{language}": {translation}')
        elif evt.result.reason == speechsdk.ResultReason.RecognizedSpeech:
            print(f'RECOGNIZED: Text={evt.result.text}')
            print('    Speech not translated.')
        elif evt.result.reason == speechsdk.ResultReason.NoMatch:
            print('NOMATCH: Speech could not be recognized.')
    
    def canceled_cb(evt):
        print(f'CANCELED: Reason={evt.cancellation_details.reason}')
        if evt.cancellation_details.reason == speechsdk.CancellationReason.Error:
            print(f'CANCELED: ErrorDetails={evt.cancellation_details.error_details}')
        nonlocal done
        done = True
    
    def session_stopped_cb(evt):
        print('SESSION STOPPED')
        nonlocal done
        done = True
    
    # Connect callbacks
    translation_recognizer.recognizing.connect(recognizing_cb)
    translation_recognizer.recognized.connect(recognized_cb)
    translation_recognizer.canceled.connect(canceled_cb)
    translation_recognizer.session_stopped.connect(session_stopped_cb)
    
    # Start continuous recognition
    print('Start translation...')
    translation_recognizer.start_continuous_recognition()
    
    # Wait for completion
    while not done:
        pass
    
    # Stop recognition
    translation_recognizer.stop_continuous_recognition()

translate_speech_continuous()

合成翻译

成功语音识别和翻译后，结果将包含字典中的所有翻译。 translations 字典键是目标翻译语言，其值是已翻译的文本。已识别的语音可以被翻译，并以另一种语言合成出来，实现语音转语音功能。

基于事件的合成

通过分配 voice_name 实例指定合成语音，并为 Synthesizing 事件提供事件处理程序，以获取音频。以下示例将翻译后的音频保存为.wav文件。

重要

基于事件的合成仅适用于单个翻译。请勿添加多种目标翻译语言。此外，voice_name 值应与目标翻译语言相同。例如，"de" 可映射到 "de-DE-Hedda"。

import os
import azure.cognitiveservices.speech as speechsdk

speech_key, service_region = os.environ['SPEECH__SERVICE__KEY'], os.environ['SPEECH__SERVICE__REGION']
from_language, to_language = 'en-US', 'de'

def translate_speech_to_text():
    translation_config = speechsdk.translation.SpeechTranslationConfig(
            subscription=speech_key, region=service_region)

    translation_config.speech_recognition_language = from_language
    translation_config.add_target_language(to_language)

    # See: https://aka.ms/speech/sdkregion#standard-and-neural-voices
    translation_config.voice_name = "de-DE-Hedda"

    translation_recognizer = speechsdk.translation.TranslationRecognizer(
            translation_config=translation_config)

    def synthesis_callback(evt):
        size = len(evt.result.audio)
        print(f'Audio synthesized: {size} byte(s) {"(COMPLETED)" if size == 0 else ""}')

        if size > 0:
            file = open('translation.wav', 'wb+')
            file.write(evt.result.audio)
            file.close()

    translation_recognizer.synthesizing.connect(synthesis_callback)

    print(f'Say something in "{from_language}" and we\'ll translate into "{to_language}".')

    translation_recognition_result = translation_recognizer.recognize_once()
    print(get_result_text(reason=translation_recognition_result.reason, result=translation_recognition_result))

def get_result_text(reason, translation_recognition_result):
    reason_format = {
        speechsdk.ResultReason.TranslatedSpeech:
            f'Recognized "{from_language}": {translation_recognition_result.text}\n' +
            f'Translated into "{to_language}"": {translation_recognition_result.translations[to_language]}',
        speechsdk.ResultReason.RecognizedSpeech: f'Recognized: "{translation_recognition_result.text}"',
        speechsdk.ResultReason.NoMatch: f'No speech could be recognized: {translation_recognition_result.no_match_details}',
        speechsdk.ResultReason.Canceled: f'Speech Recognition canceled: {translation_recognition_result.cancellation_details}'
    }
    return reason_format.get(reason, 'Unable to recognize speech')

translate_speech_to_text()

手动合成

translations 字典可用于从翻译文本合成音频。迭代每个翻译并进行综合。创建 SpeechSynthesizer 实例时，SpeechConfig 对象需要将其 speech_synthesis_voice_name 属性设为所需的语音。

以下示例翻译为五种语言。然后，将每个翻译合成为相应神经网络语言的音频文件。

import os
import azure.cognitiveservices.speech as speechsdk

speech_key, service_region = os.environ['SPEECH__SERVICE__KEY'], os.environ['SPEECH__SERVICE__REGION']
from_language, to_languages = 'en-US', [ 'de', 'en', 'it', 'pt', 'zh-Hans' ]

def translate_speech_to_text():
    translation_config = speechsdk.translation.SpeechTranslationConfig(
            subscription=speech_key, region=service_region)

    translation_config.speech_recognition_language = from_language
    for lang in to_languages:
        translation_config.add_target_language(lang)

    recognizer = speechsdk.translation.TranslationRecognizer(
            translation_config=translation_config)
    
    print('Say something...')
    translation_recognition_result = translation_recognizer.recognize_once()
    synthesize_translations(result=translation_recognition_result)

def synthesize_translations(translation_recognition_result):
    language_to_voice_map = {
        "de": "de-DE-KatjaNeural",
        "en": "en-US-AriaNeural",
        "it": "it-IT-ElsaNeural",
        "pt": "pt-BR-FranciscaNeural",
        "zh-Hans": "zh-cn-XiaoxiaoNeural"
    }
    print(f'Recognized: "{translation_recognition_result.text}"')

    for language in translation_recognition_result.translations:
        translation = translation_recognition_result.translations[language]
        print(f'Translated into "{language}": {translation}')

        speech_config = speechsdk.SpeechConfig(subscription=speech_key, region=service_region)
        speech_config.speech_synthesis_voice_name = language_to_voice_map.get(language)
        
        audio_config = speechsdk.audio.AudioOutputConfig(filename=f'{language}-translation.wav')
        speech_synthesizer = speechsdk.SpeechSynthesizer(speech_config=speech_config, audio_config=audio_config)
        speech_synthesizer.speak_text_async(translation).get()

translate_speech_to_text()

有关语音合成的详细信息，请参阅语音合成基础知识。

使用语言识别进行多语言翻译

在许多情况下，你可能不知道要指定的输入语言。使用语言识别，可以检测最多 10 种可能的输入语言，并自动将其翻译成目标语言。

有关完整的代码示例，请参阅语言识别。

语音转文本 REST API 参考 | 短音频的语音转文本 REST API 参考 | GitHub 上的更多示例

可以使用 REST API 进行语音翻译，但我们尚未在此处提供指南。请选择另一种编程语言以开始使用并了解这些概念。

本作指南介绍如何识别人工语音并将其翻译为其他语言。

有关以下内容的详细信息，请参阅语音翻译概述：

将语音转换为文本
将语音翻译为多个目标语言
进行直接语音到语音翻译

先决条件

Azure订阅。可以创建一个试用帐户
在 Azure 门户中创建用于语音的 AI Services 资源。
获取语音资源密钥和区域。部署语音资源后，选择“转到资源”以查看和管理密钥。

下载并安装

请按照以下步骤操作，并参阅语音 CLI 快速入门，了解适用于你的平台的其他要求。

运行以下.NET CLI 命令以安装语音 CLI：

dotnet tool install --global Microsoft.CognitiveServices.Speech.CLI

运行以下命令以配置语音资源密钥和区域。将 SUBSCRIPTION-KEY 替换为语音资源密钥，将 REGION 替换为语音资源区域。
- 终端
- PowerShell
```
spx config @key --set SUBSCRIPTION-KEY
spx config @region --set REGION
```
```
spx --% config @key --set SUBSCRIPTION-KEY
spx --% config @region --set REGION
```

设置源和目标语言

此命令调用语音 CLI，将语音从麦克风从意大利语翻译为法语：

spx translate --microphone --source it-IT --target fr

后续步骤

Last updated on 2026-03-10

Compartilhar via

如何识别和翻译语音

敏感数据和环境变量

创建语音翻译配置

更改源语言

添加翻译语言

初始化翻译识别器

语音翻译

基于事件的翻译

合成翻译

基于事件的合成

手动合成

使用语言识别进行多语言翻译

不使用源语言候选语言的多语言语音翻译

敏感数据和环境变量

创建语音翻译配置

更改源语言

添加翻译语言

初始化翻译识别器

语音翻译

基于事件的翻译

合成翻译

基于事件的合成

手动合成

使用语言识别进行多语言翻译

敏感数据和环境变量

创建语音翻译配置

更改源语言

添加翻译语言

初始化翻译识别器

语音翻译

基于事件的翻译

合成翻译

基于事件的合成

手动合成

使用语言识别进行多语言翻译

清理资源

敏感数据和环境变量

创建语音翻译配置

更改源语言

添加翻译语言

初始化翻译识别器

语音翻译

基于事件的翻译

合成翻译

基于事件的合成

手动合成

使用语言识别进行多语言翻译

创建翻译配置

初始化翻译器

语音翻译

指定目标语言

单次识别

基于事件的翻译

选择源语言

选择一个或多个目标语言

合成翻译

基于事件的合成

手动合成

使用语言识别进行多语言翻译

敏感数据和环境变量

创建语音翻译配置

更改源语言

添加翻译语言

初始化翻译识别器

语音翻译

基于事件的翻译

合成翻译

基于事件的合成

手动合成

使用语言识别进行多语言翻译

先决条件

下载并安装

设置源和目标语言

后续步骤

Recursos adicionais