你当前正在访问 Microsoft Azure Global Edition 技术文档网站。 如果需要访问由世纪互联运营的 Microsoft Azure 中国技术文档网站，请访问 https://docs.azure.cn。

如何识别语音

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

本操作指南介绍如何在 Foundry 工具中使用Azure语音进行实时语音转文本转换。 实时语音识别非常适合需要即时听录的应用程序，例如听写、呼叫中心协助和实时会议的字幕。

若要了解如何为示例应用程序设置环境，请参阅 快速入门：识别语音并将其转换为文本。

将语音转换为文本

在命令提示符下运行以下命令。 将以下值插入命令：

  • 语音资源的 API 密钥
  • 语音服务区域
  • 输入音频文件的路径
curl --location --request POST 'https://YourResourceName.cognitiveservices.azure.com/stt/speech/recognition/conversation/cognitiveservices/v1?language=en-US' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE' \
--header 'Content-Type: audio/wav' \
--data-binary @'INSERT_AUDIO_FILE_PATH_HERE'

应收到如下示例所示的响应：

{
    "RecognitionStatus": "Success",
    "DisplayText": "My voice is my passport, verify me.",
    "Offset": 6600000,
    "Duration": 32100000
}

有关详细信息，请参阅 语音转文本 REST API 参考。

参考文档 | 软件包（PyPi） | 更多示例在 GitHub 上

本操作指南介绍如何在 Foundry 工具中使用Azure语音进行实时语音转文本转换。 实时语音识别非常适合需要即时听录的应用程序，例如听写、呼叫中心协助和实时会议的字幕。

若要了解如何为示例应用程序设置环境，请参阅 快速入门：识别语音并将其转换为文本。

创建语音配置实例

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

  1. 在 Azure 门户中创建用于语音的 Foundry 资源。 获取语音资源密钥和区域。
  2. SpeechConfig使用以下代码创建实例。 将 YourSpeechKey 和 YourSpeechRegion 替换为你的语音资源密钥和区域。
speech_config = speechsdk.SpeechConfig(subscription="YourSpeechKey", region="YourSpeechRegion")

可以通过其他几种方式进行初始化 SpeechConfig ：

  • 使用终结点，并传入语音服务终结点。 语音密钥或授权令牌是可选的。
  • 使用主机，并传入主机地址。 语音密钥或授权令牌是可选的。
  • 将授权令牌与关联的区域/位置配合使用。

注意

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

识别来自麦克风的语音

若要使用设备麦克风识别语音，请创建一个 SpeechRecognizer 不传递 AudioConfig的实例，然后传递 speech_config：

import azure.cognitiveservices.speech as speechsdk

def from_mic():
    speech_config = speechsdk.SpeechConfig(subscription="YourSpeechKey", region="YourSpeechRegion")
    speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config)

    print("Speak into your microphone.")
    speech_recognition_result = speech_recognizer.recognize_once_async().get()
    print(speech_recognition_result.text)

from_mic()

如果要使用 特定的 音频输入设备，则需要在其中 AudioConfig指定设备 ID，并将其传递给 SpeechRecognizer 构造函数 audio_config 的参数。 若要了解如何获取设备 ID，请参阅 使用语音 SDK 选择音频输入设备。

识别文件中的语音

如果要从音频文件中识别语音而不是使用麦克风，请创建一个 AudioConfig 实例并使用 filename 参数：

import azure.cognitiveservices.speech as speechsdk

def from_file():
    speech_config = speechsdk.SpeechConfig(subscription="YourSpeechKey", region="YourSpeechRegion")
    audio_config = speechsdk.AudioConfig(filename="your_file_name.wav")
    speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config, audio_config=audio_config)

    speech_recognition_result = speech_recognizer.recognize_once_async().get()
    print(speech_recognition_result.text)

from_file()

处理错误

前面的示例仅从属性中获取已识别的文本 speech_recognition_result.text 。 若要处理错误和其他响应，需要编写一些代码来处理结果。 以下代码计算 speech_recognition_result.reason 属性，并：

  • 打印识别结果： speechsdk.ResultReason.RecognizedSpeech.
  • 如果没有识别匹配项，它会通知用户： speechsdk.ResultReason.NoMatch
  • 如果遇到错误，它将输出错误消息： speechsdk.ResultReason.Canceled.
if speech_recognition_result.reason == speechsdk.ResultReason.RecognizedSpeech:
    print("Recognized: {}".format(speech_recognition_result.text))
elif speech_recognition_result.reason == speechsdk.ResultReason.NoMatch:
    print("No speech could be recognized: {}".format(speech_recognition_result.no_match_details))
elif speech_recognition_result.reason == speechsdk.ResultReason.Canceled:
    cancellation_details = speech_recognition_result.cancellation_details
    print("Speech Recognition canceled: {}".format(cancellation_details.reason))
    if cancellation_details.reason == speechsdk.CancellationReason.Error:
        print("Error details: {}".format(cancellation_details.error_details))
        print("Did you set the speech resource key and region values?")

使用连续识别

前面的示例使用单次性识别，这种识别方法识别单一的语音。 单个言语的结束是通过在结束时倾听静音或处理最长 15 秒音频时确定的。

相比之下，当想要控制何时停止识别时，将使用连续识别。 它要求你连接到 EventSignal 以获取识别结果。 若要停止识别，必须调用stop_continuous_recognition（）或stop_continuous_recognition_async（）。 下面是如何在音频输入文件中执行连续识别的示例。

首先定义输入并初始化 SpeechRecognizer：

audio_config = speechsdk.audio.AudioConfig(filename=weatherfilename)
speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config, audio_config=audio_config)

接下来，创建一个变量来管理语音识别的状态。 将变量设置为False，因为在识别开始时，您可以放心地假设它未完成。

done = False

现在，创建一个回调函数，以便在收到 evt 时停止连续识别。 请记住以下几点：

def stop_cb(evt):
    print('CLOSING on {}'.format(evt))
    speech_recognizer.stop_continuous_recognition()
    global done
    done = True

下面的代码示例演示如何将回调连接到从 SpeechRecognizer 发送的事件。 事件包括：

  • recognizing：包含中间识别结果的事件的信号。
  • recognized：指示包含最终识别结果的事件的信号，表明识别已成功完成。
  • session_started：用于指示表明识别会话（即操作）开始的事件的信号。
  • session_stopped：指示识别会话（操作）结束的事件的信号。
  • canceled：用于指示包含已取消识别结果事件的信号。 这些结果指示因直接取消请求而取消的识别尝试。 或者，它们表示传输或协议失败。
speech_recognizer.recognizing.connect(lambda evt: print('RECOGNIZING: {}'.format(evt)))
speech_recognizer.recognized.connect(lambda evt: print('RECOGNIZED: {}'.format(evt)))
speech_recognizer.session_started.connect(lambda evt: print('SESSION STARTED: {}'.format(evt)))
speech_recognizer.session_stopped.connect(lambda evt: print('SESSION STOPPED {}'.format(evt)))
speech_recognizer.canceled.connect(lambda evt: print('CANCELED {}'.format(evt)))

speech_recognizer.session_stopped.connect(stop_cb)
speech_recognizer.canceled.connect(stop_cb)

设置所有内容后，可以调用 start_continuous_recognition（）：

speech_recognizer.start_continuous_recognition()
while not done:
    time.sleep(.5)

更改源语言

语音识别的常见任务是指定输入（或源）语言。 以下示例演示如何将输入语言更改为德语。 在代码中，找到 SpeechConfig 实例并直接在其下方添加此行：

speech_config.speech_recognition_language="de-DE"

speech_recognition_language 是一个参数，它采用字符串作为参数。 支持的语言区域列表见 语音服务的语言和语音支持。

语言识别

如果需要识别音频源中的语言，然后将其转录为文本，则可以将语言识别与语音转文本结合使用。

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

使用自定义终结点

使用 自定义语音，可以上传自己的数据、测试和训练自定义模型、比较模型之间的准确性，并将模型部署到自定义终结点。 以下示例演示如何设置自定义终结点。

speech_config = speechsdk.SpeechConfig(subscription="YourSpeechResoureKey", region="YourServiceRegion")
speech_config.endpoint_id = "YourEndpointId"
speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config)

运行和使用容器

语音容器提供通过语音 SDK 和语音 CLI 访问的基于 Websocket 的查询终结点 API。 默认情况下，语音 SDK 和语音 CLI 使用公共语音服务。 若要使用容器，需要更改初始化方法。 使用容器主机 URL，而不是密钥和区域。

有关容器的详细信息，请参阅 使用 Docker 安装和运行语音容器中的主机 URL。

语义分割

语义分段是语音识别分段策略，旨在缓解与基于沉默的分段相关的问题：

  • 细分不足：当用户长时间不暂停说话时，他们可以看到长时间的文本序列，而不会中断（“文本墙”），这严重降低了其可读性体验。
  • 过度分段：当用户短暂暂停时，静音检测机制可能会错误地分段。

