Introduzione a Riconoscimento del parlante

Questo argomento di avvio rapido illustra i modelli di progettazione di base per Riconoscimento del parlante tramite Speech SDK, tra cui:

  • Verifica dipendente dal testo e indipendente dal testo
  • Identificazione voce per identificare un campione di voce tra un gruppo di voci
  • Eliminazione dei profili vocali

Per informazioni generali sui concetti di Riconoscimento del parlante, vedere l'articolo Panoramica.

Prerequisiti

Questo articolo presuppone che si abbia un account Azure e una sottoscrizione del servizio Voce. Se l'account e la sottoscrizione non sono disponibili, provare il servizio Voce gratuitamente.

Importante

La funzionalità Riconoscimento del parlante è attualmente supportata solo nelle risorse Voce di Azure create nell'area westus.

Installare Speech SDK

Prima di poter eseguire qualsiasi operazione, è necessario installare Speech SDK. A seconda della piattaforma, usare le istruzioni seguenti:

Importare le dipendenze

Per eseguire gli esempi di questo articolo, includere le istruzioni using seguenti all'inizio dello script.

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

Creare una configurazione di Voce

Per chiamare il servizio Voce con Speech SDK, è necessario creare una classe SpeechConfig. In questo esempio viene creato un oggetto SpeechConfig usando una chiave e un'area di sottoscrizione. Si crea anche un codice boilerplate di base da usare per la parte restante di questo articolo, che viene modificato per diverse personalizzazioni.

Si noti che l'area è impostata su westus, perché è l'unica area supportata per il servizio.

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

Verifica dipendente dal testo

Verifica voce è l'atto di confermare che un parlante corrisponde a una voce nota o registrata. Il primo passaggio consiste nel registrare un profilo vocale, in modo che il servizio disponga di un profilo da confrontare con i campioni di voce futuri. In questo esempio, il profilo viene registrato usando una strategia dipendente dal testo, che richiede una passphrase specifica da usare per la registrazione e la verifica. Per un elenco delle passphrase supportate, vedere la documentazione di riferimento.

Per iniziare, creare la funzione seguente nella classe Program per registrare un profilo vocale.

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 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, \"My voice is my passport, verify me.\"");
                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}");
            }
        }
    }
}

In questa funzione await client.CreateProfileAsync() rappresenta ciò che crea effettivamente il nuovo profilo vocale. Dopo la creazione, è possibile specificare la modalità di input dei campioni audio, usando AudioConfig.FromDefaultMicrophoneInput() in questo esempio per acquisire l'audio dal dispositivo di input predefinito. Si registrano quindi i campioni audio in un ciclo while che tiene traccia del numero di campioni rimanenti e necessari per la registrazione. In ogni iterazione client.EnrollProfileAsync(profile, audioInput) chiederà di pronunciare la passphrase nel microfono e aggiungerà il campione al profilo vocale.

Al termine della registrazione, chiamare await SpeakerVerify(config, profile, profileMapping) per eseguire la verifica rispetto al profilo appena creato. Aggiungere un'altra funzione per definire 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}");
}

In questa funzione viene passato l'oggetto VoiceProfile appena creato per inizializzare un modello in base a cui eseguire la verifica. Successivamente, await speakerRecognizer.RecognizeOnceAsync(model) richiede di pronunciare di nuovo la passphrase, ma questa volta la convaliderà in base al profilo vocale e restituirà un punteggio di somiglianza compreso tra 0,0 e 1,0. L'oggetto result restituisce anche Accept o Reject, a seconda che la passphrase corrisponda o meno.

Modificare quindi la funzione Main() per chiamare le nuove funzioni create. Si noti inoltre che è possibile creare un elemento Dictionary<string, string> da passare come riferimento tramite le chiamate di funzione. Questo perché il servizio non consente l'archiviazione di un nome leggibile con un profilo VoiceProfile creato e archivia solo un numero ID ai fini della privacy. Nella funzione VerificationEnroll aggiungere a questo dizionario una voce con l'ID appena creato, insieme a un nome di testo. Negli scenari di sviluppo di applicazioni in cui è necessario visualizzare un nome leggibile, è necessario archiviare questo mapping in una posizione, perché il servizio non può archiviarlo.

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

