Introducción a Speaker Recognition

En este inicio rápido, aprenderá los patrones de diseño básicos de Speaker Recognition mediante el SDK de Voz, que incluyen:

• Comprobación dependiente e independiente del texto.
• Identificación del hablante para identificar una muestra de voz entre un grupo de voces.
• Eliminación de perfiles de voz.

Para obtener una visión general de los conceptos de Speaker Recognition, consulte el artículo de información general. Consulte el nodo de referencia situado en la navegación izquierda para ver una lista de las plataformas admitidas.

Prerrequisitos

En este artículo se da por sentado que tiene una cuenta de Azure y una suscripción al servicio de voz. Si no dispone de una cuenta y una suscripción, pruebe el servicio de voz de forma gratuita.

Instalación de Speech SDK

En primer lugar, deberá instalar Speech SDK. Utilice las siguientes instrucciones en función de la plataforma:

• .NET Framework
• .NET Core
• Unity
• UWP
• Xamarin

Dependencias de importación

Para ejecutar los ejemplos de este artículo, incluya las siguientes instrucciones de using al principio del script.

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

Creación de una configuración de voz

Para llamar al servicio de voz con Speech SDK, debe crear un elemento SpeechConfig. En este ejemplo, se crea un elemento SpeechConfig mediante una clave de suscripción y una región. Cree también código reutilizable básico para usarlo en el resto del artículo y que modificará cuando realice distintas personalizaciones.

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);
    }
}

Comprobación dependiente del texto

Speaker Verification es el acto de confirmar que un hablante coincide con una voz conocida o inscrita. El primer paso es inscribir un perfil de voz, de modo que el servicio tenga algo para comparar futuras muestras de voz. En este ejemplo, se inscribe el perfil mediante una estrategia dependiente del texto, que requiere que se use una frase de contraseña específica para la inscripción y la comprobación. Vea los documentos de referencia para obtener una lista de frases de contraseña admitidas.

Empiece por crear la siguiente función en la clase Program para inscribir un 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"))
    using (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}");
            }
        }
    }
}

En esta función, await client.CreateProfileAsync() es lo que crea realmente el nuevo perfil de voz. Una vez creada, debe especificar cómo va a introducir las muestras de audio. En este ejemplo, se usa AudioConfig.FromDefaultMicrophoneInput() para capturar audio del dispositivo de entrada predeterminado. A continuación, debe inscribir muestras de audio en un bucle while que realice un seguimiento del número de muestras restantes y necesarias para la inscripción. En cada iteración, client.EnrollProfileAsync(profile, audioInput) le pedirá que diga la frase de contraseña a través del micrófono y agregará la muestra al perfil de voz.

Una vez completada la inscripción, debe llamar a await SpeakerVerify(config, profile, profileMapping) para comprobarla con el perfil que acaba de crear. Agregue otra función 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}");
}

En esta función, se pasa el objeto VoiceProfile que acaba de crear para inicializar un modelo con el que realizar la comprobación. A continuación, await speakerRecognizer.RecognizeOnceAsync(model) le pide que diga de nuevo la frase de contraseña, pero esta vez la validará con el perfil de voz y devolverá una puntuación de similitud comprendida entre 0,0 y 1,0. El objeto result también devuelve Accept o Reject, en función de si la frase de contraseña coincide o no.

A continuación, modifique la función Main() para llamar a las nuevas funciones que ha creado. Además, tenga en cuenta que crea un objeto Dictionary<string, string> para pasar por referencia en las llamadas de función. El motivo es que el servicio no permite almacenar un nombre legible con un objeto VoiceProfile creado y solo almacena un número de identificación con fines de privacidad. En la función VerificationEnroll, agrega a este diccionario una entrada con el identificador recién creado, junto con un nombre de texto. En escenarios de desarrollo de aplicaciones en los que es necesario mostrar un nombre legible, debe almacenar esta asignación en algún lugar, ya que el servicio no puede almacenarla.

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();
}

Ejecute el script y se le pedirá que diga la frase My voice is my passport, verify me (Mi voz es mi pasaporte, verifícame) tres veces para la inscripción y una vez más para la comprobación. El resultado devuelto es la puntuación de similitud, que puede usar para crear sus propios umbrales personalizados para la comprobación.

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

Comprobación independiente del texto

A diferencia de la comprobación dependiente del texto, la comprobación independiente del texto:

• No requiere tres muestras de audio, pero sí 20 segundos de audio total.