语义分段并非仅仅依赖静音超时，而是在检测到句子结束标点符号（如“.”或“？”）时主要进行分段并返回最终结果。 通过提高语义完整性和段落质量改善了用户体验，并防止中间结果持续时间过长。

若要使用语义分割，需要在用于创建SpeechRecognizer的实例SpeechConfig上设置以下属性：

speech_config.set_property(speechsdk.PropertyId.Speech_SegmentationStrategy, "Semantic")

语义分段的一些限制如下所示：

  • 需要使用语音 SDK 版本 1.41 或更高版本才能使用语义分段。
  • 语义分段仅用于 连续识别。 这包括听写和字幕等情境。 它不应在单一识别模式或交互式方案中使用。
  • 部分语言和区域设置不支持语义分割。
  • 语义分段尚不支持置信度分数和 NBest 列表。 因此，如果使用置信度分数或 NBest 列表，则不建议进行语义分段。

流后优化（预览版）

流后优化通过与实时流并行地运行第二个识别过程来提高最终转录的准确性。 中间结果和部分结果保持低时延。 仅最终结果替换为更准确的版本，该版本使用更广泛的音频上下文。

若要启用流后优化，请在SpeechConfig实例上设置SpeechServiceResponse_PostProcessingOption属性。

speechConfig->SetProperty(PropertyId::SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speechConfig.SetProperty(PropertyId.SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speechConfig.setProperty(PropertyId.SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speech_config.set_property(
    speechsdk.PropertyId.SpeechServiceResponse_PostProcessingOption,
    "PostRefinement"
)

流后优化时的一些重要注意事项：

  • 后流优化在应对较长的语音内容时效果最佳，比如对话、会议录音以及口述听写等场景。 对于非常简短的短语，优化的结果可能与标准结果相同。
  • 流后优化和语义分段不能一起使用。
  • 流后优化和 TrueText 是同一 SpeechServiceResponse_PostProcessingOption 属性的单独值。 一次只能设置一个值。
  • 后流优化仅在公开预览版阶段的部分 Azure 区域中可用。

有关后期处理选项的详细信息，请参阅 如何使用后期处理。

重要

后处理优化功能目前处于公共预览阶段。 准确性改进因语言和区域设置而异。 对于某些区域设置，可能不会有明显的质量提升，并且最终结果可能会与你使用标准识别时所看到的结果有所差异。 预览期间仅支持单语识别。 多语言和自动语言识别不适用于流后优化。

参考文档 | 包（NuGet） | 在GitHub上的附加示例

本操作指南介绍如何在 Foundry 工具中使用Azure语音进行实时语音转文本转换。 实时语音识别非常适合需要即时听录的应用程序，例如听写、呼叫中心协助和实时会议的字幕。

若要了解如何为示例应用程序设置环境，请参阅 快速入门：识别语音并将其转换为文本。

创建语音配置实例

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

  1. 在 Azure 门户中创建用于语音的 Foundry 资源。 获取语音资源密钥和终结点。
  2. SpeechConfig使用以下代码创建实例。 将 YourSpeechKey 和 YourSpeechEndpoint 替换为你的语音资源密钥和终结点。
using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Audio;

class Program 
{
    async static Task Main(string[] args)
    {
        var speechConfig = SpeechConfig.FromEndpoint(new Uri("YourSpeechEndpoint"), "YourSpeechKey");
    }
}

可以通过其他几种方式进行初始化 SpeechConfig ：

  • 使用终结点，并传入语音服务终结点。 密钥或授权令牌是可选的。
  • 使用主机，并传入主机地址。 密钥或授权令牌是可选的。
  • 将授权令牌与关联的区域/位置配合使用。

注意

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

识别来自麦克风的语音

若要通过设备麦克风识别语音，请使用FromDefaultMicrophoneInput()方法创建AudioConfig实例。 然后通过传递speechConfig和audioConfig来初始化SpeechRecognizer对象。

using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Audio;

class Program 
{
    async static Task FromMic(SpeechConfig speechConfig)
    {
        using var audioConfig = AudioConfig.FromDefaultMicrophoneInput();
        using var speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);

        Console.WriteLine("Speak into your microphone.");
        var speechRecognitionResult = await speechRecognizer.RecognizeOnceAsync();
        Console.WriteLine($"RECOGNIZED: Text={speechRecognitionResult.Text}");
    }

    async static Task Main(string[] args)
    {
        var speechConfig = SpeechConfig.FromEndpoint(new Uri("YourSpeechEndpoint"), "YourSpeechKey");
        await FromMic(speechConfig);
    }
}

如果要使用 特定的 音频输入设备，则需要在中 AudioConfig指定设备 ID。 若要了解如何获取设备 ID，请参阅 使用语音 SDK 选择音频输入设备。

识别文件中的语音

如果要从音频文件而不是麦克风中识别语音，则仍需要创建 AudioConfig 实例。 但是，不需要调用 FromDefaultMicrophoneInput()。 调用 FromWavFileInput() 并传递文件路径：

using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Audio;

class Program 
{
    async static Task FromFile(SpeechConfig speechConfig)
    {
        using var audioConfig = AudioConfig.FromWavFileInput("PathToFile.wav");
        using var speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);

        var speechRecognitionResult = await speechRecognizer.RecognizeOnceAsync();
        Console.WriteLine($"RECOGNIZED: Text={speechRecognitionResult.Text}");
    }

    async static Task Main(string[] args)
    {
        var speechConfig = SpeechConfig.FromEndpoint(new Uri("YourSpeechEndpoint"), "YourSpeechKey");
        await FromFile(speechConfig);
    }
}

从内存流中识别语音

对于许多用例，音频数据可能来自Azure Blob 存储，或者它已作为 byte[] 实例或类似的原始数据结构存在于内存中。 以下示例用于 PushAudioInputStream 识别语音，这实质上是抽象内存流。 示例代码执行以下操作：

  • 使用接受 byte[] 实例的 Write() 函数将原始音频数据写入 PushAudioInputStream。
  • 出于演示目的，使用 FileReader 读取 .wav 文件。 如果 byte[] 实例中已有音频数据，可以直接跳到将数据写入输入流。
  • 默认格式为 16 位、16-kHz 单脉冲编码调节（PCM）数据。 要自定义格式，可以使用静态函数将AudioStreamFormat对象传递给CreatePushStream()。
using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Audio;

class Program 
{
    async static Task FromStream(SpeechConfig speechConfig)
    {
        var reader = new BinaryReader(File.OpenRead("PathToFile.wav"));
        using var audioConfigStream = AudioInputStream.CreatePushStream();
        using var audioConfig = AudioConfig.FromStreamInput(audioConfigStream);
        using var speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);

        byte[] readBytes;
        do
        {
            readBytes = reader.ReadBytes(1024);
            audioConfigStream.Write(readBytes, readBytes.Length);
        } while (readBytes.Length > 0);

        var speechRecognitionResult = await speechRecognizer.RecognizeOnceAsync();
        Console.WriteLine($"RECOGNIZED: Text={speechRecognitionResult.Text}");
    }

    async static Task Main(string[] args)
    {
        var speechConfig = SpeechConfig.FromEndpoint(new Uri("YourSpeechEndpoint"), "YourSpeechKey");
        await FromStream(speechConfig);
    }
}

使用推送流作为输入假定音频数据是原始 PCM，并跳过任何标头。 如果未跳过标头，该 API 在某些情况下仍有效。 为获得最佳结果，请考虑实现读取标头的逻辑，使 byte[] 从音频数据的开头处开始。

处理错误

前面的示例仅从属性中获取已识别的文本 speechRecognitionResult.Text 。 若要处理错误和其他响应，需要编写一些代码来处理结果。 以下代码计算 speechRecognitionResult.Reason 属性，并：

  • 打印识别结果： ResultReason.RecognizedSpeech.
  • 如果没有识别匹配项，它会通知用户： ResultReason.NoMatch
  • 如果遇到错误，它将输出错误消息： ResultReason.Canceled.
switch (speechRecognitionResult.Reason)
{
    case ResultReason.RecognizedSpeech:
        Console.WriteLine($"RECOGNIZED: Text={speechRecognitionResult.Text}");
        break;
    case ResultReason.NoMatch:
        Console.WriteLine($"NOMATCH: Speech could not be recognized.");
        break;
    case ResultReason.Canceled:
        var cancellation = CancellationDetails.FromResult(speechRecognitionResult);
        Console.WriteLine($"CANCELED: Reason={cancellation.Reason}");

        if (cancellation.Reason == CancellationReason.Error)
        {
            Console.WriteLine($"CANCELED: ErrorCode={cancellation.ErrorCode}");
            Console.WriteLine($"CANCELED: ErrorDetails={cancellation.ErrorDetails}");
            Console.WriteLine($"CANCELED: Did you set the speech resource key and endpoint values?");
        }
        break;
}