Eseguire lo script. Verrà richiesto di pronunciare la frase My voice is my passport, verify me (La mia voce è il mio passaporto, verificami) tre volte per la registrazione e una volta per la verifica. Il risultato restituito è il punteggio di somiglianza, che può essere usato per creare soglie personalizzate per la verifica.

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 indipendente dal testo

A differenza della verifica dipendente dal testo, la verifica indipendente dal testo:

  • Non richiede che venga pronunciata una passphrase specifica, ma è possibile pronunciare le parole desiderate
  • Non richiede tre campioni audio, ma richiede 20 secondi di audio totale

Apportare un paio di modifiche semplici alla funzione VerificationEnroll per passare alla verifica indipendente dal testo. Prima di tutto, modificare il tipo di verifica impostandola su VoiceProfileType.TextIndependentVerification. Modificare quindi il ciclo while per tenere traccia di result.RemainingEnrollmentsSpeechLength, che continuerà a richiedere di parlare fino a quando non saranno stati acquisiti 20 secondi di 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 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("Continue speaking to add to the profile enrollment sample.");
                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}");
            }
        }
    }
}

Eseguire di nuovo il programma e pronunciare le parole desiderate durante la fase di verifica, perché non è necessaria una passphrase. Anche in questo caso viene restituito il punteggio di somiglianza.

Enrolling profile id 4tt87d4-f2d3-44ae-b5b4-f1a8d4036ee9.
Continue speaking to add to the profile enrollment sample.
Remaining enrollment audio time needed: 00:00:15.3200000

Continue speaking to add to the profile enrollment sample.
Remaining enrollment audio time needed: 00:00:09.8100008

Continue speaking to add to the profile enrollment sample.
Remaining enrollment audio time needed: 00:00:05.1900000

Continue speaking to add to the profile enrollment sample.
Remaining enrollment audio time needed: 00:00:00.8700000

Continue speaking to add to the profile enrollment sample.
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

Identificazione voce

La funzionalità Identificazione voce viene usata per determinare chi parla da un gruppo specifico di voci registrate. Il processo è molto simile a quello di verifica indipendente dal testo, con la differenza principale che può eseguire la verifica rispetto a più profili vocali contemporaneamente, anziché rispetto a un singolo profilo.

Creare una funzione IdentificationEnroll per registrare più profili vocali. Il processo di registrazione per ogni profilo è uguale al processo di registrazione per la verifica indipendente dal testo e richiede 20 secondi di audio per ogni profilo. Questa funzione accetta un elenco di stringhe profileNames e creerà un nuovo profilo vocale per ogni nome nell'elenco. La funzione restituisce un elenco di oggetti VoiceProfile, che è possibile usare nella funzione successiva per l'identificazione di un parlante.

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))
    {
        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($"Continue speaking 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;
}

Creare la funzione seguente SpeakerIdentification per inviare una richiesta di identificazione. La differenza principale in questa funzione rispetto a una richiesta di verifica voce sta nell'utilizzo di SpeakerIdentificationModel.FromProfiles(), che accetta un elenco di oggetti 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}");
}

Modificare la funzione Main() come segue. Verrà creato un elenco di stringhe profileNames, che vengono passate alla funzione IdentificationEnroll(). Verrà richiesto di creare un nuovo profilo vocale per ogni nome in questo elenco, in modo da poter aggiungere altri nomi per creare profili aggiuntivi per gli amici o i colleghi.

static async Task Main(string[] args)
{
    // replace with your own subscription key 
    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>();
    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();
}

Eseguire lo script. Verrà richiesto di parlare per registrare i campioni vocali per il primo profilo. Al termine della registrazione, verrà richiesto di ripetere questo processo per ogni nome nell'elenco profileNames. Al termine di ogni registrazione, verrà richiesto a chiunque di parlare e il servizio tenterà di identificare questa persona tra i profili vocali registrati.

