Início Rápido: Reconhecer e verificar quem está a falar

Artigo
02/16/2024

Documentação de referência | Pacote (NuGet) | Exemplos Adicionais no GitHub

Neste início rápido, irá aprender padrões básicos de conceção para reconhecimento de orador com o SDK de Voz, incluindo:

Verificação independente de texto e texto.
Identificação de orador para identificar uma amostra de voz entre um grupo de vozes.
A eliminar perfis de voz.

Para ver os conceitos de reconhecimento de orador de alto nível, veja o artigo Descrição geral . Veja o nó Referência no painel esquerdo para obter uma lista das plataformas suportadas.

Importante

A Microsoft limita o acesso ao reconhecimento de orador. Aplique-se para utilizá-lo através do formulário revisão limitada de acesso do reconhecimento de orador do Azure AI . Após a aprovação, pode aceder às APIs de Reconhecimento de Orador.

Pré-requisitos

Subscrição do Azure – crie uma gratuitamente.
Criar um recurso de Voz no portal do Azure.
A sua chave de recurso de Voz e região. Após a implementação do recurso de Voz, selecione Ir para recurso para ver e gerir chaves. Para obter mais informações sobre os recursos dos serviços de IA do Azure, veja Obter as chaves do recurso.

Instalar o SDK de Voz

Antes de começar, tem de instalar o SDK de Voz. Consoante a sua plataforma, utilize as seguintes instruções:

Importar dependências

Para executar os exemplos neste artigo, inclua as seguintes using instruções na parte superior do script:

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Audio;

Criar uma configuração de voz

Para chamar o serviço de Voz com o SDK de Voz, tem de criar uma SpeechConfig instância. Neste exemplo, vai criar uma SpeechConfig instância com uma chave de subscrição e uma região. Também vai criar alguns códigos automáticos básicos para utilizar no resto deste artigo, que modifica para diferentes personalizações.

Importante

Lembre-se de remover a chave do código quando terminar e nunca a publicar publicamente. Para produção, utilize uma forma segura de armazenar e aceder às suas credenciais, como o Azure Key Vault. Veja o artigo segurança dos serviços de IA do Azure para obter mais informações.

public class Program 
{
    static async Task Main(string[] args)
    {
        // replace with your own subscription key 
        string subscriptionKey = "YourSubscriptionKey";
        // replace with your own subscription region 
        string region = "YourSubscriptionRegion";
        var config = SpeechConfig.FromSubscription(subscriptionKey, region);
    }
}

Verificação dependente de texto

A verificação de orador é o ato de confirmar que um orador corresponde a uma voz conhecida ou inscrita. O primeiro passo é inscrever um perfil de voz para que o serviço tenha algo com que comparar exemplos de voz futuros. Neste exemplo, vai inscrever o perfil através de uma estratégia dependente de texto , que requer uma frase de acesso específica para utilizar para inscrição e verificação. Veja os documentos de referência para obter uma lista de frases de acesso suportadas.

Comece por criar a seguinte função na sua Program turma para inscrever um perfil de voz:

public static async Task VerificationEnroll(SpeechConfig config, Dictionary<string, string> profileMapping)
{
    using (var client = new VoiceProfileClient(config))
    using (var profile = await client.CreateProfileAsync(VoiceProfileType.TextDependentVerification, "en-us"))
    {
        var phraseResult = await client.GetActivationPhrasesAsync(VoiceProfileType.TextDependentVerification, "en-us");
        using (var audioInput = AudioConfig.FromDefaultMicrophoneInput())
        {
            Console.WriteLine($"Enrolling profile id {profile.Id}.");
            // give the profile a human-readable display name
            profileMapping.Add(profile.Id, "Your Name");

            VoiceProfileEnrollmentResult result = null;
            while (result is null || result.RemainingEnrollmentsCount > 0)
            {
                Console.WriteLine($"Speak the passphrase, \"${phraseResult.Phrases[0]}\"");
                result = await client.EnrollProfileAsync(profile, audioInput);
                Console.WriteLine($"Remaining enrollments needed: {result.RemainingEnrollmentsCount}");
                Console.WriteLine("");
            }
            
            if (result.Reason == ResultReason.EnrolledVoiceProfile)
            {
                await SpeakerVerify(config, profile, profileMapping);
            }
            else if (result.Reason == ResultReason.Canceled)
            {
                var cancellation = VoiceProfileEnrollmentCancellationDetails.FromResult(result);
                Console.WriteLine($"CANCELED {profile.Id}: ErrorCode={cancellation.ErrorCode} ErrorDetails={cancellation.ErrorDetails}");
            }
        }
    }
}

Nesta função, await client.CreateProfileAsync() é o que realmente cria o novo perfil de voz. Depois de criado, especifique como irá introduzir exemplos de áudio com AudioConfig.FromDefaultMicrophoneInput() este exemplo para capturar áudio do seu dispositivo de entrada predefinido. Em seguida, vai inscrever exemplos de áudio num while ciclo que controla o número de amostras restantes e que são necessárias para a inscrição. Em cada iteração, client.EnrollProfileAsync(profile, audioInput) pede-lhe para falar a frase de acesso no microfone e adiciona o exemplo ao perfil de voz.

Após a conclusão da inscrição, chame await SpeakerVerify(config, profile, profileMapping) para verificar o perfil que acabou de criar. Adicione outra função para definir SpeakerVerify.

public static async Task SpeakerVerify(SpeechConfig config, VoiceProfile profile, Dictionary<string, string> profileMapping)
{
    var speakerRecognizer = new SpeakerRecognizer(config, AudioConfig.FromDefaultMicrophoneInput());
    var model = SpeakerVerificationModel.FromProfile(profile);

    Console.WriteLine("Speak the passphrase to verify: \"My voice is my passport, please verify me.\"");
    var result = await speakerRecognizer.RecognizeOnceAsync(model);
    Console.WriteLine($"Verified voice profile for speaker {profileMapping[result.ProfileId]}, score is {result.Score}");
}

Nesta função, vai transmitir o VoiceProfile objeto que acabou de criar para inicializar um modelo para verificar. Em seguida, await speakerRecognizer.RecognizeOnceAsync(model) pede-lhe para voltar a falar a frase de acesso. Desta vez, valida-o em relação ao seu perfil de voz e devolve uma classificação de semelhança que varia entre 0,0 e 1,0. O result objeto também devolve Accept ou Reject, com base no facto de a frase de acesso corresponder.

Em seguida, modifique a função Main() para chamar as novas funções que criou. Além disso, tenha em atenção que cria uma Dictionary<string, string> referência para transmitir através das chamadas de função. O motivo para tal é que o serviço não permite armazenar um nome legível por humanos com um criado VoiceProfilee armazena apenas um número de ID para fins de privacidade. VerificationEnroll Na função , adiciona a este dicionário uma entrada com o ID recém-criado, juntamente com um nome de texto. Em cenários de desenvolvimento de aplicações em que precisa de apresentar um nome legível por humanos, tem de armazenar este mapeamento algures porque o serviço não consegue armazená-lo.

static async Task Main(string[] args)
{
    string subscriptionKey = "YourSubscriptionKey";
    string region = "westus";
    var config = SpeechConfig.FromSubscription(subscriptionKey, region);

    // persist profileMapping if you want to store a record of who the profile is
    var profileMapping = new Dictionary<string, string>();
    await VerificationEnroll(config, profileMapping);

    Console.ReadLine();
}

Execute o script. É-lhe pedido que diga a frase "A minha voz é o meu passaporte, verifique-me" três vezes para a inscrição e mais uma vez para verificação. O resultado devolvido é a classificação de semelhança, que pode utilizar para criar os seus próprios limiares personalizados para verificação.

Enrolling profile id 87-2cef-4dff-995b-dcefb64e203f.
Speak the passphrase, "My voice is my passport, verify me."
Remaining enrollments needed: 2

Speak the passphrase, "My voice is my passport, verify me."
Remaining enrollments needed: 1

Speak the passphrase, "My voice is my passport, verify me."
Remaining enrollments needed: 0

Speak the passphrase to verify: "My voice is my passport, verify me."
Verified voice profile for speaker Your Name, score is 0.915581

Verificação independente de texto

Ao contrário da verificação dependente do texto , a verificação independente de texto não requer três amostras de áudio , mas requer 20 segundos de áudio total.

Faça algumas alterações simples à função VerificationEnroll para mudar para a verificação independente de texto . Primeiro, altere o tipo de verificação para VoiceProfileType.TextIndependentVerification. Em seguida, altere o while ciclo para controlar result.RemainingEnrollmentsSpeechLength, que continuará a pedir-lhe para falar até que sejam capturados 20 segundos de áudio.