Realice un par de cambios sencillos en la función VerificationEnroll para cambiar a la comprobación independiente del texto. En primer lugar, cambie el tipo de comprobación a VoiceProfileType.TextIndependentVerification. A continuación, cambie el bucle while para realizar un seguimiento de result.RemainingEnrollmentsSpeechLength, que le seguirá solicitando que hable hasta que se hayan capturado 20 segundos de audio.

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"))
    using (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}");
            }
        }
    }
}

Ejecute el programa otra vez. De nuevo, se devuelve la puntuación de similitud.

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

Identificación del hablante

Speaker Identification se utiliza para determinar quién está hablando de un grupo determinado de voces inscritas. El proceso es muy similar al de comprobación independiente del texto. La diferencia principal es que se puede realizar la comprobación con varios perfiles de voz a la vez, en lugar de con uno solo.

Cree una función IdentificationEnroll para inscribir varios perfiles de voz. El proceso de inscripción de cada perfil es el mismo que el proceso de inscripción de comprobación independiente del texto y requiere 20 segundos de audio para cada perfil. Esta función acepta una lista de cadenas profileNames y creará un nuevo perfil de voz para cada nombre de la lista. La función devuelve una lista de objetos VoiceProfile, que se usan en la siguiente función para identificar a un hablante.

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))
    using (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;
}

Cree la siguiente función SpeakerIdentification para enviar una solicitud de identificación. La diferencia principal de esta función con respecto a una solicitud de verificación del hablante es el uso de SpeakerIdentificationModel.FromProfiles(), que acepta una lista de objetos VoiceProfile.

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}");
}

Cambie la función Main() por lo siguiente. Se crea una lista de cadenas profileNames, que debe pasar a la función IdentificationEnroll(). Se le pedirá que cree un nuevo perfil de voz para cada nombre de la lista, de modo que puede agregar más nombres para crear perfiles adicionales para amigos o compañeros.

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();
}

Ejecute el script y se le pedirá que hable para inscribir las muestras de voz para el primer perfil. Una vez completada la inscripción, se le pedirá que repita este proceso para cada nombre de la lista profileNames. Una vez finalizada la inscripción, se le pedirá que cualquier persona hable y el servicio intentará identificarla entre los perfiles de voz inscritos.

Este ejemplo devuelve solo la coincidencia más cercana y su puntuación de similitud, pero puede obtener la respuesta completa que incluye las cinco mejores puntuaciones de similitud agregando string json = result.Properties.GetProperty(PropertyId.SpeechServiceResponse_JsonResult) a la función SpeakerIdentification.

Cambio del tipo de entrada de audio

En los ejemplos de este artículo se usa el micrófono del dispositivo predeterminado como entrada para las muestras de audio. Sin embargo, en escenarios en los que es necesario usar archivos de audio en lugar de entradas de micrófono, basta con cambiar cualquier instancia de AudioConfig.FromDefaultMicrophoneInput() a AudioConfig.FromWavFileInput(path/to/your/file.wav) para cambiar a una entrada de archivo. También puede tener entradas mixtas, si usa un micrófono para la inscripción y archivos para la comprobación, por ejemplo.

Eliminación de inscripciones de perfiles de voz

Para eliminar un perfil inscrito, utilice la función DeleteProfileAsync() en el objeto VoiceProfileClient. En la función de ejemplo siguiente se muestra cómo eliminar un perfil de voz de un identificador de perfil de voz conocido.

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

En este inicio rápido, aprenderá los patrones de diseño básicos de Speaker Recognition mediante el SDK de Voz, que incluyen:

• Comprobación dependiente e independiente del texto.
• Identificación del hablante para identificar una muestra de voz entre un grupo de voces.
• Eliminación de perfiles de voz.

Para obtener una visión general de los conceptos de Speaker Recognition, consulte el artículo de información general. Consulte el nodo de referencia situado en el panel de navegación izquierdo para ver una lista de las plataformas admitidas.

Pasar a los ejemplos en GitHub

Si quiere pasar directamente al código de ejemplo, consulte los ejemplos del inicio rápido de C++ en GitHub.

Requisitos previos

En este artículo se da por sentado que tiene una cuenta de Azure y una suscripción al servicio de voz. Si no dispone de una cuenta y una suscripción, pruebe el servicio de voz de forma gratuita.

Instalación de Speech SDK

En primer lugar, deberá instalar Speech SDK. Utilice las siguientes instrucciones en función de la plataforma:

• Linux
• macOS
• Windows

Dependencias de importación

Para ejecutar los ejemplos de este artículo, agregue las siguientes instrucciones al principio del archivo .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;

Creación de una configuración de voz

Para llamar al servicio de voz con Speech SDK, debe crear un elemento SpeechConfig. Esta clase incluye información sobre la suscripción, como la clave, la región asociada, el punto de conexión, el host o el token de autorización.

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;
}

Comprobación dependiente del texto

Speaker Verification es el acto de confirmar que un hablante coincide con una voz conocida o inscrita. El primer paso es inscribir un perfil de voz, de modo que el servicio tenga algo para comparar futuras muestras de voz. En este ejemplo, el perfil se inscribe mediante una estrategia dependiente del texto, que requiere que se use una frase de contraseña específica tanto para la inscripción como para la comprobación. Consulte los documentos de referencia para ver la lista de las frases de contraseña admitidas.

Función TextDependentVerification

Empiece por crear la función TextDependentVerification.

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 función crea un objeto VoiceProfile con el método CreateProfileAsync. Observe que hay tres tipos de VoiceProfile:

• TextIndependentIdentification
• TextDependentVerification
• TextIndependentVerification

En este caso, pasará VoiceProfileType::TextDependentVerification a CreateProfileAsync.

Luego, llamará a dos funciones auxiliares que definirá a continuación: AddEnrollmentsToTextDependentProfile y SpeakerVerify. Por último, llame a DeleteProfileAsync para limpiar el perfil.

Función AddEnrollmentsToTextDependentProfile

Defina la función siguiente para inscribir un perfil de voz.

void AddEnrollmentsToTextDependentProfile(shared_ptr<VoiceProfileClient> client, shared_ptr<VoiceProfile> profile)
{
    shared_ptr<VoiceProfileEnrollmentResult> enroll_result = nullptr;
    while (enroll_result == nullptr || enroll_result->GetEnrollmentInfo(EnrollmentInfoType::RemainingEnrollmentsCount) > 0)
    {
        std::cout << "Please say the passphrase, \"My voice is my passport, verify me.\"\n";
        enroll_result = client->EnrollProfileAsync(profile, audio_config).get();
        std::cout << "Remaining enrollments needed: " << enroll_result->GetEnrollmentInfo(EnrollmentInfoType::RemainingEnrollmentsCount) << ".\n";
    }
    std::cout << "Enrollment completed.\n\n";
}

Luego, inscribirá muestras de audio en un bucle while que realiza un seguimiento del número de muestras restantes y necesarias para la inscripción. En cada iteración, EnrollProfileAsync le pide que diga la frase de contraseña por el micrófono, y la muestra se agrega al perfil de voz.

Función SpeakerVerify

Defina SpeakerVerify como se indica a continuación.

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";
}

En esta función, creará un objeto SpeakerVerificationModel con el método SpeakerVerificationModel::FromProfile y pasará el objeto VoiceProfile que creó anteriormente.

Luego, SpeechRecognizer::RecognizeOnceAsync le pide que diga de nuevo la frase de contraseña, pero esta vez la validará con el perfil de voz y devolverá una puntuación de similitud comprendida entre 0,0 y 1,0. El objeto SpeakerRecognitionResult también devuelve Accept o Reject, según coincida o no la frase de contraseña.

Comprobación independiente del texto

A diferencia de la comprobación dependiente del texto, la comprobación independiente del texto no requiere tres muestras de audio, pero sí requiere 20 segundos de audio total.

Función TextIndependentVerification

Empiece por crear la función TextIndependentVerification.

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);
}

Al igual que la función TextDependentVerification, esta función crea un objeto VoiceProfile con el método CreateProfileAsync.

En este caso, pasará VoiceProfileType::TextIndependentVerification a CreateProfileAsync.

Luego, llamará a dos funciones auxiliares: AddEnrollmentsToTextIndependentProfile, que definirá a continuación y SpeakerVerify, que ya ha definido. Por último, llame a DeleteProfileAsync para limpiar el perfil.

AddEnrollmentsToTextIndependentProfile

Defina la función siguiente para inscribir un perfil de voz.

void AddEnrollmentsToTextIndependentProfile(shared_ptr<VoiceProfileClient> client, shared_ptr<VoiceProfile> profile)
{
    shared_ptr<VoiceProfileEnrollmentResult> enroll_result = nullptr;
    while (enroll_result == nullptr || enroll_result->GetEnrollmentInfo(EnrollmentInfoType::RemainingEnrollmentsSpeechLength) > 0)
    {
        std::cout << "Continue speaking to add to the profile enrollment sample.\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";
    }
    std::cout << "Enrollment completed.\n\n";
}