使用连续识别

前面的示例使用单次性识别，这种识别方法识别单一的语音。 单个言语的结束是通过在结束时倾听静音或处理最长 15 秒音频时确定的。

相比之下，当想要控制何时停止识别时，将使用连续识别。 它要求你订阅Recognizing和RecognizedCanceled事件以获取识别结果。 若要停止识别，必须调用 StopContinuousRecognitionAsync。 下面是如何在音频输入文件中执行连续识别的示例。

首先定义输入并初始化 SpeechRecognizer：

using var audioConfig = AudioConfig.FromWavFileInput("YourAudioFile.wav");
using var speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);

然后创建一个 TaskCompletionSource<int> 实例来管理语音识别的状态：

var stopRecognition = new TaskCompletionSource<int>();

接下来，订阅 SpeechRecognizer 发送的事件：

  • Recognizing：包含中间识别结果的事件的信号。
  • Recognized：表示包含最终识别结果的事件的信号，即表明识别尝试成功。
  • SessionStopped：指示识别会话（操作）结束的事件的信号。
  • Canceled：包含已取消识别结果的事件的信号。 这些结果指示因直接取消请求而取消的识别尝试。 或者，它们表示传输或协议失败。
speechRecognizer.Recognizing += (s, e) =>
{
    Console.WriteLine($"RECOGNIZING: Text={e.Result.Text}");
};

speechRecognizer.Recognized += (s, e) =>
{
    if (e.Result.Reason == ResultReason.RecognizedSpeech)
    {
        Console.WriteLine($"RECOGNIZED: Text={e.Result.Text}");
    }
    else if (e.Result.Reason == ResultReason.NoMatch)
    {
        Console.WriteLine($"NOMATCH: Speech could not be recognized.");
    }
};

speechRecognizer.Canceled += (s, e) =>
{
    Console.WriteLine($"CANCELED: Reason={e.Reason}");

    if (e.Reason == CancellationReason.Error)
    {
        Console.WriteLine($"CANCELED: ErrorCode={e.ErrorCode}");
        Console.WriteLine($"CANCELED: ErrorDetails={e.ErrorDetails}");
        Console.WriteLine($"CANCELED: Did you set the speech resource key and endpoint values?");
    }

    stopRecognition.TrySetResult(0);
};

speechRecognizer.SessionStopped += (s, e) =>
{
    Console.WriteLine("\n    Session stopped event.");
    stopRecognition.TrySetResult(0);
};

设置所有内容后，调用 StartContinuousRecognitionAsync 开始识别：

await speechRecognizer.StartContinuousRecognitionAsync();

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

// Make the following call at some point to stop recognition:
// await speechRecognizer.StopContinuousRecognitionAsync();

更改源语言

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

speechConfig.SpeechRecognitionLanguage = "it-IT";

该SpeechRecognitionLanguage属性需要一个语言-区域格式的字符串。 有关支持的语言环境列表，请参阅语音服务的语言和语音支持。

语言标识

当您需要识别音频源中的语言并将其转录为文本时，可以使用语音转文本识别技术。

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

使用自定义终结点

使用 自定义语音，可以上传自己的数据、测试和训练自定义模型、比较模型之间的准确性，并将模型部署到自定义终结点。 以下示例演示如何设置自定义终结点。

var speechConfig = SpeechConfig.FromEndpoint(new Uri("YourSpeechEndpoint"), "YourSpeechKey");
speechConfig.EndpointId = "YourEndpointId";
var speechRecognizer = new SpeechRecognizer(speechConfig);

运行和使用容器

语音容器提供通过语音 SDK 和语音 CLI 访问的基于 Websocket 的查询终结点 API。 默认情况下，语音 SDK 和语音 CLI 使用公共语音服务。 若要使用容器，需要更改初始化方法。 使用容器主机 URL，而不是密钥和区域。

有关容器的详细信息，请参阅 使用 Docker 安装和运行语音容器中的主机 URL。

更改处理静音的方式

如果用户说话速度比平常快或慢，输入音频中非言语静音的默认行为可能不会达到您的预期。 静音处理常见问题包括：

  • 快速语速将多个句子连接在一起，会形成单个识别结果，而不是将句子拆分为单独的结果。
  • 慢速语音，将单个句子的各部分划分成多个结果。
  • 等待语音开始时结束得过快的单步识别。

可以通过在用于创建SpeechRecognizer的SpeechConfig实例上设置两个超时属性之一来解决这些问题：

  • 分段静音超时用于调整在某个正说着的短语被认为“完成”之前，该短语中允许的非语音音频量。
    • 较高的 值通常会使处理结果更长，并允许说话人在短语内暂停更长时间，但也会导致结果需要更长的时间才能生成。 当设置过高时，它们还可以将单独的短语合并到单个结果中。
    • 较低的值通常会使结果更短，并确保短语之间更及时和更频繁地中断，但如果设置得过低，也可能导致单个短语被分成多个结果。
    • 此超时可以设置为介于 100 到 5000 之间的整数值（以毫秒为单位），其中 500 为典型默认值。
  • 初始静音超时调整在识别尝试以“不匹配”结果结束之前，在一个短语之前允许的非语音音频量。
    • 较高的 值使演讲者有更多的时间做出反应并开始说话，但当什么都说不出来时，响应速度也会变慢。
    • 较低的值可确保提示“不匹配”，以获得更快的用户体验和更可控的音频处理，但如果设置得过低，可能会过快中断说话者。
    • 由于连续识别生成许多结果，因此此值确定“不匹配”结果到达的频率，但不会影响识别结果的内容。
    • 此超时可以设置为任何非负整数值（以毫秒为单位），或设置为 0 以完全禁用它。 5000 是单次识别的典型默认值，15000 是连续识别的典型默认值。

由于在修改这些超时时需要权衡取舍，因此应该仅在遇到与静音处理相关的问题时才更改设置。 默认值能够以最佳方式处理大多数口语音频，只有在不常见的情况下才可能会遇到问题。

例子： 用户在说出序列号（如“ABC-123-4567”）时可能会在字符组之间暂停足够长的时间，使序列号被分解成多个结果。 在这种情况下，请尝试更高的值，例如 2000 毫秒的分段静音超时：

speechConfig.SetProperty(PropertyId.Speech_SegmentationSilenceTimeoutMs, "2000");

示例：录制的演讲者的演讲速度可能足够快，可以将连续的几个句子组合在一起，而较大的识别结果每分钟只到达一到两次。 在这种情况下，将分段静音超时设置为较低的值，例如 300 毫秒：

speechConfig.SetProperty(PropertyId.Speech_SegmentationSilenceTimeoutMs, "300");

示例：单次识别要求说话者查找和阅读序列号，但在查找序列号时结束得太快。 在这种情况下，请尝试较长的初始静音超时，例如 10,000 毫秒：

speechConfig.SetProperty(PropertyId.SpeechServiceConnection_InitialSilenceTimeoutMs, "10000");

语义分割

语义分段是语音识别分段策略，旨在缓解 与基于沉默的分段相关的问题：

  • 细分不足：当用户长时间不暂停说话时，他们可以看到长时间的文本序列，而不会中断（“文本墙”），这严重降低了其可读性体验。
  • 过度分段：当用户短暂暂停时，静音检测机制可能会错误地分段。

语义分段并非仅仅依赖静音超时，而是在检测到句子结束标点符号（如“.”或“？”）时主要进行分段并返回最终结果。 通过提高语义完整性和段落质量改善了用户体验，并防止中间结果持续时间过长。

若要使用语义分割，需要在用于创建SpeechRecognizer的实例SpeechConfig上设置以下属性：

speechConfig.SetProperty(PropertyId.Speech_SegmentationStrategy, "Semantic");

语义分段的一些限制如下所示：

  • 需要使用语音 SDK 版本 1.41 或更高版本才能使用语义分段。
  • 语义分段仅用于 连续识别。 这包括听写和字幕等方案。 它不应在单一识别模式或交互式方案中使用。
  • 语义分割并不适用于所有语言和地区。
  • 语义分段尚不支持置信度分数和 NBest 列表。 因此，如果使用置信度分数或 NBest 列表，则不建议进行语义分段。

流后优化（预览版）

与实时流式传输并行运行第二个识别过程，流后优化可提高最终转录的准确性。 中间结果和部分结果保持低时延。 仅最终结果替换为更准确的版本，该版本使用更广泛的音频上下文。

若要启用流后优化，请在SpeechConfig实例上设置SpeechServiceResponse_PostProcessingOption属性。