public static async Task VerificationEnroll(SpeechConfig config, Dictionary<string, string> profileMapping)
{
    using (var client = new VoiceProfileClient(config))
    using (var profile = await client.CreateProfileAsync(VoiceProfileType.TextIndependentVerification, "en-us"))
    {
        var phraseResult = await client.GetActivationPhrasesAsync(VoiceProfileType.TextIndependentVerification, "en-us");
        using (var audioInput = AudioConfig.FromDefaultMicrophoneInput())
        {
            Console.WriteLine($"Enrolling profile id {profile.Id}.");
            // give the profile a human-readable display name
            profileMapping.Add(profile.Id, "Your Name");

            VoiceProfileEnrollmentResult result = null;
            while (result is null || result.RemainingEnrollmentsSpeechLength > TimeSpan.Zero)
            {
                Console.WriteLine($"Speak the activation phrase, \"${phraseResult.Phrases[0]}\"");
                result = await client.EnrollProfileAsync(profile, audioInput);
                Console.WriteLine($"Remaining enrollment audio time needed: {result.RemainingEnrollmentsSpeechLength}");
                Console.WriteLine("");
            }
            
            if (result.Reason == ResultReason.EnrolledVoiceProfile)
            {
                await SpeakerVerify(config, profile, profileMapping);
            }
            else if (result.Reason == ResultReason.Canceled)
            {
                var cancellation = VoiceProfileEnrollmentCancellationDetails.FromResult(result);
                Console.WriteLine($"CANCELED {profile.Id}: ErrorCode={cancellation.ErrorCode} ErrorDetails={cancellation.ErrorDetails}");
            }
        }
    }
}

Execute o programa novamente e é devolvida a classificação de semelhança.

Enrolling profile id 4tt87d4-f2d3-44ae-b5b4-f1a8d4036ee9.
Speak the activation phrase, "<FIRST ACTIVATION PHRASE>"
Remaining enrollment audio time needed: 00:00:15.3200000

Speak the activation phrase, "<FIRST ACTIVATION PHRASE>"
Remaining enrollment audio time needed: 00:00:09.8100008

Speak the activation phrase, "<FIRST ACTIVATION PHRASE>"
Remaining enrollment audio time needed: 00:00:05.1900000

Speak the activation phrase, "<FIRST ACTIVATION PHRASE>"
Remaining enrollment audio time needed: 00:00:00.8700000

Speak the activation phrase, "<FIRST ACTIVATION PHRASE>"
Remaining enrollment audio time needed: 00:00:00

Speak the passphrase to verify: "My voice is my passport, please verify me."
Verified voice profile for speaker Your Name, score is 0.849409

Identificação de orador

A identificação de orador é utilizada para determinar quem está a falar de um determinado grupo de vozes inscritas. O processo é semelhante à verificação independente de texto. A principal diferença é a capacidade de verificar em vários perfis de voz ao mesmo tempo, em vez de verificar num único perfil.

Crie uma função IdentificationEnroll para inscrever múltiplos perfis de voz. O processo de inscrição para cada perfil é o mesmo que o processo de inscrição para verificação independente de texto. O processo requer 20 segundos de áudio para cada perfil. Esta função aceita uma lista de cadeias profileNames e irá criar um novo perfil de voz para cada nome na lista. A função devolve uma lista de VoiceProfile objetos, que utiliza na função seguinte para identificar um orador.

public static async Task<List<VoiceProfile>> IdentificationEnroll(SpeechConfig config, List<string> profileNames, Dictionary<string, string> profileMapping)
{
    List<VoiceProfile> voiceProfiles = new List<VoiceProfile>();
    using (var client = new VoiceProfileClient(config))
    {
        var phraseResult = await client.GetActivationPhrasesAsync(VoiceProfileType.TextIndependentVerification, "en-us");
        foreach (string name in profileNames)
        {
            using (var audioInput = AudioConfig.FromDefaultMicrophoneInput())
            {
                var profile = await client.CreateProfileAsync(VoiceProfileType.TextIndependentIdentification, "en-us");
                Console.WriteLine($"Creating voice profile for {name}.");
                profileMapping.Add(profile.Id, name);

                VoiceProfileEnrollmentResult result = null;
                while (result is null || result.RemainingEnrollmentsSpeechLength > TimeSpan.Zero)
                {
                    Console.WriteLine($"Speak the activation phrase, \"${phraseResult.Phrases[0]}\" to add to the profile enrollment sample for {name}.");
                    result = await client.EnrollProfileAsync(profile, audioInput);
                    Console.WriteLine($"Remaining enrollment audio time needed: {result.RemainingEnrollmentsSpeechLength}");
                    Console.WriteLine("");
                }
                voiceProfiles.Add(profile);
            }
        }
    }
    return voiceProfiles;
}

Crie a seguinte função SpeakerIdentification para submeter um pedido de identificação. A principal diferença nesta função em comparação com um pedido de verificação de orador é a utilização de SpeakerIdentificationModel.FromProfiles(), que aceita uma lista de VoiceProfile objetos.

public static async Task SpeakerIdentification(SpeechConfig config, List<VoiceProfile> voiceProfiles, Dictionary<string, string> profileMapping) 
{
    var speakerRecognizer = new SpeakerRecognizer(config, AudioConfig.FromDefaultMicrophoneInput());
    var model = SpeakerIdentificationModel.FromProfiles(voiceProfiles);

    Console.WriteLine("Speak some text to identify who it is from your list of enrolled speakers.");
    var result = await speakerRecognizer.RecognizeOnceAsync(model);
    Console.WriteLine($"The most similar voice profile is {profileMapping[result.ProfileId]} with similarity score {result.Score}");
}

Altere a função Main() para a seguinte. Cria uma lista de cadeias profileNames, que transmite à sua IdentificationEnroll() função. É-lhe pedido que crie um novo perfil de voz para cada nome nesta lista, para que possa adicionar mais nomes para criar mais perfis para amigos ou colegas.

static async Task Main(string[] args)
{
    // replace with your own subscription key 
    string subscriptionKey = "YourSubscriptionKey";
    // replace with your own subscription region 
    string region = "YourSubscriptionRegion";
    var config = SpeechConfig.FromSubscription(subscriptionKey, region);

    // persist profileMapping if you want to store a record of who the profile is
    var profileMapping = new Dictionary<string, string>();
    var profileNames = new List<string>() { "Your name", "A friend's name" };
    
    var enrolledProfiles = await IdentificationEnroll(config, profileNames, profileMapping);
    await SpeakerIdentification(config, enrolledProfiles, profileMapping);

    foreach (var profile in enrolledProfiles)
    {
        profile.Dispose();
    }
    Console.ReadLine();
}

Execute o script. É-lhe pedido para falar para inscrever exemplos de voz para o primeiro perfil. Após a conclusão da inscrição, ser-lhe-á pedido que repita este processo para cada nome na profileNames lista. Após a conclusão de cada inscrição, ser-lhe-á pedido para que qualquer pessoa fale. Em seguida, o serviço tenta identificar esta pessoa entre os perfis de voz inscritos.

Este exemplo devolve apenas a correspondência mais próxima e a respetiva pontuação de semelhança. Para obter a resposta completa que inclui as cinco principais classificações de semelhança, adicione string json = result.Properties.GetProperty(PropertyId.SpeechServiceResponse_JsonResult) à sua SpeakerIdentification função.

Alterar o tipo de entrada de áudio

Os exemplos neste artigo utilizam o microfone do dispositivo predefinido como entrada para exemplos de áudio. Em cenários em que precisa de utilizar ficheiros de áudio em vez da entrada do microfone, altere qualquer instância de AudioConfig.FromDefaultMicrophoneInput() para AudioConfig.FromWavFileInput(path/to/your/file.wav) para mudar para uma entrada de ficheiro. Também pode ter entradas mistas com um microfone para inscrição e ficheiros para verificação, por exemplo.

Eliminar inscrições de perfis de voz

Para eliminar um perfil inscrito, utilize a DeleteProfileAsync() função no VoiceProfileClient objeto . A função de exemplo seguinte mostra como eliminar um perfil de voz de um ID de perfil de voz conhecido:

public static async Task DeleteProfile(SpeechConfig config, string profileId) 
{
    using (var client = new VoiceProfileClient(config))
    {
        var profile = new VoiceProfile(profileId);
        await client.DeleteProfileAsync(profile);
    }
}

Documentação de referência | Pacote (NuGet) | Exemplos Adicionais no GitHub

Neste início rápido, irá aprender padrões básicos de conceção para reconhecimento de orador com o SDK de Voz, incluindo:

Verificação independente de texto e texto.
Identificação de orador para identificar um exemplo de voz entre um grupo de vozes.
A eliminar perfis de voz.

Para ver os conceitos de reconhecimento de orador de alto nível, veja o artigo Descrição geral . Veja o nó Referência no painel esquerdo para obter uma lista das plataformas suportadas.

Importante

A Microsoft limita o acesso ao reconhecimento de orador. Aplique-se para utilizá-lo através do formulário revisão limitada de acesso de reconhecimento de orador do Azure AI . Após a aprovação, pode aceder às APIs de Reconhecimento de Orador.

Pré-requisitos

Subscrição do Azure – crie uma gratuitamente.
Criar um recurso de Voz no portal do Azure.
A sua chave de recurso de Voz e região. Após a implementação do recurso de Voz, selecione Ir para recurso para ver e gerir chaves. Para obter mais informações sobre os recursos dos serviços de IA do Azure, veja Obter as chaves do recurso.