En esta función, inscribirá las muestras de audio en un bucle while que realiza un seguimiento del número de segundos de audio restantes y necesarios para la inscripción. En cada iteración, EnrollProfileAsync le pide que hable por el micrófono, y la muestra se agrega al perfil de voz.

Identificación del hablante

Speaker Identification se utiliza para determinar quién está hablando de un grupo determinado de voces inscritas. El proceso es muy similar al de comprobación independiente del texto. La diferencia principal es que se puede realizar la comprobación con varios perfiles de voz a la vez, en lugar de con uno solo.

Función TextIndependentIdentification

Empiece por crear la función TextIndependentIdentification.

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);
}

Al igual que las funciones TextDependentVerification y TextIndependentVerification, esta función crea un objeto VoiceProfile con el método CreateProfileAsync.

En este caso, pasará VoiceProfileType::TextIndependentIdentification a CreateProfileAsync.

Luego, llamará a dos funciones auxiliares: AddEnrollmentsToTextIndependentProfile, que ya ha definido y SpeakerIdentify, que definirá a continuación. Por último, llame a DeleteProfileAsync para limpiar el perfil.

Función SpeakerIdentify

defina la función SpeakerIdentify de la siguiente manera.

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";
}

En esta función, creará un objeto SpeakerIdentificationModel con el método SpeakerIdentificationModel:: FromProfiles. SpeakerIdentificationModel::FromProfiles acepta una lista de objetos VoiceProfile. En este caso, simplemente pasará el objeto VoiceProfile que creó anteriormente. Sin embargo, si lo desea, puede pasar varios objetos VoiceProfile, cada uno inscrito con muestras de audio de una voz diferente.

Luego, SpeechRecognizer::RecognizeOnceAsync le pide que hable de nuevo. Esta vez se compara su voz con los perfiles de voz inscritos y se devuelve el perfil de voz más parecido.

Función main

Por último, defina la función main como de la siguiente manera.

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 función simplemente llama a las funciones que definió anteriormente. Sin embargo, primero crea un objeto VoiceProfileClient y un objeto SpeakerRecognizer.

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

VoiceProfileClient se usa para crear, inscribir y eliminar perfiles de voz. SpeakerRecognizer se utiliza para validar muestras de voz con uno o varios perfiles de voz inscritos.

Cambio del tipo de entrada de audio

En los ejemplos de este artículo se usa el micrófono del dispositivo predeterminado como entrada para las muestras de audio. Sin embargo, en escenarios en los que necesite usar archivos de audio en lugar de la entrada de micrófono, solo tiene que cambiar la línea siguiente:

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

a:

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

También puede reemplazar el uso de audio_config por Audio::AudioConfig::FromWavFileInput. También puede tener entradas mixtas, si usa un micrófono para la inscripción y archivos para la comprobación, por ejemplo.

En este inicio rápido, aprenderá los patrones de diseño básicos de Speaker Recognition mediante el SDK de Voz, que incluyen:

• Comprobación dependiente e independiente del texto.
• Identificación del hablante para identificar una muestra de voz entre un grupo de voces.
• Eliminación de perfiles de voz.

Para obtener una visión general de los conceptos de Speaker Recognition, consulte el artículo de información general. Consulte el nodo de referencia situado en el panel de navegación izquierdo para ver una lista de las plataformas admitidas.

Pasar a los ejemplos en GitHub

Si quiere pasar directamente al código de ejemplo, consulte los ejemplos del inicio rápido de JavaScript en GitHub.

Requisitos previos

En este artículo se da por sentado que tiene una cuenta de Azure y una suscripción al servicio de voz. Si no dispone de una cuenta y una suscripción, pruebe el servicio de voz de forma gratuita.

Instalación de Speech SDK

En primer lugar, deberá instalar Speech SDK para JavaScript. Utilice las siguientes instrucciones en función de la plataforma:

• Node.js
• Explorador web

Además, en función del entorno de destino, use una de las siguientes:

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

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

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

Dependencias de importación

Para ejecutar los ejemplos de este artículo, agregue las siguientes instrucciones al principio del archivo .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 instrucciones importan las bibliotecas necesarias y obtienen la clave y región de la suscripción del servicio Voz de las variables de entorno. También especifican las rutas de acceso a los archivos de audio que usará en las siguientes tareas.