Questo esempio restituisce solo la corrispondenza più vicina e il relativo punteggio di somiglianza, ma è possibile ottenere la risposta completa che include i primi cinque punteggi di somiglianza aggiungendo string json = result.Properties.GetProperty(PropertyId.SpeechServiceResponse_JsonResult) alla funzione SpeakerIdentification.

Modifica del tipo di input audio

Gli esempi in questo articolo usano il microfono del dispositivo predefinito come input per i campioni audio. Tuttavia, negli scenari in cui è necessario usare file audio anziché l'input del microfono, è sufficiente modificare qualsiasi istanza di AudioConfig.FromDefaultMicrophoneInput() in AudioConfig.FromWavFileInput(path/to/your/file.wav) per passare a un input di file. È anche possibile usare una combinazione di input, ad esempio un microfono per la registrazione e i file per la verifica.

Eliminazione delle registrazioni dei profili vocali

Per eliminare un profilo registrato, utilizzare la funzione DeleteProfileAsync() sull'oggetto VoiceProfileClient. La funzione di esempio seguente mostra come eliminare un profilo vocale da un ID profilo vocale noto.

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

Questo argomento di avvio rapido illustra i modelli di progettazione di base per Riconoscimento del parlante tramite Speech SDK, tra cui:

  • Verifica dipendente dal testo e indipendente dal testo
  • Identificazione voce per identificare un campione di voce tra un gruppo di voci
  • Eliminazione dei profili vocali

Per informazioni generali sui concetti di Riconoscimento del parlante, vedere l'articolo Panoramica.

Passare agli esempi su GitHub

Per passare direttamente al codice di esempio, vedere gli esempi di avvio rapido C++ in GitHub.

Prerequisiti

Questo articolo presuppone che si abbia un account Azure e una sottoscrizione del servizio Voce. Se l'account e la sottoscrizione non sono disponibili, provare il servizio Voce gratuitamente.

Importante

La funzionalità Riconoscimento del parlante è attualmente supportata solo nelle risorse Voce di Azure create nell'area westus.

Installare Speech SDK

Prima di poter eseguire qualsiasi operazione, è necessario installare Speech SDK. A seconda della piattaforma, usare le istruzioni seguenti:

Importare le dipendenze

Per eseguire gli esempi di questo articolo, aggiungere le istruzioni seguenti all'inizio del file 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;

Creare una configurazione di Voce

Per chiamare il servizio Voce con Speech SDK, è necessario creare una classe SpeechConfig. Questa classe include informazioni sulla sottoscrizione, ad esempio la chiave e l'area associata, l'endpoint, l'host o il token di autorizzazione.

shared_ptr<SpeechConfig> GetSpeechConfig()
{
    char* subscription_key = nullptr;
    char* region = nullptr;
    size_t sz = 0;
    _dupenv_s(&subscription_key, &sz, "SPEECH_SUBSCRIPTION_KEY");
    _dupenv_s(&region, &sz, "SPEECH_REGION");
    if (subscription_key == nullptr) {
        throw std::invalid_argument("Please set the environment variable SPEECH_SUBSCRIPTION_KEY.");
    }
    if (region == nullptr) {
        throw std::invalid_argument("Please set the environment variable SPEECH_REGION.");
    }
    auto config = SpeechConfig::FromSubscription(subscription_key, region);
    free(subscription_key);
    free(region);
    return config;
}

Verifica dipendente dal testo

Verifica voce è l'atto di confermare che un parlante corrisponde a una voce nota o registrata. Il primo passaggio consiste nel registrare un profilo vocale, in modo che il servizio disponga di un profilo da confrontare con i campioni di voce futuri. In questo esempio, il profilo viene registrato usando una strategia dipendente dal testo, che richiede una passphrase specifica da usare per la registrazione e la verifica. Per un elenco delle passphrase supportate, vedere la documentazione di riferimento.

Funzione TextDependentVerification

Per iniziare, creare la funzione 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);
}