Instalar o SDK de Voz

Antes de começar, tem de instalar o SDK de Voz. Consoante a sua plataforma, utilize as seguintes instruções:

Importar dependências

Para executar os exemplos neste artigo, adicione as seguintes instruções na parte superior do ficheiro .cpp:

#include <iostream>
#include <stdexcept>
// Note: Install the NuGet package Microsoft.CognitiveServices.Speech.
#include <speechapi_cxx.h>

using namespace std;
using namespace Microsoft::CognitiveServices::Speech;

// Note: Change the locale if desired.
auto profile_locale = "en-us";
auto audio_config = Audio::AudioConfig::FromDefaultMicrophoneInput();
auto ticks_per_second = 10000000;

Criar uma configuração de voz

Para chamar o serviço de Voz com o SDK de Voz, crie uma SpeechConfig classe. Esta classe inclui informações sobre a sua subscrição, como a sua chave e região associada, ponto final, anfitrião ou token de autorização.

Importante

shared_ptr<SpeechConfig> GetSpeechConfig()
{
    auto subscription_key = 'PASTE_YOUR_SPEECH_SUBSCRIPTION_KEY_HERE';
    auto region = 'PASTE_YOUR_SPEECH_ENDPOINT_REGION_HERE';
    auto config = SpeechConfig::FromSubscription(subscription_key, region);
    return config;
}

Verificação dependente de texto

Função TextDependentVerification

Comece por criar a TextDependentVerification função:

void TextDependentVerification(shared_ptr<VoiceProfileClient> client, shared_ptr<SpeakerRecognizer> recognizer)
{
    std::cout << "Text Dependent Verification:\n\n";
    // Create the profile.
    auto profile = client->CreateProfileAsync(VoiceProfileType::TextDependentVerification, profile_locale).get();
    std::cout << "Created profile ID: " << profile->GetId() << "\n";
    AddEnrollmentsToTextDependentProfile(client, profile);
    SpeakerVerify(profile, recognizer);
    // Delete the profile.
    client->DeleteProfileAsync(profile);
}

Esta função cria um objeto VoiceProfile com o método CreateProfileAsync . Existem três tipos de VoiceProfile:

TextIndependentIdentification
TextDependentVerification
TextIndependentVerification

Neste caso, passa VoiceProfileType::TextDependentVerification para CreateProfileAsync.

Em seguida, chama duas funções auxiliares que irá definir a seguir AddEnrollmentsToTextDependentProfile e SpeakerVerify. Por fim, chame DeleteProfileAsync para limpar o perfil.

Função AddEnrollmentsToTextDependentProfile

Defina a seguinte função para inscrever um perfil de voz:

void AddEnrollmentsToTextDependentProfile(shared_ptr<VoiceProfileClient> client, shared_ptr<VoiceProfile> profile)
{
    shared_ptr<VoiceProfileEnrollmentResult> enroll_result = nullptr;
    auto phraseResult = client->GetActivationPhrasesAsync(profile->GetType(), profile_locale).get();
    auto phrases = phraseResult->GetPhrases();
    while (enroll_result == nullptr || enroll_result->GetEnrollmentInfo(EnrollmentInfoType::RemainingEnrollmentsCount) > 0)
    {
        if (phrases != nullptr && phrases->size() > 0)
        {
            std::cout << "Please say the passphrase, \"" << phrases->at(0) << "\"\n";
            enroll_result = client->EnrollProfileAsync(profile, audio_config).get();
            std::cout << "Remaining enrollments needed: " << enroll_result->GetEnrollmentInfo(EnrollmentInfoType::RemainingEnrollmentsCount) << ".\n";
        }
        else
        {
            std::cout << "No passphrases received, enrollment not attempted.\n\n";
        }
    }
    std::cout << "Enrollment completed.\n\n";
}

Nesta função, vai inscrever amostras de áudio num while ciclo que controla o número de amostras restantes e que são necessárias para inscrição. Em cada iteração, EnrollProfileAsync pede-lhe para falar a frase de acesso no microfone e adiciona o exemplo ao perfil de voz.

Função SpeakerVerify

Defina SpeakerVerify da seguinte forma:

void SpeakerVerify(shared_ptr<VoiceProfile> profile, shared_ptr<SpeakerRecognizer> recognizer)
{
    shared_ptr<SpeakerVerificationModel> model = SpeakerVerificationModel::FromProfile(profile);
    std::cout << "Speak the passphrase to verify: \"My voice is my passport, verify me.\"\n";
    shared_ptr<SpeakerRecognitionResult> result = recognizer->RecognizeOnceAsync(model).get();
    std::cout << "Verified voice profile for speaker: " << result->ProfileId << ". Score is: " << result->GetScore() << ".\n\n";
}

Nesta função, vai criar um objeto SpeakerVerificationModel com o método SpeakerVerificationModel::FromProfile , transmitindo o objeto VoiceProfile que criou anteriormente.

Em seguida, SpeechRecognizer::RecognizeOnceAsync pede-lhe para voltar a falar a frase de acesso. Desta vez, valida-a no seu perfil de voz e devolve uma classificação de semelhança que varia entre 0,0 e 1,0. O objeto SpeakerRecognitionResult também devolve Accept ou Reject se a frase de acesso corresponde.

Verificação independente de texto

Ao contrário da verificação dependente do texto , a verificação independente de texto não requer três amostras de áudio , mas requer 20 segundos de áudio total.

Função TextIndependentVerification

Comece por criar a TextIndependentVerification função:

void TextIndependentVerification(shared_ptr<VoiceProfileClient> client, shared_ptr<SpeakerRecognizer> recognizer)
{
    std::cout << "Text Independent Verification:\n\n";
    // Create the profile.
    auto profile = client->CreateProfileAsync(VoiceProfileType::TextIndependentVerification, profile_locale).get();
    std::cout << "Created profile ID: " << profile->GetId() << "\n";
    AddEnrollmentsToTextIndependentProfile(client, profile);
    SpeakerVerify(profile, recognizer);
    // Delete the profile.
    client->DeleteProfileAsync(profile);
}

Tal como a TextDependentVerification função, esta função cria um objeto VoiceProfile com o método CreateProfileAsync .

Neste caso, passa VoiceProfileType::TextIndependentVerification para CreateProfileAsync.

Em seguida, chama duas funções auxiliares: AddEnrollmentsToTextIndependentProfile, que definirá a seguir e SpeakerVerify, que já definiu. Por fim, chame DeleteProfileAsync para limpar o perfil.

AddEnrollmentsToTextIndependentProfile

Defina a seguinte função para inscrever um perfil de voz:

void AddEnrollmentsToTextIndependentProfile(shared_ptr<VoiceProfileClient> client, shared_ptr<VoiceProfile> profile)
{
    shared_ptr<VoiceProfileEnrollmentResult> enroll_result = nullptr;
    auto phraseResult = client->GetActivationPhrasesAsync(profile->GetType(), profile_locale).get();
    auto phrases = phraseResult->GetPhrases();
    while (enroll_result == nullptr || enroll_result->GetEnrollmentInfo(EnrollmentInfoType::RemainingEnrollmentsSpeechLength) > 0)
    {
        if (phrases != nullptr && phrases->size() > 0)
        {
            std::cout << "Please say the activation phrase, \"" << phrases->at(0) << "\"\n";
            enroll_result = client->EnrollProfileAsync(profile, audio_config).get();
            std::cout << "Remaining audio time needed: " << enroll_result->GetEnrollmentInfo(EnrollmentInfoType::RemainingEnrollmentsSpeechLength) / ticks_per_second << " seconds.\n";
        }
        else
        {
            std::cout << "No activation phrases received, enrollment not attempted.\n\n";
        }
    }
    std::cout << "Enrollment completed.\n\n";
}

Nesta função, vai inscrever amostras de áudio num while ciclo que controla o número de segundos restantes do áudio e que são necessários para a inscrição. Em cada iteração, EnrollProfileAsync pede-lhe para falar com o microfone e adiciona o exemplo ao perfil de voz.

Identificação de orador

Função TextIndependentIdentification

Comece por criar a TextIndependentIdentification função:

void TextIndependentIdentification(shared_ptr<VoiceProfileClient> client, shared_ptr<SpeakerRecognizer> recognizer)
{
    std::cout << "Speaker Identification:\n\n";
    // Create the profile.
    auto profile = client->CreateProfileAsync(VoiceProfileType::TextIndependentIdentification, profile_locale).get();
    std::cout << "Created profile ID: " << profile->GetId() << "\n";
    AddEnrollmentsToTextIndependentProfile(client, profile);
    SpeakerIdentify(profile, recognizer);
    // Delete the profile.
    client->DeleteProfileAsync(profile);
}

Tal como as TextDependentVerification funções e TextIndependentVerification , esta função cria um objeto VoiceProfile com o método CreateProfileAsync .

Neste caso, passa VoiceProfileType::TextIndependentIdentification para CreateProfileAsync.

Em seguida, chama duas funções auxiliares: AddEnrollmentsToTextIndependentProfile, que já definiu e SpeakerIdentify, que irá definir a seguir. Por fim, chame DeleteProfileAsync para limpar o perfil.