Creación de funciones de asistente

Agregue la siguiente función del asistente para leer archivos de audio en secuencias que los usa el servicio Voz.

/* From: https://github.com/Azure-Samples/cognitive-services-speech-sdk/blob/fa6428a0837779cbeae172688e0286625e340942/quickstart/javascript/node/speaker-recognition/verification/dependent-verification.js#L8
*/
function GetAudioConfigFromFile (file)
{
    let pushStream = sdk.AudioInputStream.createPushStream();
    fs.createReadStream(file).on("data", function(arrayBuffer) {
        pushStream.write(arrayBuffer.buffer);
    }).on("end", function() {
        pushStream.close();
    });
    return sdk.AudioConfig.fromStreamInput(pushStream);
}

En esta función, se usan los métodos AudioInputStream. createPushStream y AudioConfig. fromStreamInput para crear un objeto AudioConfig. Este objeto AudioConfig representa una secuencia de audio. En las siguientes tareas, utilizará varios de estos objetos AudioConfig.

Comprobación dependiente del texto

Speaker Verification es el acto de confirmar que un hablante coincide con una voz conocida o inscrita. El primer paso es inscribir un perfil de voz, de modo que el servicio tenga algo para comparar futuras muestras de voz. En este ejemplo, el perfil se inscribe mediante una estrategia dependiente del texto, que requiere que se use una frase de contraseña específica tanto para la inscripción como para la comprobación. Consulte los documentos de referencia para ver la lista de las frases de contraseña admitidas.

Función TextDependentVerification

Empiece por crear la función TextDependentVerification.

async function TextDependentVerification(client, speech_config)
{
    console.log ("Text Dependent Verification:\n");
    var profile = null;
    try {
        // Create the profile.
        profile = await new Promise ((resolve, reject) => {
            client.createProfileAsync (sdk.VoiceProfileType.TextDependentVerification, profile_locale, result => { resolve(result); }, error => { reject(error); });
        });
        console.log ("Created profile ID: " + profile.profileId);
        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);
            await new Promise ((resolve, reject) => {
                client.deleteProfileAsync (profile, result => { resolve(result); }, error => { reject(error); });
            });
        }
    }
}

Esta función crea un objeto VoiceProfile con el método VoiceProfileClient.createProfileAsync. Observe que hay tres tipos de VoiceProfile:

• TextIndependentIdentification
• TextDependentVerification
• TextIndependentVerification

En este caso, pasará VoiceProfileType.TextDependentVerification a VoiceProfileClient.createProfileAsync.

Luego, llamará a dos funciones auxiliares que definirá a continuación: AddEnrollmentsToTextDependentProfile y SpeakerVerify. Por último, llamará a VoiceProfileClient. deleteProfileAsync para quitar el perfil.

Función AddEnrollmentsToTextDependentProfile

Defina la función siguiente para inscribir un perfil de voz.

async function AddEnrollmentsToTextDependentProfile(client, profile, audio_files)
{
    for (var i = 0; i < audio_files.length; i++) {
        console.log ("Adding enrollment to text dependent profile...");
        const audio_config = GetAudioConfigFromFile (audio_files[i]);
        const result = await new Promise ((resolve, reject) => {
            client.enrollProfileAsync (profile, audio_config, result => { resolve(result); }, error => { reject(error); });
        });
        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");
}

En esta función, se llama a la función GetAudioConfigFromFile, que se ha definido anteriormente, para crear objetos AudioConfig a partir de muestras de audio. Estas muestras de audio contienen una frase de contraseña, como "My voice is my passport, verify me". Luego, se inscriben estas muestras de audio mediante el método VoiceProfileClient. enrollProfileAsync.

Función SpeakerVerify

Defina SpeakerVerify como se indica a continuación.

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

En esta función, creará un objeto SpeakerVerificationModel con el método SpeakerVerificationModel.FromProfile y pasará el objeto VoiceProfile que creó anteriormente.

A continuación, llamará al método SpeechRecognizer. recognizeOnceAsync para validar una muestra de audio que contiene la misma frase de contraseña que las muestras de audio que inscribió anteriormente. SpeechRecognizer.recognizeOnceAsync devuelve un objeto SpeakerRecognitionResult cuya score, propiedad contiene una puntuación de similitud comprendida entre 0,0 y 1,0. El objeto SpeakerRecognitionResult también contiene una propiedad reason del tipo ResultReason. Si la comprobación se realizó correctamente, la propiedad reason debería tener el valor RecognizedSpeaker.

Comprobación independiente del texto

A diferencia de la comprobación dependiente del texto, la comprobación independiente del texto:

• No es preciso que se diga una frase de contraseña determinada, se puede decir cualquier cosa.
• No se necesitan tres muestras de audio, pero sí 20 segundos de audio en total.

Función TextIndependentVerification

Empiece por crear la función TextIndependentVerification.

async function TextIndependentVerification(client, speech_config)
{
    console.log ("Text Independent Verification:\n");
    var profile = null;
    try {
        // Create the profile.
        profile = await new Promise ((resolve, reject) => {
            client.createProfileAsync (sdk.VoiceProfileType.TextIndependentVerification, profile_locale, result => { resolve(result); }, error => { reject(error); });
        });
        console.log ("Created profile ID: " + profile.profileId);
        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);
            await new Promise ((resolve, reject) => {
                client.deleteProfileAsync (profile, result => { resolve(result); }, error => { reject(error); });
            });
        }
    }
}