Questa funzione crea un oggetto VoiceProfile con il metodo CreateProfileAsync. Si noti che esistono tre tipi di profili VoiceProfile:

  • TextIndependentIdentification
  • TextDependentVerification
  • TextIndependentVerification

In questo caso, si passerà VoiceProfileType::TextDependentVerification a CreateProfileAsync.

Verranno chiamate quindi due funzioni helper che verranno definite avanti, AddEnrollmentsToTextDependentProfile e SpeakerVerify. Infine, si chiamerà DeleteProfileAsync per eseguire la pulizia del profilo.

Funzione AddEnrollmentsToTextDependentProfile

Definire la funzione seguente per registrare un profilo vocale.

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

In questa funzione si registrano quindi i campioni audio in un ciclo while che tiene traccia del numero di campioni rimanenti e necessari per la registrazione. In ogni iterazione EnrollProfileAsync chiederà di pronunciare la passphrase nel microfono e aggiungerà il campione al profilo vocale.

Funzione SpeakerVerify

Definire SpeakerVerify come indicato di seguito.

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

In questa funzione viene creato un oggetto SpeakerVerificationModel con il metodo SpeakerVerificationModel::FromProfile, passando l'oggetto VoiceProfile creato in precedenza.

Successivamente, SpeechRecognizer::RecognizeOnceAsync richiede di pronunciare di nuovo la passphrase, ma questa volta la convaliderà in base al profilo vocale e restituirà un punteggio di somiglianza compreso tra 0,0 e 1,0. L'oggetto SpeakerRecognitionResult restituisce anche Accept o Reject, a seconda che la passphrase corrisponda o meno.

Verifica indipendente dal testo

A differenza della verifica dipendente dal testo, la verifica indipendente dal testo:

  • Non richiede che venga pronunciata una passphrase specifica, ma è possibile pronunciare le parole desiderate
  • Non richiede tre campioni audio, ma richiede 20 secondi di audio totale

Funzione TextIndependentVerification

Per iniziare, creare la funzione 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);
}

Come la funzione TextDependentVerification, questa funzione crea un oggetto VoiceProfile con il metodo CreateProfileAsync.

In questo caso, si passerà VoiceProfileType::TextIndependentVerification a CreateProfileAsync.

Si chiamano quindi due funzioni helper: AddEnrollmentsToTextIndependentProfile, che verrà definita in seguito e SpeakerVerify, che è già stata definita. Infine, si chiamerà DeleteProfileAsync per eseguire la pulizia del profilo.

AddEnrollmentsToTextIndependentProfile

Definire la funzione seguente per registrare un profilo vocale.

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

In questa funzione si registrano quindi i campioni audio in un ciclo while che tiene traccia del numero di secondi di audio rimanenti e necessari per la registrazione. In ogni iterazione EnrollProfileAsync chiederà di pronunciare parole nel microfono e aggiungerà il campione al profilo vocale.

Identificazione voce

La funzionalità Identificazione voce viene usata per determinare chi parla da un gruppo specifico di voci registrate. Il processo è molto simile a quello di verifica indipendente dal testo, con la differenza principale che può eseguire la verifica rispetto a più profili vocali contemporaneamente, anziché rispetto a un singolo profilo.

Funzione TextIndependentIdentification

Per iniziare, creare la funzione 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);
}

Come le funzioni TextDependentVerification e TextIndependentVerification, questa funzione crea un oggetto VoiceProfile con il metodo CreateProfileAsync.

In questo caso, si passerà VoiceProfileType::TextIndependentIdentification a CreateProfileAsync.

Si chiamano quindi due funzioni helper: AddEnrollmentsToTextIndependentProfile, che è già stata definita e SpeakerIdentify, che verrà definita in seguito. Infine, si chiamerà DeleteProfileAsync per eseguire la pulizia del profilo.

Funzione SpeakerIdentify

Definire la funzione SpeakerIdentify come indicato di seguito.

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