Função SpeakerIdentify

Defina a função da SpeakerIdentify seguinte forma:

void SpeakerIdentify(shared_ptr<VoiceProfile> profile, shared_ptr<SpeakerRecognizer> recognizer)
{
    shared_ptr<SpeakerIdentificationModel> model = SpeakerIdentificationModel::FromProfiles({ profile });
    // Note: We need at least four seconds of audio after pauses are subtracted.
    std::cout << "Please speak for at least ten seconds to identify who it is from your list of enrolled speakers.\n";
    shared_ptr<SpeakerRecognitionResult> result = recognizer->RecognizeOnceAsync(model).get();
    std::cout << "The most similar voice profile is: " << result->ProfileId << " with similarity score: " << result->GetScore() << ".\n\n";
}

Nesta função, vai criar um objeto SpeakerIdentificationModel com o método SpeakerIdentificationModel::FromProfiles . SpeakerIdentificationModel::FromProfiles aceita uma lista de objetos VoiceProfile . Neste caso, transmite o VoiceProfile objeto que criou anteriormente. Se quiser, pode transmitir vários VoiceProfile objetos, cada um inscrito com amostras de áudio de uma voz diferente.

Em seguida, SpeechRecognizer::RecognizeOnceAsync pede-lhe para voltar a falar. Desta vez, compara a sua voz com os perfis de voz inscritos e devolve o perfil de voz mais semelhante.

Função principal

Por fim, defina a função da main seguinte forma:

int main()
{
    auto speech_config = GetSpeechConfig();
    auto client = VoiceProfileClient::FromConfig(speech_config);
    auto recognizer = SpeakerRecognizer::FromConfig(speech_config, audio_config);
    TextDependentVerification(client, recognizer);
    TextIndependentVerification(client, recognizer);
    TextIndependentIdentification(client, recognizer);
    std::cout << "End of quickstart.\n";
}

Esta função chama as funções que definiu anteriormente. Primeiro, cria um objeto VoiceProfileClient e um objeto SpeakerRecognizer .

auto speech_config = GetSpeechConfig();
auto client = VoiceProfileClient::FromConfig(speech_config);
auto recognizer = SpeakerRecognizer::FromConfig(speech_config, audio_config);

O VoiceProfileClient objeto é utilizado para criar, inscrever e eliminar perfis de voz. O SpeakerRecognizer objeto é utilizado para validar exemplos de voz em relação a um ou mais perfis de voz inscritos.

Alterar o tipo de entrada de áudio

Os exemplos neste artigo utilizam o microfone predefinido do dispositivo como entrada para exemplos de áudio. Nos cenários em que precisa de utilizar ficheiros de áudio em vez da entrada do microfone, altere a seguinte linha:

auto audio_config = Audio::AudioConfig::FromDefaultMicrophoneInput();

para:

auto audio_config = Audio::AudioConfig::FromWavFileInput("path/to/your/file.wav");

Em alternativa, substitua qualquer utilização de audio_config por Audio::AudioConfig::FromWavFileInput. Também pode ter entradas mistas ao utilizar um microfone para inscrição e ficheiros para verificação, por exemplo.

Documentação de referência | Pacote (Ir) | Exemplos Adicionais no GitHub

Neste início rápido, irá aprender padrões básicos de design para reconhecimento de orador com o SDK de Voz, incluindo:

Verificação independente de texto e texto.
Identificação de orador para identificar uma amostra de voz entre um grupo de vozes.
A eliminar perfis de voz.

Para ver os conceitos de reconhecimento de orador de alto nível, veja o artigo Descrição geral . Veja o nó Referência no painel esquerdo para obter uma lista das plataformas suportadas.

Importante

Pré-requisitos

Subscrição do Azure – crie uma gratuitamente.
Criar um recurso de Voz no portal do Azure.
A sua chave de recurso de Voz e região. Após a implementação do recurso de Voz, selecione Ir para recurso para ver e gerir chaves. Para obter mais informações sobre os recursos dos serviços de IA do Azure, veja Obter as chaves do recurso.

Configurar o ambiente

Instale o SDK de Voz para Go. Verifique o guia de instalação do SDK para obter mais requisitos

Efetuar identificação independente

Siga estes passos para criar um novo módulo GO.

Abra uma linha de comandos onde quer o novo módulo e crie um novo ficheiro com o nome independent-identification.go.

Substitua o conteúdo de independent-identification.go pelo seguinte código.

package main