Al igual que la función TextDependentVerification, esta función crea un objeto VoiceProfile con el método VoiceProfileClient.createProfileAsync.

En este caso, pasará VoiceProfileType.TextIndependentVerification a createProfileAsync.

Luego, llamará a dos funciones auxiliares: AddEnrollmentsToTextIndependentProfile, que definirá a continuación, y SpeakerVerify, que ya ha definido. Por último, llamará a VoiceProfileClient. deleteProfileAsync para quitar el perfil.

AddEnrollmentsToTextIndependentProfile

Defina la función siguiente para inscribir un perfil de voz.

async function AddEnrollmentsToTextIndependentProfile(client, profile, audio_files)
{
    for (var i = 0; i < audio_files.length; i++) {
        console.log ("Adding enrollment to text independent profile...");
        const audio_config = GetAudioConfigFromFile (audio_files[i]);
        const result = await new Promise ((resolve, reject) => {
            client.enrollProfileAsync (profile, audio_config, result => { resolve(result); }, error => { reject(error); });
        });
        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");
}

En esta función, se llama a la función GetAudioConfigFromFile, que se ha definido anteriormente, para crear objetos AudioConfig a partir de muestras de audio. Luego, se inscriben estas muestras de audio mediante el método VoiceProfileClient. enrollProfileAsync.

Identificación del hablante

Speaker Identification se utiliza para determinar quién está hablando de un grupo determinado de voces inscritas. El proceso es similar al de comprobación independiente del texto. La diferencia principal es que la comprobación se puede realizar con varios perfiles de voz a la vez, en lugar de con uno solo.

Función TextIndependentIdentification

Empiece por crear la función TextIndependentIdentification.

async function TextIndependentIdentification(client, speech_config)
{
    console.log ("Text Independent Identification:\n");
    var profile = null;
    try {
        // Create the profile.
        profile = await new Promise ((resolve, reject) => {
            client.createProfileAsync (sdk.VoiceProfileType.TextIndependentIdentification, profile_locale, result => { resolve(result); }, error => { reject(error); });
        });
        console.log ("Created profile ID: " + profile.profileId);
        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);
            await new Promise ((resolve, reject) => {
                client.deleteProfileAsync (profile, result => { resolve(result); }, error => { reject(error); });
            });
        }
    }
}

Al igual que las funciones TextDependentVerification y TextIndependentVerification, esta función crea un objeto VoiceProfile con el método VoiceProfileClient.createProfileAsync.

En este caso, pasará VoiceProfileType.TextIndependentIdentification a VoiceProfileClient.createProfileAsync.

Luego, llamará a dos funciones auxiliares: AddEnrollmentsToTextIndependentProfile, que ya ha definido y SpeakerIdentify, que definirá a continuación. Por último, llamará a VoiceProfileClient. deleteProfileAsync para quitar el perfil.

Función SpeakerIdentify

Defina la función SpeakerIdentify como se indica a continuación.

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

En esta función, creará un objeto SpeakerIdentificationModel con el método SpeakerIdentificationModel.fromProfiles y pasará el objeto VoiceProfile que creó anteriormente.