In questa funzione viene creato un oggetto SpeakerIdentificationModel con il metodo SpeakerIdentificationModel::FromProfiles. SpeakerIdentificationModel::FromProfiles accetta un elenco di oggetti VoiceProfile. In questo caso, si passerà solo l'oggetto VoiceProfile creato in precedenza. Tuttavia, se si desidera, è possibile passare più oggetti VoiceProfile, ognuno dei quali è registrato con campioni audio da un'altra voce.

Successivamente, SpeechRecognizer::RecognizeOnceAsync richiederà di parlare ancora. Questa volta confronta la voce con i profili vocali registrati e restituisce il profilo vocale più simile.

Funzione main

Infine, definire la funzione main come indicato di seguito.

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

Questa funzione chiama semplicemente le funzioni definite in precedenza. Per prima cosa, tuttavia, crea un oggetto VoiceProfileClient e un oggetto SpeakerRecognizer.

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

L'oggetto VoiceProfileClient viene usato per creare, registrare ed eliminare i profili vocali. L'oggetto SpeakerRecognizer viene usato per convalidare i campioni vocali rispetto a uno o più profili vocali registrati.

Modifica del tipo di input audio

Gli esempi in questo articolo usano il microfono del dispositivo predefinito come input per i campioni audio. Tuttavia, negli scenari in cui è necessario usare file audio anziché l'input del microfono, è sufficiente modificare la riga seguente:

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

in:

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

In alternativa, è anche possibile sostituire l'uso di audio_config con Audio::AudioConfig::FromWavFileInput. È anche possibile usare una combinazione di input, ad esempio un microfono per la registrazione e i file per la verifica.

Questo argomento di avvio rapido illustra i modelli di progettazione di base per Riconoscimento del parlante tramite Speech SDK, tra cui:

  • Verifica dipendente dal testo e indipendente dal testo
  • Identificazione voce per identificare un campione di voce tra un gruppo di voci
  • Eliminazione dei profili vocali

Per informazioni generali sui concetti di Riconoscimento del parlante, vedere l'articolo Panoramica.

Passare agli esempi su GitHub

Per passare direttamente al codice di esempio, vedere gli esempi di avvio rapido JavaScript in GitHub.

Prerequisiti

Questo articolo presuppone che si abbia un account Azure e una sottoscrizione del servizio Voce. Se l'account e la sottoscrizione non sono disponibili, provare il servizio Voce gratuitamente.

Importante

La funzionalità Riconoscimento del parlante è attualmente supportata solo nelle risorse Voce di Azure create nell'area westus.

Installare Speech SDK

Prima di poter eseguire qualsiasi operazione, è necessario installare Speech SDK per JavaScript. A seconda della piattaforma, usare le istruzioni seguenti:

A seconda dell'ambiente di destinazione, inoltre, usare una delle alternative seguenti:

Scaricare ed estrarre il file SDK di riconoscimento vocale per JavaScript microsoft.cognitiveservices.speech.sdk.bundle.js e inserirlo in una cartella accessibile al file HTML.

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

Suggerimento

Se la destinazione è un Web browser e si usa il tag <script>, il prefisso sdk non è necessario. Il prefisso sdk è un alias usato per la denominazione del modulo di require.

Importare le dipendenze

Per eseguire gli esempi di questo articolo, aggiungere le istruzioni seguenti all'inizio del file 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";

const key_var = 'SPEECH_SUBSCRIPTION_KEY';
if (!process.env[key_var]) {
    throw new Error('please set/export the following environment variable: ' + key_var);
}
var subscription_key = process.env[key_var];

const region_var = 'SPEECH_REGION';
if (!process.env[region_var]) {
    throw new Error('please set/export the following environment variable: ' + region_var);
}
var region = process.env[region_var];

const ticks_per_second = 10000000;

Queste istruzioni importano le librerie necessarie e recuperano la chiave di sottoscrizione e l'area del servizio Voce dalle variabili di ambiente. Specificano inoltre i percorsi dei file audio che verranno usati nelle attività seguenti.

Creare la funzione helper

Aggiungere la funzione helper seguente per la lettura dei file audio nei flussi per l'uso da parte del servizio Voce.

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