import (
    "bufio"
    "fmt"
    "os"
    "time"

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

func GetNewVoiceProfileFromClient(client *speaker.VoiceProfileClient, expectedType common.VoiceProfileType) *speaker.VoiceProfile {
    future := client.CreateProfileAsync(expectedType, "en-US")
    outcome := <-future
    if outcome.Failed() {
        fmt.Println("Got an error creating profile: ", outcome.Error.Error())
        return nil
    }
    profile := outcome.Profile
    _, err := profile.Id()
    if err != nil {
        fmt.Println("Unexpected error creating profile id: ", err)
        return nil
    }
    profileType, err := profile.Type();
    if err != nil {
        fmt.Println("Unexpected error getting profile type: ", err)
        return nil
    }
    if profileType != expectedType {
        fmt.Println("Profile type does not match expected type")
        return nil
    }
    return profile
}

func EnrollProfile(client *speaker.VoiceProfileClient, profile *speaker.VoiceProfile, audioConfig *audio.AudioConfig) {
    enrollmentReason, currentReason := common.EnrollingVoiceProfile, common.EnrollingVoiceProfile
    var currentResult *speaker.VoiceProfileEnrollmentResult
    expectedEnrollmentCount := 1
    for currentReason == enrollmentReason {
        fmt.Println(`Please speak the following phrase: "I'll talk for a few seconds so you can recognize my voice in the future."`)
        enrollFuture := client.EnrollProfileAsync(profile, audioConfig)
        enrollOutcome := <-enrollFuture
        if enrollOutcome.Failed() {
            fmt.Println("Got an error enrolling profile: ", enrollOutcome.Error.Error())
            return
        }
        currentResult = enrollOutcome.Result
        currentReason = currentResult.Reason
        if currentResult.EnrollmentsCount != expectedEnrollmentCount {
            fmt.Println("Unexpected enrollments for profile: ", currentResult.RemainingEnrollmentsCount)
        }
        expectedEnrollmentCount += 1
    }
    if currentReason != common.EnrolledVoiceProfile {
        fmt.Println("Unexpected result enrolling profile: ", currentResult)
    }
}

func DeleteProfile(client *speaker.VoiceProfileClient, profile *speaker.VoiceProfile) {
    deleteFuture := client.DeleteProfileAsync(profile)
    deleteOutcome := <-deleteFuture
    if deleteOutcome.Failed() {
        fmt.Println("Got an error deleting profile: ", deleteOutcome.Error.Error())
        return
    }
    result := deleteOutcome.Result
    if result.Reason != common.DeletedVoiceProfile {
        fmt.Println("Unexpected result deleting profile: ", result)
    }
}

func main() {
    subscription :=  "YourSubscriptionKey"
    region := "YourServiceRegion"
    config, err := speech.NewSpeechConfigFromSubscription(subscription, region)
    if err != nil {
        fmt.Println("Got an error: ", err)
        return
    }
    defer config.Close()
    client, err := speaker.NewVoiceProfileClientFromConfig(config)
    if err != nil {
        fmt.Println("Got an error: ", err)
        return
    }
    defer client.Close()
    audioConfig, err := audio.NewAudioConfigFromDefaultMicrophoneInput()
    if err != nil {
        fmt.Println("Got an error: ", err)
        return
    }
    defer audioConfig.Close()
    <-time.After(10 * time.Second)
    expectedType := common.VoiceProfileType(1)

    profile := GetNewVoiceProfileFromClient(client, expectedType)
    if profile == nil {
        fmt.Println("Error creating profile")
        return
    }
    defer profile.Close()

    EnrollProfile(client, profile, audioConfig)

    profiles := []*speaker.VoiceProfile{profile}
    model, err := speaker.NewSpeakerIdentificationModelFromProfiles(profiles)
    if err != nil {
        fmt.Println("Error creating Identification model: ", err)
    }
    if model == nil {
        fmt.Println("Error creating Identification model: nil model")
        return
    }
    identifyAudioConfig, err := audio.NewAudioConfigFromDefaultMicrophoneInput()
    if err != nil {
        fmt.Println("Got an error: ", err)
        return
    }
    defer identifyAudioConfig.Close()
    speakerRecognizer, err := speaker.NewSpeakerRecognizerFromConfig(config, identifyAudioConfig)
    if err != nil {
        fmt.Println("Got an error: ", err)
        return
    }
    identifyFuture := speakerRecognizer.IdentifyOnceAsync(model)
    identifyOutcome := <-identifyFuture
    if identifyOutcome.Failed() {
        fmt.Println("Got an error identifying profile: ", identifyOutcome.Error.Error())
        return
    }
    identifyResult := identifyOutcome.Result
    if identifyResult.Reason != common.RecognizedSpeakers {
        fmt.Println("Got an unexpected result identifying profile: ", identifyResult)
    }
    expectedID, _ := profile.Id()
    if identifyResult.ProfileID != expectedID {
        fmt.Println("Got an unexpected profile id identifying profile: ", identifyResult.ProfileID)
    }
    if identifyResult.Score < 1.0 {
        fmt.Println("Got an unexpected score identifying profile: ", identifyResult.Score)
    }

    DeleteProfile(client, profile)
    bufio.NewReader(os.Stdin).ReadBytes('\n')
}

No independent-identification.go, substitua pela YourSubscriptionKey sua chave de recurso de Voz e substitua pela YourServiceRegion região do recurso de Voz.

Importante

Lembre-se de remover a chave do código quando terminar e nunca a publicar publicamente. Para produção, utilize uma forma segura de armazenar e aceder às suas credenciais, como o Azure Key Vault. Veja o artigo segurança dos serviços de IA do Azure para obter mais informações.

Execute os seguintes comandos para criar um go.mod ficheiro que liga a componentes alojados no GitHub:

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

Agora, crie e execute o código:

go build
go run independent-identification

Efetuar verificação independente

Siga estes passos para criar um novo módulo GO.

Abra uma linha de comandos onde quer o novo módulo e crie um novo ficheiro com o nome independent-verification.go.

Substitua o conteúdo de independent-verification.go pelo seguinte código.

package main

import (
    "bufio"
    "fmt"
    "os"
    "time"

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

func GetNewVoiceProfileFromClient(client *speaker.VoiceProfileClient, expectedType common.VoiceProfileType) *speaker.VoiceProfile {
    future := client.CreateProfileAsync(expectedType, "en-US")
    outcome := <-future
    if outcome.Failed() {
        fmt.Println("Got an error creating profile: ", outcome.Error.Error())
        return nil
    }
    profile := outcome.Profile
    _, err := profile.Id()
    if err != nil {
        fmt.Println("Unexpected error creating profile id: ", err)
        return nil
    }
    profileType, err := profile.Type();
    if err != nil {
        fmt.Println("Unexpected error getting profile type: ", err)
        return nil
    }
    if profileType != expectedType {
        fmt.Println("Profile type does not match expected type")
        return nil
    }
    return profile
}

func EnrollProfile(client *speaker.VoiceProfileClient, profile *speaker.VoiceProfile, audioConfig *audio.AudioConfig) {
    enrollmentReason, currentReason := common.EnrollingVoiceProfile, common.EnrollingVoiceProfile
    var currentResult *speaker.VoiceProfileEnrollmentResult
    expectedEnrollmentCount := 1
    for currentReason == enrollmentReason {
        fmt.Println(`Please speak the following phrase: "I'll talk for a few seconds so you can recognize my voice in the future."`)
        enrollFuture := client.EnrollProfileAsync(profile, audioConfig)
        enrollOutcome := <-enrollFuture
        if enrollOutcome.Failed() {
            fmt.Println("Got an error enrolling profile: ", enrollOutcome.Error.Error())
            return
        }
        currentResult = enrollOutcome.Result
        currentReason = currentResult.Reason
        if currentResult.EnrollmentsCount != expectedEnrollmentCount {
            fmt.Println("Unexpected enrollments for profile: ", currentResult.RemainingEnrollmentsCount)
        }
        expectedEnrollmentCount += 1
    }
    if currentReason != common.EnrolledVoiceProfile {
        fmt.Println("Unexpected result enrolling profile: ", currentResult)
    }
}

func DeleteProfile(client *speaker.VoiceProfileClient, profile *speaker.VoiceProfile) {
    deleteFuture := client.DeleteProfileAsync(profile)
    deleteOutcome := <-deleteFuture
    if deleteOutcome.Failed() {
        fmt.Println("Got an error deleting profile: ", deleteOutcome.Error.Error())
        return
    }
    result := deleteOutcome.Result
    if result.Reason != common.DeletedVoiceProfile {
        fmt.Println("Unexpected result deleting profile: ", result)
    }
}

func main() {
    subscription :=  "YourSubscriptionKey"
    region := "YourServiceRegion"
    config, err := speech.NewSpeechConfigFromSubscription(subscription, region)
    if err != nil {
        fmt.Println("Got an error: ", err)
        return
    }
    defer config.Close()
    client, err := speaker.NewVoiceProfileClientFromConfig(config)
    if err != nil {
        fmt.Println("Got an error: ", err)
        return
    }
    defer client.Close()
    audioConfig, err := audio.NewAudioConfigFromDefaultMicrophoneInput()
    if err != nil {
        fmt.Println("Got an error: ", err)
        return
    }
    defer audioConfig.Close()
    <-time.After(10 * time.Second)
    expectedType := common.VoiceProfileType(3)

    profile := GetNewVoiceProfileFromClient(client, expectedType)
    if profile == nil {
        fmt.Println("Error creating profile")
        return
    }
    defer profile.Close()

    EnrollProfile(client, profile, audioConfig)

    model, err := speaker.NewSpeakerVerificationModelFromProfile(profile)
    if err != nil {
        fmt.Println("Error creating Verification model: ", err)
    }
    if model == nil {
        fmt.Println("Error creating Verification model: nil model")
        return
    }
    verifyAudioConfig, err := audio.NewAudioConfigFromDefaultMicrophoneInput()
    if err != nil {
        fmt.Println("Got an error: ", err)
        return
    }
    defer verifyAudioConfig.Close()
    speakerRecognizer, err := speaker.NewSpeakerRecognizerFromConfig(config, verifyAudioConfig)
    if err != nil {
        fmt.Println("Got an error: ", err)
        return
    }
    verifyFuture := speakerRecognizer.VerifyOnceAsync(model)
    verifyOutcome := <-verifyFuture
    if verifyOutcome.Failed() {
        fmt.Println("Got an error verifying profile: ", verifyOutcome.Error.Error())
        return
    }
    verifyResult := verifyOutcome.Result
    if verifyResult.Reason != common.RecognizedSpeaker {
        fmt.Println("Got an unexpected result verifying profile: ", verifyResult)
    }
    expectedID, _ := profile.Id()
    if verifyResult.ProfileID != expectedID {
        fmt.Println("Got an unexpected profile id verifying profile: ", verifyResult.ProfileID)
    }
    if verifyResult.Score < 1.0 {
        fmt.Println("Got an unexpected score verifying profile: ", verifyResult.Score)
    }

    DeleteProfile(client, profile)
    bufio.NewReader(os.Stdin).ReadBytes('\n')
}

No independent-verification.go, substitua pela YourSubscriptionKey sua chave de recurso de Voz e substitua pela YourServiceRegion região do recurso de Voz.

Execute os seguintes comandos para criar um go.mod ficheiro que liga a componentes alojados no GitHub:

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

Agora, crie e execute o código:

go build
go run independent-verification

Limpar os recursos

Pode utilizar o portal do Azure ou a Interface de Linha de Comandos (CLI) do Azure para remover o recurso de Voz que criou.

Documentação de referência | Exemplos Adicionais no GitHub

O SDK de Voz para Java suporta o reconhecimento de orador, mas ainda não incluímos um guia aqui. Selecione outra linguagem de programação para começar e saber mais sobre os conceitos ou veja a referência java e exemplos ligados desde o início deste artigo.

Documentação de referência | Pacote (npm) | Exemplos Adicionais no GitHub | Código fonte da biblioteca

Neste início rápido, irá aprender padrões básicos de conceção para reconhecimento de orador com o SDK de Voz, incluindo:

Verificação independente de texto e texto.
Identificação de orador para identificar uma amostra de voz entre um grupo de vozes.
A eliminar perfis de voz.

Para ver os conceitos de reconhecimento de orador de alto nível, veja o artigo Descrição geral . Veja o nó Referência no painel esquerdo para obter uma lista das plataformas suportadas.

Importante

Pré-requisitos

Subscrição do Azure – crie uma gratuitamente.
Criar um recurso de Voz no portal do Azure.
A sua chave de recurso de Voz e região. Após a implementação do recurso de Voz, selecione Ir para recurso para ver e gerir chaves. Para obter mais informações sobre os recursos dos serviços de IA do Azure, veja Obter as chaves do recurso.

Instalar o SDK de Voz

Antes de começar, tem de instalar o SDK de Voz para JavaScript.

Consoante o ambiente de destino, utilize um dos seguintes procedimentos:

Transfira e extraia o ficheiro demicrosoft.cognitiveservices.speech.sdk.bundle.jsdo SDK de Voz para JavaScript . Coloque-o numa pasta acessível ao seu ficheiro HTML.

<script src="microsoft.cognitiveservices.speech.sdk.bundle.js"></script>;

Dica

Se estiver a filtrar um browser e a utilizar a <script> etiqueta, o sdk prefixo não é necessário. O sdk prefixo é um alias utilizado para atribuir um nome ao require módulo.

import * from "microsoft-cognitiveservices-speech-sdk";

Para obter mais informações sobre import, consulte Exportar e importar.

const sdk = require("microsoft-cognitiveservices-speech-sdk");

Importar dependências

Para executar os exemplos neste artigo, adicione as seguintes instruções na parte superior do ficheiro de .js:

"use strict";

/* To run this sample, install:
npm install microsoft-cognitiveservices-speech-sdk
*/
var sdk = require("microsoft-cognitiveservices-speech-sdk");
var fs = require("fs");

// Note: Change the locale if desired.
const profile_locale = "en-us";

/* Note: passphrase_files and verify_file should contain paths to audio files that contain \"My voice is my passport, verify me.\"
You can obtain these files from:
https://github.com/Azure-Samples/cognitive-services-speech-sdk/tree/fa6428a0837779cbeae172688e0286625e340942/quickstart/javascript/node/speaker-recognition/verification
*/ 
const passphrase_files = ["myVoiceIsMyPassportVerifyMe01.wav", "myVoiceIsMyPassportVerifyMe02.wav", "myVoiceIsMyPassportVerifyMe03.wav"];
const verify_file = "myVoiceIsMyPassportVerifyMe04.wav";
/* Note: identify_file should contain a path to an audio file that uses the same voice as the other files, but contains different speech. You can obtain this file from:
https://github.com/Azure-Samples/cognitive-services-speech-sdk/tree/fa6428a0837779cbeae172688e0286625e340942/quickstart/javascript/node/speaker-recognition/identification
*/
const identify_file = "aboutSpeechSdk.wav";

var subscription_key = 'PASTE_YOUR_SPEECH_SUBSCRIPTION_KEY_HERE';
var region = 'PASTE_YOUR_SPEECH_ENDPOINT_REGION_HERE';

const ticks_per_second = 10000000;

Estas instruções importam as bibliotecas necessárias e obtêm a chave e a região da subscrição do serviço de Voz a partir das variáveis de ambiente. Também especificam caminhos para ficheiros de áudio que irá utilizar nas seguintes tarefas.

Importante

Criar uma função auxiliar

Adicione a seguinte função auxiliar para ler ficheiros de áudio em fluxos para utilização pelo serviço de Voz:

function GetAudioConfigFromFile (file)
{
    return sdk.AudioConfig.fromWavFileInput(fs.readFileSync(file));
}

Nesta função, vai utilizar os métodos AudioInputStream.createPushStream e AudioConfig.fromStreamInput para criar um objeto AudioConfig . Este AudioConfig objeto representa um fluxo de áudio. Irá utilizar vários destes AudioConfig objetos durante as seguintes tarefas.

Verificação dependente de texto

Função TextDependentVerification

Comece por criar a TextDependentVerification função.

async function TextDependentVerification(client, speech_config)
{
    console.log ("Text Dependent Verification:\n");
    var profile = null;
    try {
        const type = sdk.VoiceProfileType.TextDependentVerification;
        // Create the profile.
        profile = await client.createProfileAsync(type, profile_locale);
        console.log ("Created profile ID: " + profile.profileId);
        // Get the activation phrases
        await GetActivationPhrases(type, profile_locale);
        await AddEnrollmentsToTextDependentProfile(client, profile, passphrase_files);
        const audio_config = GetAudioConfigFromFile(verify_file);
        const recognizer = new sdk.SpeakerRecognizer(speech_config, audio_config);
        await SpeakerVerify(profile, recognizer);
    }
    catch (error) {
        console.log ("Error:\n" + error);
    }
    finally {
        if (profile !== null) {
            console.log ("Deleting profile ID: " + profile.profileId);
            const deleteResult = await client.deleteProfileAsync (profile);
        }
    }
}

Esta função cria um objeto VoiceProfile com o método VoiceProfileClient.createProfileAsync . Existem três tipos de VoiceProfile:

TextIndependentIdentification
TextDependentVerification
TextIndependentVerification

Neste caso, passa VoiceProfileType.TextDependentVerification para VoiceProfileClient.createProfileAsync.

Em seguida, chama duas funções auxiliares que irá definir a seguir AddEnrollmentsToTextDependentProfile e SpeakerVerify. Por fim, chame VoiceProfileClient.deleteProfileAsync para remover o perfil.

Função AddEnrollmentsToTextDependentProfile

Defina a seguinte função para inscrever um perfil de voz:

async function AddEnrollmentsToTextDependentProfile(client, profile, audio_files)
{
    try {
        for (const file of audio_files) {
            console.log ("Adding enrollment to text dependent profile...");
            const audio_config = GetAudioConfigFromFile(file);
            const result = await client.enrollProfileAsync(profile, audio_config);
            if (result.reason === sdk.ResultReason.Canceled) {
                throw(JSON.stringify(sdk.VoiceProfileEnrollmentCancellationDetails.fromResult(result)));
            }
            else {
                console.log ("Remaining enrollments needed: " + result.privDetails["remainingEnrollmentsCount"] + ".");
            }
        };
        console.log ("Enrollment completed.\n");
    } catch (error) {
        console.log ("Error adding enrollments: " + error);
    }
}

Nesta função, vai chamar a GetAudioConfigFromFile função que definiu anteriormente para criar AudioConfig objetos a partir de exemplos de áudio. Estes exemplos de áudio contêm uma frase de acesso, como "A minha voz é o meu passaporte, verifique-me". Em seguida, pode inscrever estes exemplos de áudio com o método VoiceProfileClient.enrollProfileAsync .

Função SpeakerVerify

Defina SpeakerVerify da seguinte forma:

async function SpeakerVerify(profile, recognizer)
{
    try {
        const model = sdk.SpeakerVerificationModel.fromProfile(profile);
        const result = await recognizer.recognizeOnceAsync(model);
        console.log ("Verified voice profile for speaker: " + result.profileId + ". Score is: " + result.score + ".\n");
    } catch (error) {
        console.log ("Error verifying speaker: " + error);
    }
}

Nesta função, vai criar um objeto SpeakerVerificationModel com o método SpeakerVerificationModel.FromProfile , transmitindo o objeto VoiceProfile que criou anteriormente.

Em seguida, chame o método SpeechRecognizer.recognizeOnceAsync para validar um exemplo de áudio que contém a mesma frase de acesso que os exemplos de áudio que inscreveu anteriormente. SpeechRecognizer.recognizeOnceAsync devolve um objeto SpeakerRecognitionResult , cuja score propriedade contém uma classificação de semelhança que varia entre 0,0 e 1,0. O SpeakerRecognitionResult objeto também contém uma reason propriedade do tipo ResultReason. Se a verificação tiver sido efetuada com êxito, a reason propriedade deverá ter o valor RecognizedSpeaker.

Verificação independente de texto

Ao contrário da verificação dependente do texto , a verificação independente de texto :

Não requer que uma determinada frase de acesso seja falada. Tudo pode ser falado.
Não requer três exemplos de áudio , mas requer 20 segundos de áudio total.

Função TextIndependentVerification

Comece por criar a TextIndependentVerification função.

async function TextIndependentVerification(client, speech_config)
{
    console.log ("Text Independent Verification:\n");
    var profile = null;
    try {
        const type = sdk.VoiceProfileType.TextIndependentVerification;
        // Create the profile.
        profile = await client.createProfileAsync(type, profile_locale);
        console.log ("Created profile ID: " + profile.profileId);
        // Get the activation phrases
        await GetActivationPhrases(type, profile_locale);
        await AddEnrollmentsToTextIndependentProfile(client, profile, [identify_file]);
        const audio_config = GetAudioConfigFromFile(passphrase_files[0]);
        const recognizer = new sdk.SpeakerRecognizer(speech_config, audio_config);
        await SpeakerVerify(profile, recognizer);
    }
    catch (error) {
        console.log ("Error:\n" + error);
    }
    finally {
        if (profile !== null) {
            console.log ("Deleting profile ID: " + profile.profileId);
            const deleteResult = await client.deleteProfileAsync (profile);
        }
    }
}

Tal como a TextDependentVerification função , esta função cria um objeto VoiceProfile com o método VoiceProfileClient.createProfileAsync .

Neste caso, passa VoiceProfileType.TextIndependentVerification para createProfileAsync.

Em seguida, chama duas funções auxiliares: AddEnrollmentsToTextIndependentProfile, que irá definir a seguir, e SpeakerVerify, que já definiu. Por fim, chame VoiceProfileClient.deleteProfileAsync para remover o perfil.

AddEnrollmentsToTextIndependentProfile

Defina a seguinte função para inscrever um perfil de voz:

async function AddEnrollmentsToTextIndependentProfile(client, profile, audio_files)
{
    try {
        for (const file of audio_files) {
            console.log ("Adding enrollment to text independent profile...");
            const audio_config = GetAudioConfigFromFile(file);
            const result = await client.enrollProfileAsync (profile, audio_config);
            if (result.reason === sdk.ResultReason.Canceled) {
                throw(JSON.stringify(sdk.VoiceProfileEnrollmentCancellationDetails.fromResult(result)));
            }
            else {
                console.log ("Remaining audio time needed: " + (result.privDetails["remainingEnrollmentsSpeechLength"] / ticks_per_second) + " seconds.");
            }
        }
        console.log ("Enrollment completed.\n");
    } catch (error) {
        console.log ("Error adding enrollments: " + error);
    }
}

Nesta função, vai chamar a GetAudioConfigFromFile função que definiu anteriormente para criar AudioConfig objetos a partir de exemplos de áudio. Em seguida, pode inscrever estes exemplos de áudio com o método VoiceProfileClient.enrollProfileAsync .

Identificação de orador

Função TextIndependentIdentification

Comece por criar a TextIndependentIdentification função.

async function TextIndependentIdentification(client, speech_config)
{
    console.log ("Text Independent Identification:\n");
    var profile = null;
    try {
        const type = sdk.VoiceProfileType.TextIndependentIdentification;
        // Create the profile.
        profile = await client.createProfileAsync(type, profile_locale);
        console.log ("Created profile ID: " + profile.profileId);
        // Get the activation phrases
        await GetActivationPhrases(type, profile_locale);
        await AddEnrollmentsToTextIndependentProfile(client, profile, [identify_file]);
        const audio_config = GetAudioConfigFromFile(passphrase_files[0]);
        const recognizer = new sdk.SpeakerRecognizer(speech_config, audio_config);
        await SpeakerIdentify(profile, recognizer);
    }
    catch (error) {
        console.log ("Error:\n" + error);
    }
    finally {
        if (profile !== null) {
            console.log ("Deleting profile ID: " + profile.profileId);
            const deleteResult = await client.deleteProfileAsync (profile);
        }
    }
}

Tal como as TextDependentVerification funções e TextIndependentVerification , esta função cria um objeto VoiceProfile com o método VoiceProfileClient.createProfileAsync .

Neste caso, passa VoiceProfileType.TextIndependentIdentification para VoiceProfileClient.createProfileAsync.

Em seguida, chama duas funções auxiliares: AddEnrollmentsToTextIndependentProfile, que já definiu, e SpeakerIdentify, que irá definir a seguir. Por fim, chame VoiceProfileClient.deleteProfileAsync para remover o perfil.

Função SpeakerIdentify

Defina a função da SpeakerIdentify seguinte forma:

async function SpeakerIdentify(profile, recognizer)
{
    try {
        const model = sdk.SpeakerIdentificationModel.fromProfiles([profile]);
        const result = await recognizer.recognizeOnceAsync(model);
        console.log ("The most similar voice profile is: " + result.profileId + " with similarity score: " + result.score + ".\n");
    } catch (error) {
        console.log ("Error identifying speaker: " + error);
    }
}

Nesta função, vai criar um objeto SpeakerIdentificationModel com o método SpeakerIdentificationModel.fromProfiles , transmitindo o objeto VoiceProfile que criou anteriormente.

Em seguida, chame o método SpeechRecognizer.recognizeOnceAsync e transmita um exemplo de áudio. SpeechRecognizer.recognizeOnceAsync tenta identificar a voz deste exemplo de áudio com base nos VoiceProfile objetos que utilizou para criar o SpeakerIdentificationModel. Devolve um objeto SpeakerRecognitionResult , cuja profileId propriedade identifica o correspondente VoiceProfile, se existir, enquanto a score propriedade contém uma classificação de semelhança que varia entre 0,0 e 1,0.

Função principal

Por fim, defina a função da main seguinte forma:

async function main() {
    const speech_config = sdk.SpeechConfig.fromSubscription(subscription_key, region);
    const client = new sdk.VoiceProfileClient(speech_config);

    await TextDependentVerification(client, speech_config);
    await TextIndependentVerification(client, speech_config);
    await TextIndependentIdentification(client, speech_config);
    console.log ("End of quickstart.");
}
main();

Esta função cria um objeto VoiceProfileClient , que é utilizado para criar, inscrever e eliminar perfis de voz. Em seguida, chama as funções que definiu anteriormente.

Documentação de referência | Pacote (Transferir) | Exemplos Adicionais no GitHub

O SDK de Voz para Objective-C não suporta o reconhecimento de orador. Selecione outra linguagem de programação ou a referência Objective-C e os exemplos ligados desde o início deste artigo.

Documentação de referência | Pacote (Transferir) | Exemplos Adicionais no GitHub

O SDK de Voz para Swift não suporta o reconhecimento de orador. Selecione outra linguagem de programação ou a referência do Swift e exemplos ligados desde o início deste artigo.

Documentação de referência | Pacote (PyPi) | Exemplos Adicionais no GitHub

O SDK de Voz para Python não suporta o reconhecimento de orador. Selecione outra linguagem de programação ou a referência do Python e exemplos ligados desde o início deste artigo.

Referência | da API REST de conversão de voz em texto API REST de conversão de voz em texto para referência | de áudio breveExemplos Adicionais no GitHub

Neste início rápido, irá aprender padrões básicos de conceção para reconhecimento de orador com o SDK de Voz, incluindo:

Verificação independente de texto e texto.
Identificação de orador para identificar uma amostra de voz entre um grupo de vozes.
A eliminar perfis de voz.

Para ver os conceitos de reconhecimento de orador de alto nível, veja o artigo Descrição geral . Veja o nó Referência no painel esquerdo para obter uma lista das plataformas suportadas.

Importante

Pré-requisitos

Subscrição do Azure – crie uma gratuitamente.
Criar um recurso de Voz no portal do Azure.
A sua chave de recurso de Voz e região. Após a implementação do recurso de Voz, selecione Ir para recurso para ver e gerir chaves. Para obter mais informações sobre os recursos dos serviços de IA do Azure, veja Obter as chaves do recurso.

Verificação dependente de texto

Comece por criar um perfil de voz. Terá de inserir a sua chave e região de subscrição do serviço de Voz em cada um dos comandos curl neste artigo.

Importante

# Note Change locale if needed.
curl --location --request POST 'INSERT_ENDPOINT_HERE/speaker-recognition/verification/text-dependent/profiles?api-version=2021-09-05' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE' \
--header 'Content-Type: application/json' \
--data-raw '{
    '\''locale'\'':'\''en-us'\''
}'

Existem três tipos de perfil de voz:

Verificação dependente de texto
Verificação independente de texto
Identificação independente de texto

Neste caso, vai criar um perfil de voz de verificação dependente de texto. Deverá receber a seguinte resposta:

{
    "remainingEnrollmentsCount": 3,
    "locale": "en-us",
    "createdDateTime": "2020-09-29T14:54:29.683Z",
    "enrollmentStatus": "Enrolling",
    "modelVersion": null,
    "profileId": "714ce523-de76-4220-b93f-7c1cc1882d6e",
    "lastUpdatedDateTime": null,
    "enrollmentsCount": 0,
    "enrollmentsLength": 0.0,
    "enrollmentSpeechLength": 0.0
}

Em seguida, inscreva o perfil de voz. Para o valor do --data-binary parâmetro, especifique um ficheiro de áudio no seu computador que contenha uma das frases de acesso suportadas, como "A minha voz é o meu passaporte, verifique-me". Pode gravar um ficheiro de áudio com uma aplicação como Gravador de Voz do Windows. Em alternativa, pode gerá-lo utilizando texto em voz.

curl --location --request POST 'INSERT_ENDPOINT_HERE/speaker-recognition/verification/text-dependent/profiles/INSERT_PROFILE_ID_HERE/enrollments?api-version=2021-09-05' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE' \
--header 'Content-Type: audio/wav' \
--data-binary @'INSERT_FILE_PATH_HERE'

Deverá receber a seguinte resposta:

{
    "remainingEnrollmentsCount": 2,
    "passPhrase": "my voice is my passport verify me",
    "profileId": "714ce523-de76-4220-b93f-7c1cc1882d6e",
    "enrollmentStatus": "Enrolling",
    "enrollmentsCount": 1,
    "enrollmentsLength": 3.5,
    "enrollmentsSpeechLength": 2.88,
    "audioLength": 3.5,
    "audioSpeechLength": 2.88
}

Esta resposta indica-lhe que precisa de inscrever mais dois exemplos de áudio.

Depois de inscrever um total de três exemplos de áudio, deverá receber a seguinte resposta:

{
    "remainingEnrollmentsCount": 0,
    "passPhrase": "my voice is my passport verify me",
    "profileId": "714ce523-de76-4220-b93f-7c1cc1882d6e",
    "enrollmentStatus": "Enrolled",
    "enrollmentsCount": 3,
    "enrollmentsLength": 10.5,
    "enrollmentsSpeechLength": 8.64,
    "audioLength": 3.5,
    "audioSpeechLength": 2.88
}

Agora, está pronto para verificar um exemplo de áudio no perfil de voz. Este exemplo de áudio deve conter a mesma frase de acesso que os exemplos que utilizou para inscrever o perfil de voz.

curl --location --request POST 'INSERT_ENDPOINT_HERE/speaker-recognition/verification/text-dependent/profiles/INSERT_PROFILE_ID_HERE:verify?api-version=2021-09-05' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE' \
--header 'Content-Type: audio/wav' \
--data-binary @'INSERT_FILE_PATH_HERE'

Deverá receber a seguinte resposta:

{
    "recognitionResult": "Accept",
    "score": 1.0
}

Accept significa que a frase de acesso correspondeu e a verificação foi efetuada com êxito. A resposta também contém uma classificação de semelhança que varia entre 0,0 e 1,0.

Para concluir, elimine o perfil de voz.

curl --location --request DELETE \
'INSERT_ENDPOINT_HERE/speaker-recognition/verification/text-dependent/profiles/INSERT_PROFILE_ID_HERE?api-version=2021-09-05' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE'

Não há resposta.

Verificação independente de texto

Em contraste com a verificação dependente de texto , verificação independente de texto :

Não requer que uma determinada frase de acesso seja falada. Tudo pode ser falado.
Não requer três amostras de áudio , mas requer 20 segundos do áudio total.

Comece por criar um perfil de verificação independente de texto.

curl --location --request POST 'INSERT_ENDPOINT_HERE/speaker-recognition/verification/text-independent/profiles?api-version=2021-09-05' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE' \
--header 'Content-Type: application/json' \
--data-raw '{
    '\''locale'\'':'\''en-us'\''
}'

Deverá receber a seguinte resposta:

{
    "profileStatus": "Inactive",
    "remainingEnrollmentsSpeechLength": 20.0,
    "profileId": "3f85dca9-ffc9-4011-bf21-37fad2beb4d2",
    "locale": "en-us",
    "enrollmentStatus": "Enrolling",
    "createdDateTime": "2020-09-29T16:08:52.409Z",
    "lastUpdatedDateTime": null,
    "enrollmentsCount": 0,
    "enrollmentsLength": 0.0,
    "enrollmentSpeechLength": 0.0
    "modelVersion": null,
}

Em seguida, inscreva o perfil de voz. Mais uma vez, em vez de submeter três exemplos de áudio, tem de submeter amostras de áudio que contenham um total de 20 segundos de áudio.

curl --location --request POST 'INSERT_ENDPOINT_HERE/speaker-recognition/verification/text-independent/profiles/INSERT_PROFILE_ID_HERE/enrollments?api-version=2021-09-05' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE' \
--header 'Content-Type: audio/wav' \
--data-binary @'INSERT_FILE_PATH_HERE'

Depois de submeter amostras de áudio suficientes, deverá receber a seguinte resposta:

{
    "remainingEnrollmentsSpeechLength": 0.0,
    "profileId": "3f85dca9-ffc9-4011-bf21-37fad2beb4d2",
    "enrollmentStatus": "Enrolled",
    "enrollmentsCount": 1,
    "enrollmentsLength": 33.16,
    "enrollmentsSpeechLength": 29.21,
    "audioLength": 33.16,
    "audioSpeechLength": 29.21
}

Agora, está pronto para verificar um exemplo de áudio no perfil de voz. Mais uma vez, este exemplo de áudio não precisa de conter uma frase de acesso. Pode conter qualquer voz, mas tem de conter um total de, pelo menos, quatro segundos de áudio.

curl --location --request POST 'INSERT_ENDPOINT_HERE/speaker-recognition/verification/text-independent/profiles/INSERT_PROFILE_ID_HERE:verify?api-version=2021-09-05' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE' \
--header 'Content-Type: audio/wav' \
--data-binary @'INSERT_FILE_PATH_HERE'

Deverá receber a seguinte resposta:

{
    "recognitionResult": "Accept",
    "score": 0.9196669459342957
}

Accept significa que a verificação foi efetuada com êxito. A resposta também contém uma classificação de semelhança que varia entre 0,0 e 1,0.

Para concluir, elimine o perfil de voz.

curl --location --request DELETE 'INSERT_ENDPOINT_HERE/speaker-recognition/verification/text-independent/profiles/INSERT_PROFILE_ID_HERE?api-version=2021-09-05' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE'

Não há resposta.

Identificação de orador

Comece por criar um perfil de identificação independente de texto.

# Note Change locale if needed.
curl --location --request POST 'INSERT_ENDPOINT_HERE/speaker-recognition/identification/text-independent/profiles?api-version=2021-09-05' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE' \
--header 'Content-Type: application/json' \
--data-raw '{
    '\''locale'\'':'\''en-us'\''
}'

Deverá receber a seguinte resposta:

{
    "profileStatus": "Inactive",
    "remainingEnrollmentsSpeechLengthInSec": 20.0,
    "profileId": "de99ab38-36c8-4b82-b137-510907c61fe8",
    "locale": "en-us",
    "enrollmentStatus": "Enrolling",
    "createdDateTime": "2020-09-22T17:25:48.642Z",
    "lastUpdatedDateTime": null,
    "enrollmentsCount": 0,
    "enrollmentsLengthInSec": 0.0,
    "enrollmentsSpeechLengthInSec": 0.0,
    "modelVersion": null
}

Em seguida, inscreva o perfil de voz. Mais uma vez, tem de submeter amostras de áudio que contenham um total de 20 segundos de áudio. Estes exemplos não precisam de conter uma frase de acesso.

curl --location --request POST 'INSERT_ENDPOINT_HERE/speaker-recognition/identification/text-independent/profiles/INSERT_PROFILE_ID_HERE/enrollments?api-version=2021-09-05' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE' \
--header 'Content-Type: audio/wav' \
--data-binary @'INSERT_FILE_PATH_HERE'

Depois de submeter amostras de áudio suficientes, deverá receber a seguinte resposta:

{
    "remainingEnrollmentsSpeechLength": 0.0,
    "profileId": "de99ab38-36c8-4b82-b137-510907c61fe8",
    "enrollmentStatus": "Enrolled",
    "enrollmentsCount": 2,
    "enrollmentsLength": 36.69,
    "enrollmentsSpeechLength": 31.95,
    "audioLength": 33.16,
    "audioSpeechLength": 29.21
}

Agora, está pronto para identificar um exemplo de áudio com o perfil de voz. O comando identifique aceita uma lista delimitada por vírgulas de possíveis IDs de perfil de voz. Neste caso, irá transmitir o ID do perfil de voz que criou anteriormente. Se quiser, pode transmitir vários IDs de perfil de voz onde cada perfil de voz é inscrito com amostras de áudio de uma voz diferente.

# Profile ids comma seperated list
curl --location --request POST 'INSERT_ENDPOINT_HERE/speaker-recognition/identification/text-independent/profiles:identifySingleSpeaker?api-version=2021-09-05&profileIds=INSERT_PROFILE_ID_HERE' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE' \
--header 'Content-Type: audio/wav' \
--data-binary @'INSERT_FILE_PATH_HERE'

Deverá receber a seguinte resposta:

Success:
{
    "identifiedProfile": {
        "profileId": "de99ab38-36c8-4b82-b137-510907c61fe8",
        "score": 0.9083486
    },
    "profilesRanking": [
        {
            "profileId": "de99ab38-36c8-4b82-b137-510907c61fe8",
            "score": 0.9083486
        }
    ]
}

A resposta contém o ID do perfil de voz que corresponde mais de perto ao exemplo de áudio que submeteu. Também contém uma lista de perfis de voz candidatos, classificados por ordem de semelhança.

Para concluir, elimine o perfil de voz.

curl --location --request DELETE \
'INSERT_ENDPOINT_HERE/speaker-recognition/identification/text-independent/profiles/INSERT_PROFILE_ID_HERE?api-version=2021-09-05' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE'

Não há resposta.

A CLI de Voz suporta o reconhecimento de orador, mas ainda não incluímos um guia aqui. Selecione outra linguagem de programação para começar e saber mais sobre os conceitos.

Passos seguintes

Veja os exemplos de início rápido no GitHub

Início Rápido: Reconhecer e verificar quem está a falar

Pré-requisitos

Instalar o SDK de Voz

Importar dependências

Criar uma configuração de voz

Verificação dependente de texto

Verificação independente de texto

Identificação de orador

Alterar o tipo de entrada de áudio

Eliminar inscrições de perfis de voz

Pré-requisitos

Instalar o SDK de Voz

Importar dependências

Criar uma configuração de voz

Verificação dependente de texto

Função TextDependentVerification

Função AddEnrollmentsToTextDependentProfile

Função SpeakerVerify

Verificação independente de texto

Função TextIndependentVerification

AddEnrollmentsToTextIndependentProfile

Identificação de orador

Função TextIndependentIdentification

Função SpeakerIdentify

Função principal

Alterar o tipo de entrada de áudio

Pré-requisitos

Configurar o ambiente

Efetuar identificação independente

Efetuar verificação independente

Limpar os recursos

Pré-requisitos

Instalar o SDK de Voz

Importar dependências

Criar uma função auxiliar

Verificação dependente de texto

Função TextDependentVerification

Função AddEnrollmentsToTextDependentProfile

Função SpeakerVerify

Verificação independente de texto

Função TextIndependentVerification

AddEnrollmentsToTextIndependentProfile

Identificação de orador

Função TextIndependentIdentification

Função SpeakerIdentify

Função principal

Pré-requisitos

Verificação dependente de texto

Verificação independente de texto

Identificação de orador

Passos seguintes

Recursos adicionais