Luego, llamará al método SpeechRecognizer. recognizeOnceAsync y utilizara una muestra de audio. SpeechRecognizer.recognizeOnceAsync intentará identificar la voz de esta muestra de audio en función de los objetos VoiceProfile que se usaron para crear SpeakerIdentificationModel. Devolverá un objeto SpeakerRecognitionResult, cuya propiedad profileId identificará el VoiceProfile coincidente, si hay alguno, mientras que la propiedad score contendrá contiene una puntuación de similitud comprendida entre 0,0 y 1,0.

Función main

Por último, definirá la función main de la sigiuente manera.

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 función crea un objeto VoiceProfileClient, que se usa para crear, inscribir y eliminar perfiles de voz. Y, posteriormente, llama a las funciones que definió anteriormente.

En este inicio rápido, aprenderá los patrones de diseño básicos de Speaker Recognition mediante el SDK de Voz, que incluyen:

• Comprobación dependiente e independiente del texto.
• Identificación del hablante para identificar una muestra de voz entre un grupo de voces.
• Eliminación de perfiles de voz.

Para obtener una visión general de los conceptos de Speaker Recognition, consulte el artículo de información general. Consulte el nodo de referencia situado en el panel de navegación izquierdo para ver una lista de las plataformas admitidas.

Prerrequisitos

En este artículo se da por sentado que tiene una cuenta de Azure y una suscripción al servicio de voz. Si no dispone de una cuenta y una suscripción, pruebe el servicio de voz de forma gratuita.

Comprobación dependiente del texto

Speaker Verification es el acto de confirmar que un hablante coincide con una voz conocida o inscrita. El primer paso es inscribir un perfil de voz, de modo que el servicio tenga algo para comparar futuras muestras de voz. En este ejemplo, el perfil se inscribe mediante una estrategia dependiente del texto, que requiere que se use una frase de contraseña específica tanto para la inscripción como para la comprobación. Consulte los documentos de referencia para ver la lista de las frases de contraseña admitidas.

Para empezar, cree un perfil de voz. Tendrá que insertar la región y la clave de suscripción del servicio Voz en cada uno de los comandos curl de este artículo.

# Note Change locale if needed.
curl --location --request POST 'INSERT_ENDPOINT_HERE/speaker/verification/v2.0/text-dependent/profiles' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE' \
--header 'Content-Type: application/json' \
--data-raw '{
    '\''locale'\'':'\''en-us'\''
}'

Hay tres tipos de perfiles de voz:

• Comprobación dependiente del texto
• Comprobación independiente del texto
• Identificación independiente del texto

En este caso, se crea un perfil de voz de comprobación dependiente del texto. Debería recibir la respuesta siguiente.

{
    "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
}

Luego, se inscribe el perfil de voz. En el caso del valor del parámetro --data-binary, especifique un archivo de audio en el equipo que contenga una de las frases de contraseña admitidas, como "my voice is my passport, verify me". Este tipo de archivo de audio se puede grabar con una aplicación como Windows Voice Recorder, o bien puede generarlo mediante la conversión de texto a voz.

curl --location --request POST 'INSERT_ENDPOINT_HERE/speaker/verification/v2.0/text-dependent/profiles/INSERT_PROFILE_ID_HERE/enrollments' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE' \
--header 'Content-Type: audio/wav' \
--data-binary @'INSERT_FILE_PATH_HERE'

Debería recibir la respuesta siguiente.