In questa funzione si usano i metodi AudioInputStream.createPushStream e AudioConfig.fromStreamInput per creare un oggetto AudioConfig. L'oggetto AudioConfig rappresenta un flusso audio. Verranno usati numerosi oggetti AudioConfig nel corso delle attività seguenti.

Verifica dipendente dal testo

Verifica voce è l'atto di confermare che un parlante corrisponde a una voce nota o registrata. Il primo passaggio consiste nel registrare un profilo vocale, in modo che il servizio disponga di un profilo da confrontare con i campioni di voce futuri. In questo esempio, il profilo viene registrato usando una strategia dipendente dal testo, che richiede una passphrase specifica da usare per la registrazione e la verifica. Per un elenco delle passphrase supportate, vedere la documentazione di riferimento.

Funzione TextDependentVerification

Per iniziare, creare la funzione 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); });
            });
        }
    }
}

Questa funzione crea un oggetto VoiceProfile con il metodo VoiceProfileClient.createProfileAsync. Si noti che esistono tre tipi di profili VoiceProfile:

  • TextIndependentIdentification
  • TextDependentVerification
  • TextIndependentVerification

In questo caso, si passerà VoiceProfileType.TextDependentVerification a VoiceProfileClient.createProfileAsync.

Verranno chiamate quindi due funzioni helper che verranno definite avanti, AddEnrollmentsToTextDependentProfile e SpeakerVerify. Infine, si chiamerà VoiceProfileClient.deleteProfileAsync per rimuovere il profilo.

Funzione AddEnrollmentsToTextDependentProfile

Definire la funzione seguente per registrare un profilo vocale.

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

In questa funzione viene chiamata la funzione GetAudioConfigFromFile definita in precedenza per creare AudioConfig oggetti dai campioni audio. Questi campioni audio contengono una passphrase, ad esempio "My voice is my passport, verify me". Questi campioni audio verranno quindi registrati usando il metodo VoiceProfileClient.enrollProfileAsync.

Funzione SpeakerVerify

Definire SpeakerVerify come indicato di seguito.

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

In questa funzione viene creato un oggetto SpeakerVerificationModel con il metodo SpeakerVerificationModel.FromProfile, passando l'oggetto VoiceProfile creato in precedenza.

Verrà quindi chiamato il metodo SpeechRecognizer.recognizeOnceAsync per convalidare un campione audio che contiene la stessa passphrase dei campioni audio registrati in precedenza. SpeechRecognizer.recognizeOnceAsync restituisce un oggetto SpeakerRecognitionResult, la cui proprietà score contiene un punteggio di somiglianza compreso tra 0,0 e 1,0. L'oggetto SpeakerRecognitionResult contiene inoltre una proprietà reason di tipo ResultReason. Se la verifica ha avuto esito positivo, il valore della proprietà reason sarà RecognizedSpeaker.

Verifica indipendente dal testo

A differenza della verifica dipendente dal testo, la verifica indipendente dal testo:

  • Non richiede che venga pronunciata una passphrase specifica, ma è possibile pronunciare le parole desiderate
  • Non richiede tre campioni audio, ma richiede 20 secondi di audio totale

Funzione TextIndependentVerification

Per iniziare, creare la funzione 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); });
            });
        }
    }
}

Come la funzione TextDependentVerification, questa funzione crea un oggetto VoiceProfile con il metodo VoiceProfileClient.createProfileAsync.

In questo caso, si passerà VoiceProfileType.TextIndependentVerification a createProfileAsync.

Si chiamano quindi due funzioni helper: AddEnrollmentsToTextIndependentProfile, che verrà definita in seguito e SpeakerVerify, che è già stata definita. Infine, si chiamerà VoiceProfileClient.deleteProfileAsync per rimuovere il profilo.

AddEnrollmentsToTextIndependentProfile

Definire la funzione seguente per registrare un profilo vocale.

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