speechConfig->SetProperty(PropertyId::SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speechConfig.SetProperty(PropertyId.SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speechConfig.setProperty(PropertyId.SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speech_config.set_property(
    speechsdk.PropertyId.SpeechServiceResponse_PostProcessingOption,
    "PostRefinement"
)

流后优化时的一些重要注意事项：

  • 后流优化在应对较长的语音内容时效果最佳，比如对话、会议录音以及口述听写等场景。 对于非常简短的短语，优化的结果可能与标准结果相同。
  • 流后优化和语义分段不能一起使用。
  • 流后优化和 TrueText 是同一 SpeechServiceResponse_PostProcessingOption 属性的单独值。 一次只能设置一个值。
  • 后流优化仅在公开预览版阶段的部分 Azure 区域中可用。

有关后期处理选项的详细信息，请参阅 如何使用后期处理。

重要

后处理优化功能目前处于公共预览阶段。 准确性改进因语言和区域设置而异。 对于某些区域设置，可能不会有明显的质量提升，并且最终结果可能会与你使用标准识别时所看到的结果有所差异。 预览期间仅支持单语识别。 多语言和自动语言识别不适用于流后优化。

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

本操作指南介绍如何在 Foundry 工具中使用Azure语音进行实时语音转文本转换。 实时语音识别非常适合需要即时听录的应用程序，例如听写、呼叫中心协助和实时会议的字幕。

若要了解如何为示例应用程序设置环境，请参阅 快速入门：识别语音并将其转换为文本。

创建语音配置实例

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

  1. 在 Azure 门户中创建用于语音的 Foundry 资源。 获取语音资源密钥和终结点。
  2. SpeechConfig使用以下代码创建实例。 将 YourSpeechEndpoint 和 YourSpeechKey 替换为您的语音资源终结点和密钥。
const speechConfig = sdk.SpeechConfig.fromEndpoint(new URL("YourSpeechEndpoint"), "YourSpeechKey");

可以通过其他几种方式进行初始化 SpeechConfig ：

  • 使用终结点，并传入语音服务终结点。 密钥或授权令牌是可选的。
  • 使用主机，并传入主机地址。 密钥或授权令牌是可选的。
  • 将授权令牌与关联的区域/位置配合使用。

注意

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

识别来自麦克风的语音

Node.js不支持从麦克风识别语音。 它仅在基于浏览器的 JavaScript 环境中受支持。 有关详细信息，请参阅 GitHub 上的 React 示例 和 从麦克风实现语音转换为文本。 React 示例显示了用于交换和管理身份验证令牌的设计模式。 它还显示从麦克风或文件中捕获音频，以便进行语音转文本转换。

注意

如果要使用 特定的 音频输入设备，则需要在中 AudioConfig指定设备 ID。 若要了解如何获取设备 ID，请参阅 使用语音 SDK 选择音频输入设备。

识别文件中的语音

要从音频文件中识别语音，请使用fromWavFileInput()方法，该方法接受Buffer对象，从而创建AudioConfig实例。 然后通过传递audioConfig和speechConfig初始化SpeechRecognizer。

const fs = require('fs');
const sdk = require("microsoft-cognitiveservices-speech-sdk");
const speechConfig = sdk.SpeechConfig.fromEndpoint("YourSpeechEndpoint", "YourSpeechKey");

function fromFile() {
    let audioConfig = sdk.AudioConfig.fromWavFileInput(fs.readFileSync("YourAudioFile.wav"));
    let speechRecognizer = new sdk.SpeechRecognizer(speechConfig, audioConfig);

    speechRecognizer.recognizeOnceAsync(result => {
        console.log(`RECOGNIZED: Text=${result.text}`);
        speechRecognizer.close();
    });
}
fromFile();

从内存流中识别语音

对于许多用例，音频数据可能来自Azure Blob 存储。 或者它已作为 ArrayBuffer 或类似的原始数据结构存在于内存中。 以下代码：

  • 使用createPushStream()创建推送流。
  • 出于演示目的，使用 fs.createReadStream 读取 .wav 文件。 如果您已经有音频数据在ArrayBuffer中，则可以直接跳过这一步骤，将内容写入输入流。
  • 使用推送流创建音频配置。
const fs = require('fs');
const sdk = require("microsoft-cognitiveservices-speech-sdk");
const speechConfig = sdk.SpeechConfig.fromEndpoint("YourSpeechEndpoint", "YourSpeechKey");

function fromStream() {
    let pushStream = sdk.AudioInputStream.createPushStream();

    fs.createReadStream("YourAudioFile.wav").on('data', function(arrayBuffer) {
        pushStream.write(arrayBuffer.slice());
    }).on('end', function() {
        pushStream.close();
    });
 
    let audioConfig = sdk.AudioConfig.fromStreamInput(pushStream);
    let speechRecognizer = new sdk.SpeechRecognizer(speechConfig, audioConfig);
    speechRecognizer.recognizeOnceAsync(result => {
        console.log(`RECOGNIZED: Text=${result.text}`);
        speechRecognizer.close();
    });
}
fromStream();

使用推流作为输入假定音频数据是无标头的原始脉冲编码调制（PCM）数据。 如果未跳过标头，该 API 在某些情况下仍有效。 为获得最佳结果，请考虑实现读取标头的逻辑，使 fs 从音频数据的开头处开始。

处理错误

前面的示例仅从属性中获取已识别的文本 result.text 。 若要处理错误和其他响应，需要编写一些代码来处理结果。 以下代码计算 result.reason 属性，并：

  • 打印识别结果： ResultReason.RecognizedSpeech.
  • 如果没有识别匹配项，它会通知用户： ResultReason.NoMatch
  • 如果遇到错误，它将输出错误消息： ResultReason.Canceled.
switch (result.reason) {
    case sdk.ResultReason.RecognizedSpeech:
        console.log(`RECOGNIZED: Text=${result.text}`);
        break;
    case sdk.ResultReason.NoMatch:
        console.log("NOMATCH: Speech could not be recognized.");
        break;
    case sdk.ResultReason.Canceled:
        const cancellation = sdk.CancellationDetails.fromResult(result);
        console.log(`CANCELED: Reason=${cancellation.reason}`);

        if (cancellation.reason == sdk.CancellationReason.Error) {
            console.log(`CANCELED: ErrorCode=${cancellation.ErrorCode}`);
            console.log(`CANCELED: ErrorDetails=${cancellation.errorDetails}`);
            console.log("CANCELED: Did you set the speech resource key and endpoint values?");
        }
        break;
    }

使用连续识别

前面的示例使用单次性识别，这种识别方法识别单一的语音。 单个言语的结束是通过在结束时倾听静音或处理最长 15 秒音频时确定的。

相比之下，当想要控制何时停止识别时，可以使用连续识别。 它要求你订阅Recognizing和RecognizedCanceled事件以获取识别结果。 若要停止识别，必须调用 [stopContinuousRecognitionAsync] （/javascript/api/microsoft-cognitiveservices-speech-sdk/speechrecognizer#microsoft-cognitiveservices-speech-sdk-speechrecognizer-stopcontinuousrecognitionasync）。 下面是如何在音频输入文件中执行连续识别的示例。

首先定义输入并初始化 SpeechRecognizer：

const speechRecognizer = new sdk.SpeechRecognizer(speechConfig, audioConfig);

接下来，订阅从 SpeechRecognizer 发送的事件：

  • recognizing：包含中间识别结果的事件的信号。
  • recognized：指示包含最终识别结果的事件的信号，表明识别已成功完成。
  • sessionStopped：指示识别会话（操作）结束的事件的信号。
  • canceled：用于指示包含已取消识别结果事件的信号。 这些结果指示因直接取消请求而取消的识别尝试。 或者，它们表示传输或协议失败。
speechRecognizer.recognizing = (s, e) => {
    console.log(`RECOGNIZING: Text=${e.result.text}`);
};

speechRecognizer.recognized = (s, e) => {
    if (e.result.reason == sdk.ResultReason.RecognizedSpeech) {
        console.log(`RECOGNIZED: Text=${e.result.text}`);
    }
    else if (e.result.reason == sdk.ResultReason.NoMatch) {
        console.log("NOMATCH: Speech could not be recognized.");
    }
};

speechRecognizer.canceled = (s, e) => {
    console.log(`CANCELED: Reason=${e.reason}`);

    if (e.reason == sdk.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 endpoint values?");
    }

    speechRecognizer.stopContinuousRecognitionAsync();
};

speechRecognizer.sessionStopped = (s, e) => {
    console.log("\n    Session stopped event.");
    speechRecognizer.stopContinuousRecognitionAsync();
};

设置所有内容后，调用 [startContinuousRecognitionAsync] （/javascript/api/microsoft-cognitiveservices-speech-sdk/speechrecognizer#microsoft-cognitiveservices-speech-sdk-speechrecognizer-startkeywordrecognitionasync）开始识别：

speechRecognizer.startContinuousRecognitionAsync();

// Make the following call at some point to stop recognition:
// speechRecognizer.stopContinuousRecognitionAsync();

更改源语言

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

speechConfig.speechRecognitionLanguage = "it-IT";

该speechRecognitionLanguage属性需要一个语言-区域格式的字符串。 支持的语言区域列表见 语音服务的语言和语音支持。

语言识别

当您需要识别音频源中的语言并将其转录为文本时，可以使用语音转文本识别技术。

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

使用自定义终结点

使用 自定义语音，可以上传自己的数据、测试和训练自定义模型、比较模型之间的准确性，并将模型部署到自定义终结点。 以下示例演示如何设置自定义终结点。

var speechConfig = SpeechSDK.SpeechConfig.fromSubscription("YourSpeechResoureKey", "YourServiceRegion");
speechConfig.endpointId = "YourEndpointId";
var speechRecognizer = new SpeechSDK.SpeechRecognizer(speechConfig);

运行和使用容器

语音容器提供通过语音 SDK 和语音 CLI 访问的基于 Websocket 的查询终结点 API。 默认情况下，语音 SDK 和语音 CLI 使用公共语音服务。 若要使用容器，需要更改初始化方法。 使用容器主机 URL，而不是密钥和区域。

有关容器的详细信息，请参阅 使用 Docker 安装和运行语音容器中的主机 URL。

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

本操作指南介绍如何在 Foundry 工具中使用Azure语音进行实时语音转文本转换。 实时语音识别非常适合需要即时听录的应用程序，例如听写、呼叫中心协助和实时会议的字幕。

若要了解如何为示例应用程序设置环境，请参阅 快速入门：识别语音并将其转换为文本。

创建语音配置实例

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

  1. 在 Azure 门户中创建用于语音的 Foundry 资源。 获取语音资源密钥和区域。
  2. 使用您的 Speech 密钥和区域创建一个SpeechConfig实例。
import com.microsoft.cognitiveservices.speech.*;
import com.microsoft.cognitiveservices.speech.audio.AudioConfig;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

public class Program {
    public static void main(String[] args) throws InterruptedException, ExecutionException, URISyntaxException {
        SpeechConfig speechConfig = SpeechConfig.fromEndpoint(new URI("<paste-your-speech-endpoint>"), "<paste-your-speech-key>");
    }
}

可以通过其他几种方式进行初始化 SpeechConfig ：

  • 使用终结点，并传入语音服务终结点。 密钥或授权令牌是可选的。
  • 使用主机，并传入主机地址。 密钥或授权令牌是可选的。
  • 将授权令牌与关联的区域/位置配合使用。

注意

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

识别来自麦克风的语音

若要通过设备麦克风识别语音，请使用fromDefaultMicrophoneInput()方法创建AudioConfig实例。 然后通过传递audioConfig和config来初始化SpeechRecognizer对象。

import com.microsoft.cognitiveservices.speech.*;
import com.microsoft.cognitiveservices.speech.audio.AudioConfig;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

public class Program {
    public static void main(String[] args) throws InterruptedException, ExecutionException, URISyntaxException {
        SpeechConfig speechConfig = SpeechConfig.fromEndpoint(new URI("<paste-your-speech-endpoint>"), "<paste-your-speech-key>");
        fromMic(speechConfig);
    }

    public static void fromMic(SpeechConfig speechConfig) throws InterruptedException, ExecutionException {
        AudioConfig audioConfig = AudioConfig.fromDefaultMicrophoneInput();
        SpeechRecognizer speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);

        System.out.println("Speak into your microphone.");
        Future<SpeechRecognitionResult> task = speechRecognizer.recognizeOnceAsync();
        SpeechRecognitionResult speechRecognitionResult = task.get();
        System.out.println("RECOGNIZED: Text=" + speechRecognitionResult.getText());
    }
}

如果要使用 特定的 音频输入设备，则需要在中 AudioConfig指定设备 ID。 若要了解如何获取设备 ID，请参阅 使用语音 SDK 选择音频输入设备。

识别文件中的语音

如果要从音频文件中识别语音，而不是使用麦克风，则仍需要创建 AudioConfig 实例。 但是，不需要调用 FromDefaultMicrophoneInput()。 调用 fromWavFileInput() 并传递文件路径：

import com.microsoft.cognitiveservices.speech.*;
import com.microsoft.cognitiveservices.speech.audio.AudioConfig;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

public class Program {
    public static void main(String[] args) throws InterruptedException, ExecutionException, URISyntaxException {
        SpeechConfig speechConfig = SpeechConfig.fromEndpoint(new URI("<paste-your-speech-endpoint>"), "<paste-your-speech-key>");
        fromFile(speechConfig);
    }

    public static void fromFile(SpeechConfig speechConfig) throws InterruptedException, ExecutionException {
        AudioConfig audioConfig = AudioConfig.fromWavFileInput("YourAudioFile.wav");
        SpeechRecognizer speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);
        
        Future<SpeechRecognitionResult> task = speechRecognizer.recognizeOnceAsync();
        SpeechRecognitionResult speechRecognitionResult = task.get();
        System.out.println("RECOGNIZED: Text=" + speechRecognitionResult.getText());
    }
}

处理错误

前面的示例仅通过使用 获取识别的文本。 若要处理错误和其他响应，需要编写一些代码来处理结果。 以下示例评估 speechRecognitionResult.getReason() 和：

  • 打印识别结果： ResultReason.RecognizedSpeech.
  • 如果没有识别匹配项，它会通知用户： ResultReason.NoMatch
  • 如果遇到错误，它将输出错误消息： ResultReason.Canceled.
switch (speechRecognitionResult.getReason()) {
    case ResultReason.RecognizedSpeech:
        System.out.println("We recognized: " + speechRecognitionResult.getText());
        exitCode = 0;
        break;
    case ResultReason.NoMatch:
        System.out.println("NOMATCH: Speech could not be recognized.");
        break;
    case ResultReason.Canceled: {
            CancellationDetails cancellation = CancellationDetails.fromResult(speechRecognitionResult);
            System.out.println("CANCELED: Reason=" + cancellation.getReason());

            if (cancellation.getReason() == CancellationReason.Error) {
                System.out.println("CANCELED: ErrorCode=" + cancellation.getErrorCode());
                System.out.println("CANCELED: ErrorDetails=" + cancellation.getErrorDetails());
                System.out.println("CANCELED: Did you set the speech resource key and region values?");
            }
        }
        break;
}

使用连续识别

前面的示例使用单次性识别，这种识别方法识别单一的语音。 单个言语的结束是通过在结束时倾听静音或处理最长 15 秒音频时确定的。

相比之下，当想要控制何时停止识别时，将使用连续识别。 它要求你订阅recognizing和recognizedcanceled事件以获取识别结果。 若要停止识别，必须调用 stopContinuousRecognitionAsync。 下面是有关如何对音频输入文件执行连续识别的示例。

首先定义输入并初始化 SpeechRecognizer：

AudioConfig audioConfig = AudioConfig.fromWavFileInput("YourAudioFile.wav");
SpeechRecognizer speechRecognizer = new SpeechRecognizer(config, audioConfig);

接下来，创建一个变量来管理语音识别的状态。 在类范围内声明一个Semaphore实例：

private static Semaphore stopTranslationWithFileSemaphore;

接下来，订阅 SpeechRecognizer 发送的事件：

  • recognizing：包含中间识别结果的事件的信号。
  • recognized：指示包含最终识别结果的事件的信号，表明识别已成功完成。
  • sessionStopped：指示识别会话（操作）结束的事件的信号。
  • canceled：用于指示包含已取消识别结果事件的信号。 这些结果指示因直接取消请求而取消的识别尝试。 或者，它们表示传输或协议失败。
// First initialize the semaphore.
stopTranslationWithFileSemaphore = new Semaphore(0);

speechRecognizer.recognizing.addEventListener((s, e) -> {
    System.out.println("RECOGNIZING: Text=" + e.getResult().getText());
});

speechRecognizer.recognized.addEventListener((s, e) -> {
    if (e.getResult().getReason() == ResultReason.RecognizedSpeech) {
        System.out.println("RECOGNIZED: Text=" + e.getResult().getText());
    }
    else if (e.getResult().getReason() == ResultReason.NoMatch) {
        System.out.println("NOMATCH: Speech could not be recognized.");
    }
});

speechRecognizer.canceled.addEventListener((s, e) -> {
    System.out.println("CANCELED: Reason=" + e.getReason());

    if (e.getReason() == CancellationReason.Error) {
        System.out.println("CANCELED: ErrorCode=" + e.getErrorCode());
        System.out.println("CANCELED: ErrorDetails=" + e.getErrorDetails());
        System.out.println("CANCELED: Did you set the speech resource key and region values?");
    }

    stopTranslationWithFileSemaphore.release();
});

speechRecognizer.sessionStopped.addEventListener((s, e) -> {
    System.out.println("\n    Session stopped event.");
    stopTranslationWithFileSemaphore.release();
});

设置所有内容后，调用 startContinuousRecognitionAsync 开始识别：

// Starts continuous recognition. Uses StopContinuousRecognitionAsync() to stop recognition.
speechRecognizer.startContinuousRecognitionAsync().get();

// Waits for completion.
stopTranslationWithFileSemaphore.acquire();

// Stops recognition.
speechRecognizer.stopContinuousRecognitionAsync().get();

更改源语言

语音识别的常见任务是指定输入（或源）语言。 以下示例演示如何将输入语言更改为法语。 在代码中，找到 SpeechConfig 实例，并直接在它下面添加此行：

config.setSpeechRecognitionLanguage("fr-FR");

setSpeechRecognitionLanguage 是一个参数，它采用字符串作为参数。 请参阅支持的语音转文本区域设置列表。

语言识别

当您需要识别音频源中的语言并将其转录为文本时，可以使用语音转文本识别技术。

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

使用自定义终结点

使用 自定义语音，可以上传自己的数据、测试和训练自定义模型、比较模型之间的准确性，并将模型部署到自定义终结点。 以下示例演示如何设置自定义终结点：

SpeechConfig speechConfig = SpeechConfig.FromSubscription("YourSpeechKey", "YourServiceRegion");
speechConfig.setEndpointId("YourEndpointId");
SpeechRecognizer speechRecognizer = new SpeechRecognizer(speechConfig);

运行和使用容器

语音容器提供通过语音 SDK 和语音 CLI 访问的基于 Websocket 的查询终结点 API。 默认情况下，语音 SDK 和语音 CLI 使用公共语音服务。 若要使用容器，需要更改初始化方法。 使用容器主机 URL，而不是密钥和区域。

有关容器的详细信息，请参阅 使用 Docker 安装和运行语音容器中的主机 URL。

语义分割

语义分段是语音识别分段策略，旨在缓解与基于沉默的分段相关的问题：

  • 细分不足：当用户长时间不暂停说话时，他们可以看到长时间的文本序列，而不会中断（“文本墙”），这严重降低了其可读性体验。
  • 过度分段：当用户短暂暂停时，静音检测机制可能会错误地分段。

语义分段并非仅仅依赖静音超时，而是在检测到句子结束标点符号（如“.”或“？”）时主要进行分段并返回最终结果。 通过提高语义完整性和段落质量改善了用户体验，并防止中间结果持续时间过长。

若要使用语义分割，需要在用于创建SpeechRecognizer的实例SpeechConfig上设置以下属性：

speechConfig.SetProperty(PropertyId.Speech_SegmentationStrategy, "Semantic");

语义分段的一些限制如下所示：

  • 需要使用语音 SDK 版本 1.41 或更高版本才能使用语义分段。
  • 语义分段仅用于 连续识别。 这包括听写和字幕等方案。 它不应在单一识别模式或交互式方案中使用。
  • 语义分割并不适用于所有语言和地区。
  • 语义分段尚不支持置信度分数和 NBest 列表。 因此，如果使用置信度分数或 NBest 列表，则不建议进行语义分段。

流后优化（预览版）

与实时流式传输并行运行第二个识别过程，流后优化可提高最终转录的准确性。 中间结果和部分结果保持低时延。 仅最终结果替换为更准确的版本，该版本使用更广泛的音频上下文。

若要启用流后优化，请在SpeechConfig实例上设置SpeechServiceResponse_PostProcessingOption属性。

speechConfig->SetProperty(PropertyId::SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speechConfig.SetProperty(PropertyId.SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speechConfig.setProperty(PropertyId.SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speech_config.set_property(
    speechsdk.PropertyId.SpeechServiceResponse_PostProcessingOption,
    "PostRefinement"
)

流后优化时的一些重要注意事项：

  • 后流优化在应对较长的语音内容时效果最佳，比如对话、会议录音以及口述听写等场景。 对于非常简短的短语，优化的结果可能与标准结果相同。
  • 流后优化和语义分段不能一起使用。
  • 流后优化和 TrueText 是同一 SpeechServiceResponse_PostProcessingOption 属性的单独值。 一次只能设置一个值。
  • 后流优化仅在公开预览版阶段的部分 Azure 区域中可用。

有关后期处理选项的详细信息，请参阅 如何使用后期处理。

重要

后处理优化功能目前处于公共预览阶段。 准确性改进因语言和区域设置而异。 对于某些区域设置，可能不会有明显的质量提升，并且最终结果可能会与你使用标准识别时所看到的结果有所差异。 预览期间仅支持单语识别。 多语言和自动语言识别不适用于流后优化。

参考文档 | 包（NuGet） | 在GitHub上的附加示例

本操作指南介绍如何在 Foundry 工具中使用Azure语音进行实时语音转文本转换。 实时语音识别非常适合需要即时听录的应用程序，例如听写、呼叫中心协助和实时会议的字幕。

若要了解如何为示例应用程序设置环境，请参阅 快速入门：识别语音并将其转换为文本。

创建语音配置实例

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

  1. 在 Azure 门户中创建用于语音的 Foundry 资源。 获取语音资源密钥和终结点。
  2. SpeechConfig使用以下代码创建实例。 将 YourSpeechKey 和 YourSpeechEndpoint 替换为你的语音资源密钥和终结点。
using namespace std;
using namespace Microsoft::CognitiveServices::Speech;

auto speechConfig = SpeechConfig::FromEndpoint("YourServiceEndpoint", "YourSpeechResourceKey");

可以通过其他几种方式进行初始化 SpeechConfig ：

  • 使用终结点，并传入语音服务终结点。 密钥或授权令牌是可选的。
  • 使用主机，并传入主机地址。 密钥或授权令牌是可选的。
  • 将授权令牌与关联的区域/位置配合使用。

注意

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

识别来自麦克风的语音

若要使用设备麦克风识别语音，请使用AudioConfig成员函数创建实例FromDefaultMicrophoneInput()。 通过传递audioConfig和config来初始化SpeechRecognizer对象。

using namespace Microsoft::CognitiveServices::Speech::Audio;

auto audioConfig = AudioConfig::FromDefaultMicrophoneInput();
auto speechRecognizer = SpeechRecognizer::FromConfig(config, audioConfig);

cout << "Speak into your microphone." << std::endl;
auto result = speechRecognizer->RecognizeOnceAsync().get();
cout << "RECOGNIZED: Text=" << result->Text << std::endl;

如果要使用 特定的 音频输入设备，则需要在中 AudioConfig指定设备 ID。 若要了解如何获取设备 ID，请参阅 使用语音 SDK 选择音频输入设备。

识别文件中的语音

如果要从音频文件中识别语音，而不是使用麦克风，则仍需要创建 AudioConfig 实例。 但是，不需要调用 FromDefaultMicrophoneInput()。 调用 FromWavFileInput() 并传递文件路径：

using namespace Microsoft::CognitiveServices::Speech::Audio;

auto audioConfig = AudioConfig::FromWavFileInput("YourAudioFile.wav");
auto speechRecognizer = SpeechRecognizer::FromConfig(config, audioConfig);

auto result = speechRecognizer->RecognizeOnceAsync().get();
cout << "RECOGNIZED: Text=" << result->Text << std::endl;

使用识别器类识别语音

适用于 C++ 的语音 SDK 的 识别器类 公开了一些可用于语音识别的方法。

单次识别

单步识别可异步识别单个言语。 单个言语的结束是通过在结束时倾听静音或处理最长 15 秒音频时确定的。 下面是通过 RecognizeOnceAsync 进行异步单拍识别的示例：

auto result = speechRecognizer->RecognizeOnceAsync().get();

需要编写一些代码来处理结果。 此示例评估 result->Reason 和：

  • 打印识别结果： ResultReason::RecognizedSpeech.
  • 如果没有识别匹配项，它会通知用户： ResultReason::NoMatch
  • 如果遇到错误，它将输出错误消息： ResultReason::Canceled.
switch (result->Reason)
{
    case ResultReason::RecognizedSpeech:
        cout << "We recognized: " << result->Text << std::endl;
        break;
    case ResultReason::NoMatch:
        cout << "NOMATCH: Speech could not be recognized." << std::endl;
        break;
    case ResultReason::Canceled:
        {
            auto cancellation = CancellationDetails::FromResult(result);
            cout << "CANCELED: Reason=" << (int)cancellation->Reason << std::endl;
    
            if (cancellation->Reason == CancellationReason::Error) {
                cout << "CANCELED: ErrorCode= " << (int)cancellation->ErrorCode << std::endl;
                cout << "CANCELED: ErrorDetails=" << cancellation->ErrorDetails << std::endl;
                cout << "CANCELED: Did you set the speech resource key and endpoint values?" << std::endl;
            }
        }
        break;
    default:
        break;
}

连续识别

连续识别比单次识别更加复杂。 它要求你订阅Recognizing和RecognizedCanceled事件以获取识别结果。 若要停止识别，必须调用 StopContinuousRecognitionAsync。 下面是对音频输入文件执行的连续识别的示例。

首先定义输入并初始化 SpeechRecognizer：

auto audioConfig = AudioConfig::FromWavFileInput("YourAudioFile.wav");
auto speechRecognizer = SpeechRecognizer::FromConfig(config, audioConfig);

接下来，创建一个变量来管理语音识别的状态。 声明 promise<void> 是因为在识别开始时，可以放心地假定它未完成：

promise<void> recognitionEnd;

接下来，订阅 SpeechRecognizer 发送的事件：

  • Recognizing：包含中间识别结果的事件的信号。
  • Recognized：指示包含最终识别结果的事件的信号，表明识别已成功完成。
  • SessionStopped：指示识别会话（操作）结束的事件的信号。
  • Canceled：用于指示包含已取消识别结果事件的信号。 这些结果指示因直接取消请求而取消的识别尝试。 或者，它们表示传输或协议失败。
speechRecognizer->Recognizing.Connect([](const SpeechRecognitionEventArgs& e)
    {
        cout << "Recognizing:" << e.Result->Text << std::endl;
    });

speechRecognizer->Recognized.Connect([](const SpeechRecognitionEventArgs& e)
    {
        if (e.Result->Reason == ResultReason::RecognizedSpeech)
        {
            cout << "RECOGNIZED: Text=" << e.Result->Text 
                 << " (text could not be translated)" << std::endl;
        }
        else if (e.Result->Reason == ResultReason::NoMatch)
        {
            cout << "NOMATCH: Speech could not be recognized." << std::endl;
        }
    });

speechRecognizer->Canceled.Connect([&recognitionEnd](const SpeechRecognitionCanceledEventArgs& e)
    {
        cout << "CANCELED: Reason=" << (int)e.Reason << std::endl;
        if (e.Reason == CancellationReason::Error)
        {
            cout << "CANCELED: ErrorCode=" << (int)e.ErrorCode << "\n"
                 << "CANCELED: ErrorDetails=" << e.ErrorDetails << "\n"
                 << "CANCELED: Did you set the speech resource key and endpoint values?" << std::endl;

            recognitionEnd.set_value(); // Notify to stop recognition.
        }
    });

speechRecognizer->SessionStopped.Connect([&recognitionEnd](const SessionEventArgs& e)
    {
        cout << "Session stopped.";
        recognitionEnd.set_value(); // Notify to stop recognition.
    });

设置所有内容后，调用 StartContinuousRecognitionAsync 开始识别：

// Starts continuous recognition. Uses StopContinuousRecognitionAsync() to stop recognition.
speechRecognizer->StartContinuousRecognitionAsync().get();

// Waits for recognition end.
recognitionEnd.get_future().get();

// Stops recognition.
speechRecognizer->StopContinuousRecognitionAsync().get();

更改源语言

语音识别的常见任务是指定输入（或源）语言。 以下示例演示如何将输入语言更改为德语。 在代码中，找到 SpeechConfig 实例并直接在其下方添加此行：

speechConfig->SetSpeechRecognitionLanguage("de-DE");

SetSpeechRecognitionLanguage 是一个参数，它采用字符串作为参数。 支持的语言区域列表见 语音服务的语言和语音支持。

语言识别

当您需要识别音频源中的语言并将其转录为文本时，可以使用语音转文本识别技术。

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

使用自定义终结点

使用 自定义语音，可以上传自己的数据、测试和训练自定义模型、比较模型之间的准确性，并将模型部署到自定义终结点。 以下示例演示如何设置自定义终结点。

auto speechConfig = SpeechConfig::FromEndpoint("YourServiceEndpoint", "YourSpeechResourceKey");
speechConfig->SetEndpointId("YourEndpointId");
auto speechRecognizer = SpeechRecognizer::FromConfig(speechConfig);

运行和使用容器

语音容器提供通过语音 SDK 和语音 CLI 访问的基于 Websocket 的查询终结点 API。 默认情况下，语音 SDK 和语音 CLI 使用公共语音服务。 若要使用容器，需要更改初始化方法。 使用容器主机 URL，而不是密钥和终结点。

有关容器的详细信息，请参阅 使用 Docker 安装和运行语音容器中的主机 URL。

语义分割

语义分段是语音识别分段策略，旨在缓解与基于沉默的分段相关的问题：

  • 细分不足：当用户长时间不暂停说话时，他们可以看到长时间的文本序列，而不会中断（“文本墙”），这严重降低了其可读性体验。
  • 过度分段：当用户短暂暂停时，静音检测机制可能会错误地分段。

语义分段并非仅仅依赖静音超时，而是在检测到句子结束标点符号（如“.”或“？”）时主要进行分段并返回最终结果。 通过提高语义完整性和段落质量改善了用户体验，并防止中间结果持续时间过长。

若要使用语义分割，需要在用于创建SpeechRecognizer的实例SpeechConfig上设置以下属性：

speechConfig->SetProperty(PropertyId::Speech_SegmentationStrategy, "Semantic");

语义分段的一些限制如下所示：

  • 需要使用语音 SDK 版本 1.41 或更高版本才能使用语义分段。
  • 语义分段仅用于 连续识别。 这包括听写和字幕等方案。 它不应在单一识别模式或交互式方案中使用。
  • 语义分割并不适用于所有语言和地区。
  • 语义分段尚不支持置信度分数和 NBest 列表。 因此，如果使用置信度分数或 NBest 列表，则不建议进行语义分段。

流后优化（预览版）

与实时流式传输并行运行第二个识别过程，流后优化可提高最终转录的准确性。 中间结果和部分结果保持低时延。 仅最终结果替换为更准确的版本，该版本使用更广泛的音频上下文。

若要启用流后优化，请在SpeechConfig实例上设置SpeechServiceResponse_PostProcessingOption属性。

speechConfig->SetProperty(PropertyId::SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speechConfig.SetProperty(PropertyId.SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speechConfig.setProperty(PropertyId.SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speech_config.set_property(
    speechsdk.PropertyId.SpeechServiceResponse_PostProcessingOption,
    "PostRefinement"
)

流后优化时的一些重要注意事项：

  • 后流优化在应对较长的语音内容时效果最佳，比如对话、会议录音以及口述听写等场景。 对于非常简短的短语，优化的结果可能与标准结果相同。
  • 流后优化和语义分段不能一起使用。
  • 流后优化和 TrueText 是同一 SpeechServiceResponse_PostProcessingOption 属性的单独值。 一次只能设置一个值。
  • 后流优化仅在公开预览版阶段的部分 Azure 区域中可用。

有关后期处理选项的详细信息，请参阅 如何使用后期处理。

重要

后处理优化功能目前处于公共预览阶段。 准确性改进因语言和区域设置而异。 对于某些区域设置，可能不会有明显的质量提升，并且最终结果可能会与你使用标准识别时所看到的结果有所差异。 预览期间仅支持单语识别。 多语言和自动语言识别不适用于流后优化。

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

本操作指南介绍如何在 Foundry 工具中使用Azure语音进行实时语音转文本转换。 实时语音识别非常适合需要即时听录的应用程序，例如听写、呼叫中心协助和实时会议的字幕。

若要了解如何为示例应用程序设置环境，请参阅 快速入门：识别语音并将其转换为文本。

识别麦克风的语音转文本

  1. 在 Azure 门户中创建用于语音的 Foundry 资源。 获取语音资源密钥和区域。
  2. 使用以下代码示例从默认设备麦克风运行语音识别。 将 YourSpeechKey 和 YourSpeechRegion 替换为你的语音资源密钥和区域。 运行脚本会在默认麦克风和输出文本上启动识别会话：
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 sessionStartedHandler(event speech.SessionEventArgs) {
	defer event.Close()
	fmt.Println("Session Started (ID=", event.SessionID, ")")
}

func sessionStoppedHandler(event speech.SessionEventArgs) {
	defer event.Close()
	fmt.Println("Session Stopped (ID=", event.SessionID, ")")
}

func recognizingHandler(event speech.SpeechRecognitionEventArgs) {
	defer event.Close()
	fmt.Println("Recognizing:", event.Result.Text)
}

func recognizedHandler(event speech.SpeechRecognitionEventArgs) {
	defer event.Close()
	fmt.Println("Recognized:", event.Result.Text)
}

func cancelledHandler(event speech.SpeechRecognitionCanceledEventArgs) {
	defer event.Close()
	fmt.Println("Received a cancellation: ", event.ErrorDetails)
	fmt.Println("Did you set the speech resource key and region values?")
}

func main() {
    subscription :=  "YourSpeechKey"
    region := "YourSpeechRegion"

	audioConfig, err := audio.NewAudioConfigFromDefaultMicrophoneInput()
	if err != nil {
		fmt.Println("Got an error: ", err)
		return
	}
	defer audioConfig.Close()
	config, err := speech.NewSpeechConfigFromSubscription(subscription, region)
	if err != nil {
		fmt.Println("Got an error: ", err)
		return
	}
	defer config.Close()
	speechRecognizer, err := speech.NewSpeechRecognizerFromConfig(config, audioConfig)
	if err != nil {
		fmt.Println("Got an error: ", err)
		return
	}
	defer speechRecognizer.Close()
	speechRecognizer.SessionStarted(sessionStartedHandler)
	speechRecognizer.SessionStopped(sessionStoppedHandler)
	speechRecognizer.Recognizing(recognizingHandler)
	speechRecognizer.Recognized(recognizedHandler)
	speechRecognizer.Canceled(cancelledHandler)
	speechRecognizer.StartContinuousRecognitionAsync()
	defer speechRecognizer.StopContinuousRecognitionAsync()
	bufio.NewReader(os.Stdin).ReadBytes('\n')
}

运行以下命令，创建链接到 GitHub 上托管的组件的 go.mod 文件：

go mod init quickstart
go get github.com/Microsoft/cognitive-services-speech-sdk-go

现在生成并运行代码：

go build
go run quickstart

有关详细信息，请参阅 SpeechConfig 类和 SpeechRecognizer 类的参考内容。

从音频文件中识别语音转文本

使用以下示例从音频文件运行语音识别。 将 YourSpeechKey 和 YourSpeechRegion 替换为你的语音资源密钥和区域。 此外，请将变量 file 替换为 .wav 文件的路径。 运行脚本时，它会识别文件中的语音并输出文本结果：

package main

import (
	"fmt"
	"time"

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

func main() {
    subscription :=  "YourSpeechKey"
    region := "YourSpeechRegion"
    file := "path/to/file.wav"

	audioConfig, err := audio.NewAudioConfigFromWavFileInput(file)
	if err != nil {
		fmt.Println("Got an error: ", err)
		return
	}
	defer audioConfig.Close()
	config, err := speech.NewSpeechConfigFromSubscription(subscription, region)
	if err != nil {
		fmt.Println("Got an error: ", err)
		return
	}
	defer config.Close()
	speechRecognizer, err := speech.NewSpeechRecognizerFromConfig(config, audioConfig)
	if err != nil {
		fmt.Println("Got an error: ", err)
		return
	}
	defer speechRecognizer.Close()
	speechRecognizer.SessionStarted(func(event speech.SessionEventArgs) {
		defer event.Close()
		fmt.Println("Session Started (ID=", event.SessionID, ")")
	})
	speechRecognizer.SessionStopped(func(event speech.SessionEventArgs) {
		defer event.Close()
		fmt.Println("Session Stopped (ID=", event.SessionID, ")")
	})

	task := speechRecognizer.RecognizeOnceAsync()
	var outcome speech.SpeechRecognitionOutcome
	select {
	case outcome = <-task:
	case <-time.After(5 * time.Second):
		fmt.Println("Timed out")
		return
	}
	defer outcome.Close()
	if outcome.Error != nil {
		fmt.Println("Got an error: ", outcome.Error)
	}
	fmt.Println("Got a recognition!")
	fmt.Println(outcome.Result.Text)
}

运行以下命令，创建链接到 GitHub 上托管的组件的 go.mod 文件：

go mod init quickstart
go get github.com/Microsoft/cognitive-services-speech-sdk-go

现在生成并运行代码：

go build
go run quickstart

有关详细信息，请参阅 SpeechConfig 类和 SpeechRecognizer 类的参考内容。

运行和使用容器

语音容器提供通过语音 SDK 和语音 CLI 访问的基于 Websocket 的查询终结点 API。 默认情况下，语音 SDK 和语音 CLI 使用公共语音服务。 若要使用容器，需要更改初始化方法。 使用容器主机 URL，而不是密钥和区域。

有关容器的详细信息，请参阅 使用 Docker 安装和运行语音容器中的主机 URL。

参考文档 | 软件包（下载） | GitHub上的附加示例

本操作指南介绍如何在 Foundry 工具中使用Azure语音进行实时语音转文本转换。 实时语音识别非常适合需要即时听录的应用程序，例如听写、呼叫中心协助和实时会议的字幕。

若要了解如何为示例应用程序设置环境，请参阅 快速入门：识别语音并将其转换为文本。

安装语音 SDK 和示例

Azure-Samples/cognitive-services-speech-sdk 存储库包含为 iOS 和 Mac Objective-C 编写的示例。 选择一个链接以查看每个示例的安装说明：

有关更多信息，请参阅 Objective-C 语音 SDK 参考文档。

使用自定义终结点

使用 自定义语音，可以上传自己的数据、测试和训练自定义模型、比较模型之间的准确性，并将模型部署到自定义终结点。 以下示例演示如何设置自定义终结点：

SPXSpeechConfiguration *speechConfig = [[SPXSpeechConfiguration alloc] initWithSubscription:"YourSpeechResoureKey" region:"YourServiceRegion"];
speechConfig.endpointId = "YourEndpointId";
SPXSpeechRecognizer* speechRecognizer = [[SPXSpeechRecognizer alloc] init:speechConfig];

运行和使用容器

语音容器提供通过语音 SDK 和语音 CLI 访问的基于 Websocket 的查询终结点 API。 默认情况下，语音 SDK 和语音 CLI 使用公共语音服务。 若要使用容器，需要更改初始化方法。 使用容器主机 URL，而不是密钥和区域。

有关容器的详细信息，请参阅 使用 Docker 安装和运行语音容器中的主机 URL。

本操作指南介绍如何在 Foundry 工具中使用Azure语音进行实时语音转文本转换。 实时语音识别非常适合需要即时听录的应用程序，例如听写、呼叫中心协助和实时会议的字幕。

若要了解如何为示例应用程序设置环境，请参阅 快速入门：识别语音并将其转换为文本。

识别来自麦克风的语音

插入并打开电脑麦克风。 关闭可能还使用麦克风的任何应用。 某些计算机具有内置麦克风，而其他计算机需要配置蓝牙设备。

现在，你已准备好运行语音 CLI 来识别来自麦克风的语音。 在命令行中，切换到包含语音 CLI 二进制文件的目录。 然后运行以下命令：

spx recognize --microphone

注意

语音 CLI 默认为英语。 你可以从语音转文本表中选择不同语言。 例如，添加 --source de-DE 以识别德语语音。

对着麦克风说话，你可以实时看到将你的话语转录成文字。 语音 CLI 会在静默期间后停止，或选择 Ctrl+C 时停止。

识别文件中的语音

语音 CLI 可以识别多种文件格式和自然语言的语音。 在此示例中，可以使用包含英语语音的任何 .wav 文件（16 kHz 或 8 kHz、16 位和单声道 PCM）。 或者，如果需要快速示例，请下载文件 whatstheweatherlike.wav，并将其复制到语音 CLI 二进制文件所在的同一目录。

使用以下命令运行语音 CLI 来识别音频文件中找到的语音：

spx recognize --file whatstheweatherlike.wav

注意

语音 CLI 默认为英语。 可以从语音转换为文本的表中选择不同的语言。 例如，添加 --source de-DE 以识别德语语音。

语音 CLI 在屏幕上显示语音的文本听录。

运行和使用容器

语音容器提供通过语音 SDK 和语音 CLI 访问的基于 Websocket 的查询终结点 API。 默认情况下，语音 SDK 和语音 CLI 使用公共语音服务。 若要使用容器，需要更改初始化方法。 使用容器主机 URL，而不是密钥和区域。

有关容器的详细信息，请参阅 使用 Docker 安装和运行语音容器中的主机 URL。

参考文档 | 软件包（下载） | GitHub上的附加示例

本操作指南介绍如何在 Foundry 工具中使用Azure语音进行实时语音转文本转换。 实时语音识别非常适合需要即时听录的应用程序，例如听写、呼叫中心协助和实时会议的字幕。

若要了解如何为示例应用程序设置环境，请参阅 快速入门：识别语音并将其转换为文本。

安装语音 SDK 和示例

Azure-Samples/cognitive-services-speech-sdk 存储库包含使用 Swift for iOS 和 Mac 编写的示例。 选择一个链接以查看每个示例的安装说明：

  • 在 macOS 上使用 Swift 进行语音识别
  • 在 iOS 的 Swift 中识别语音

有关更多信息，请参阅 Objective-C 语音 SDK 参考文档。

使用自定义终结点

使用 自定义语音，可以上传自己的数据、测试和训练自定义模型、比较模型之间的准确性，并将模型部署到自定义终结点。 以下示例演示如何设置自定义终结点：

let speechConfig = SPXSpeechConfiguration(subscription: "YourSpeechResoureKey", region: "YourServiceRegion");
speechConfig.endpointId = "YourEndpointId";
let speechRecognizer = SPXSpeechRecognizer(speechConfiguration: speechConfig);

运行和使用容器

语音容器提供通过语音 SDK 和语音 CLI 访问的基于 Websocket 的查询终结点 API。 默认情况下，语音 SDK 和语音 CLI 使用公共语音服务。 若要使用容器，需要更改初始化方法。 使用容器主机 URL，而不是密钥和区域。

有关容器的详细信息，请参阅 使用 Docker 安装和运行语音容器中的主机 URL。

相关内容

  • Last updated on