{
    "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 respuesta le indica que debe inscribir dos muestras de audio más.

Cuando haya inscrito un total de tres ejemplos de audio, debe recibir la siguiente respuesta.

{
    "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
}

Ya está listo para comprobar una muestra de audio con el perfil de voz. Esta muestra de audio debe contener la misma frase de contraseña que los ejemplos que usó para inscribir el perfil de voz.

curl --location --request POST 'INSERT_ENDPOINT_HERE/speaker/verification/v2.0/text-dependent/profiles/INSERT_PROFILE_ID_HERE/verify' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE' \
--header 'Content-Type: audio/wav' \
--data-binary @'INSERT_FILE_PATH_HERE'

Debería recibir la respuesta siguiente.

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

Accept significa que la frase de contraseña coincidía y que la comprobación se realizó correctamente. La respuesta también contiene una puntuación de similitud comprendida entre 0,0 y 1,0.

Para finalizar, elimine el perfil de voz.

curl --location --request DELETE \
'INSERT_ENDPOINT_HERE/speaker/verification/v2.0/text-dependent/profiles/INSERT_PROFILE_ID_HERE' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE'

No hay ninguna respuesta.

Comprobación independiente del texto

A diferencia de la comprobación dependiente del texto, la comprobación independiente del texto:

• No es preciso que se diga una frase de contraseña determinada, se puede decir cualquier cosa.
• No se necesitan tres muestras de audio, pero sí 20 segundos de audio en total.

Para empezar, cree un perfil de comprobación independiente del texto.

curl --location --request POST 'INSERT_ENDPOINT_HERE/speaker/verification/v2.0/text-independent/profiles' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE' \
--header 'Content-Type: application/json' \
--data-raw '{
    '\''locale'\'':'\''en-us'\''
}'

Debería recibir la respuesta siguiente.

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

A continuación, inscriba el perfil de voz. De nuevo, en lugar de enviar tres muestras de audio, debe enviar ejemplos de audio que contengan un total de 20 segundos de audio.

curl --location --request POST 'INSERT_ENDPOINT_HERE/speaker/verification/v2.0/text-independent/profiles/INSERT_PROFILE_ID_HERE/enrollments' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE' \
--header 'Content-Type: audio/wav' \
--data-binary @'INSERT_FILE_PATH_HERE'

Una vez que haya enviado suficientes muestras de audio, debe recibir la siguiente respuesta.

{
    "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
}

Ya está listo para comprobar una muestra de audio con el perfil de voz. De nuevo, no es preciso que esta muestra contenga una frase de contraseña. Puede contener cualquier locución, siempre que incluya un total de al menos cuatro segundos de audio.

curl --location --request POST 'INSERT_ENDPOINT_HERE/speaker/verification/v2.0/text-independent/profiles/INSERT_PROFILE_ID_HERE/verify' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE' \
--header 'Content-Type: audio/wav' \
--data-binary @'INSERT_FILE_PATH_HERE'

Debería recibir la respuesta siguiente.

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

Accept significa que la comprobación se realizó correctamente. La respuesta también contiene una puntuación de similitud comprendida entre 0,0 y 1,0.

Para finalizar, elimine el perfil de voz.

curl --location --request DELETE 'INSERT_ENDPOINT_HERE/speaker/verification/v2.0/text-independent/profiles/INSERT_PROFILE_ID_HERE' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE'

No hay ninguna respuesta.

Identificación del hablante

Speaker Identification se utiliza para determinar quién está hablando de un grupo determinado de voces inscritas. El proceso es similar al de comprobación independiente del texto. La diferencia principal es que la comprobación se puede realizar con varios perfiles de voz a la vez, en lugar de con uno solo.

Para empezar, cree un perfil de identificación independiente del texto.

# Note Change locale if needed.
curl --location --request POST 'INSERT_ENDPOINT_HERE/speaker/identification/v2.0/text-independent/profiles' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE' \
--header 'Content-Type: application/json' \
--data-raw '{
    '\''locale'\'':'\''en-us'\''
}'

Debería recibir la respuesta siguiente.

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

Luego, se inscribe el perfil de voz. De nuevo, debe enviar muestras de audio que contengan un total de 20 segundos de audio. No es necesario que estas muestras contengan una frase de contraseña.

curl --location --request POST 'INSERT_ENDPOINT_HERE/speaker/identification/v2.0/text-independent/profiles/INSERT_PROFILE_ID_HERE/enrollments' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE' \
--header 'Content-Type: audio/wav' \
--data-binary @'INSERT_FILE_PATH_HERE'

Una vez que haya enviado suficientes muestras de audio, debe recibir la siguiente respuesta.

{
    "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
}

Ya está listo para identificar una muestra de audio mediante el perfil de voz. El comando de identificación acepta una lista delimitada por comas de posibles identificadores del perfil de voz. En este caso, solo tendrá que pasar el identificador del perfil de voz que creó anteriormente. Sin embargo, si lo desea, puede usar varios identificadores de perfil de voz, y cada perfil de voz se inscribe con muestras de audio de una voz diferente.

curl --location --request POST 'INSERT_ENDPOINT_HERE/speaker/identification/v2.0/text-independent/profiles/identifySingleSpeaker?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'

Debería recibir la respuesta siguiente.

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

La respuesta contiene el identificador del perfil de voz que más se aproxime al ejemplo de audio que envió. También contiene una lista de perfiles de voz candidatos, clasificados por orden de similitud.

Para finalizar, elimine el perfil de voz.

curl --location --request DELETE \
'INSERT_ENDPOINT_HERE/speaker/identification/v2.0/text-independent/profiles/INSERT_PROFILE_ID_HERE' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE'

No hay ninguna respuesta.