In questa funzione viene chiamata la funzione GetAudioConfigFromFile definita in precedenza per creare AudioConfig oggetti dai campioni audio. Questi campioni audio verranno quindi registrati usando il metodo VoiceProfileClient.enrollProfileAsync.

Identificazione voce

La funzionalità Identificazione voce viene usata per determinare chi parla da un gruppo specifico di voci registrate. Il processo è simile a quello di verifica indipendente dal testo, con la differenza principale che può eseguire la verifica rispetto a più profili vocali contemporaneamente, anziché rispetto a un singolo profilo.

Funzione TextIndependentIdentification

Per iniziare, creare la funzione 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); });
            });
        }
    }
}

Come le funzioni TextDependentVerification e TextIndependentVerification, questa funzione crea un oggetto VoiceProfile con il metodo VoiceProfileClient.createProfileAsync.

In questo caso, si passerà VoiceProfileType.TextIndependentIdentification a VoiceProfileClient.createProfileAsync.

Si chiamano quindi due funzioni helper: AddEnrollmentsToTextIndependentProfile, che è già stata definita e SpeakerIdentify, che verrà definita in seguito. Infine, si chiamerà VoiceProfileClient.deleteProfileAsync per rimuovere il profilo.

Funzione SpeakerIdentify

Definire la funzione SpeakerIdentify come indicato di seguito.

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

In questa funzione viene creato un oggetto SpeakerIdentificationModel con il metodo SpeakerIdentificationModel.fromProfiles, passando l'oggetto VoiceProfile creato in precedenza.

Verrà quindi chiamato il metodo SpeechRecognizer.recognizeOnceAsync e verrà passato un campione audio. SpeechRecognizer.recognizeOnceAsync tenta di identificare la voce per questo campione audio in base agli oggetti VoiceProfile usati per creare il modello SpeakerIdentificationModel. Restituisce un oggetto SpeakerRecognitionResult, la cui proprietà profileId identifica la corrispondenza VoiceProfile, se presente, mentre la proprietà score contiene un punteggio di somiglianza compreso tra 0,0 e 1,0.

Funzione main

Infine, definire la funzione main come indicato di seguito.

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

Questa funzione crea un oggetto VoiceProfileClient, che viene usato per creare, registrare ed eliminare i profili vocali, e quindi chiama le funzioni definite in precedenza.

Questo argomento di avvio rapido illustra i modelli di progettazione di base per Riconoscimento del parlante tramite Speech SDK, tra cui:

  • Verifica dipendente dal testo e indipendente dal testo
  • Identificazione voce per identificare un campione di voce tra un gruppo di voci
  • Eliminazione dei profili vocali

Per informazioni generali sui concetti di Riconoscimento del parlante, vedere l'articolo Panoramica.

Prerequisiti

Questo articolo presuppone che si abbia un account Azure e una sottoscrizione del servizio Voce. Se l'account e la sottoscrizione non sono disponibili, provare il servizio Voce gratuitamente.

Importante

La funzionalità Riconoscimento del parlante è attualmente supportata solo nelle risorse Voce di Azure create nell'area westus.

Verifica dipendente dal testo

Verifica voce è l'atto di confermare che un parlante corrisponde a una voce nota o registrata. Il primo passaggio consiste nel registrare un profilo vocale, in modo che il servizio disponga di un profilo da confrontare con i campioni di voce futuri. In questo esempio, il profilo viene registrato usando una strategia dipendente dal testo, che richiede una passphrase specifica da usare per la registrazione e la verifica. Per un elenco delle passphrase supportate, vedere la documentazione di riferimento.

Per iniziare, creare un profilo vocale. Sarà necessario inserire la chiave e l'area della sottoscrizione del servizio Voce in ognuno dei comandi curl in questo articolo.

# 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'\''
}'

Si noti che esistono tre tipi di profili vocali:

  • Verifica dipendente dal testo
  • Verifica indipendente dal testo
  • Identificazione indipendente dal testo

In questo caso, verrà creato un profilo vocale di verifica dipendente dal testo. Si riceverà la risposta seguente.

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

Successivamente, si procederà alla registrazione del profilo vocale. Per il valore del parametro --data-binary, specificare un file audio nel computer contenente una delle passphrase supportate, ad esempio "my voice is my passport, verify me" (La mia voce è il mio passaporto, verificami). È possibile registrare un file audio di questo tipo con un'app, ad esempio Registratore vocale Windows, oppure è possibile generarlo usando la sintesi vocale.

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'

Si riceverà la risposta seguente.

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

Questa risposta indica che è necessario registrare altri due campioni audio.

Dopo aver registrato un totale di tre campioni audio, si riceverà la risposta seguente.

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

A questo punto si è pronti per verificare un campione audio in base al profilo vocale. Il campione audio deve contenere la stessa passphrase dei campioni usati per registrare il profilo vocale.

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'

Si riceverà la risposta seguente.

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

Accept indica che la passphrase corrisponde e che la verifica è stata superata. La risposta contiene anche un punteggio di somiglianza compreso tra 0,0 e 1,0.

Per terminare, eliminare il profilo vocale.

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'

Non viene restituita alcuna risposta.

Verifica indipendente dal testo

A differenza della verifica dipendente dal testo, la verifica indipendente dal testo:

  • Non richiede che venga pronunciata una passphrase specifica, ma è possibile pronunciare le parole desiderate
  • Non richiede tre campioni audio, ma richiede 20 secondi di audio totale

Per iniziare, creare un profilo di verifica indipendente dal testo.

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'\''
}'

Si riceverà la risposta seguente.

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

Successivamente, si procederà alla registrazione del profilo vocale. Anche in questo caso, invece di inviare tre campioni audio, è necessario inviare campioni audio contenenti un totale di 20 secondi di 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'

Dopo aver inviato un numero sufficiente di campioni audio, si riceverà la risposta seguente.

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

A questo punto si è pronti per verificare un campione audio in base al profilo vocale. Anche in questo caso, il campione audio non deve contenere una passphrase. Può includere le parole desiderate, purché contenga un totale di almeno quattro secondi di 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'

Si riceverà la risposta seguente.

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

Accept indica che la verifica ha avuto esito positivo. La risposta contiene anche un punteggio di somiglianza compreso tra 0,0 e 1,0.

Per terminare, eliminare il profilo vocale.

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'

Non viene restituita alcuna risposta.

Identificazione voce

La funzionalità Identificazione voce viene usata per determinare chi parla da un gruppo specifico di voci registrate. Il processo è simile a quello di verifica indipendente dal testo, con la differenza principale che può eseguire la verifica rispetto a più profili vocali contemporaneamente, anziché rispetto a un singolo profilo.

Per iniziare, creare un profilo di identificazione indipendente dal testo.

# 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'\''
}'

Si riceverà la risposta seguente.

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

Successivamente, si procederà alla registrazione del profilo vocale. Anche in questo caso, è necessario inviare campioni audio contenenti un totale di 20 secondi di audio. Questi campioni non devono contenere una passphrase.

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'

Dopo aver inviato un numero sufficiente di campioni audio, si riceverà la risposta seguente.

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

A questo punto si è pronti per identificare un campione audio in base al profilo vocale. Il comando di identificazione accetta un elenco delimitato da virgole di possibili ID di profilo vocale. In questo caso, si passerà semplicemente l'ID del profilo vocale creato in precedenza. Tuttavia, se si desidera, è possibile passare più ID di profilo vocale in cui ogni profilo vocale è registrato con campioni audio da un'altra voce.

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'

Si riceverà la risposta seguente.

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

La risposta contiene l'ID del profilo vocale che corrisponde maggiormente al campione audio inviato. Contiene anche un elenco di profili vocali candidati, classificati in ordine di somiglianza.

Per terminare, eliminare il profilo vocale.

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'

Non viene restituita alcuna risposta.

Passaggi successivi

  • Per informazioni dettagliate sulle classi e sulle funzioni, vedere la documentazione di riferimento di Riconoscimento del parlante.

  • Vedere gli esempi per C# e C++ in GitHub.