Guida introduttiva: Riconoscere e verificare chi parla

  • Articolo

Documentazione di | riferimentoPacchetto (NuGet) | Esempi aggiuntivi in GitHub

In questa guida introduttiva si apprenderà i modelli di progettazione di base per il riconoscimento degli altoparlanti usando Speech SDK, tra cui:

  • Verifica dipendente dal testo e indipendente dal testo.
  • Identificazione dell'altoparlante per identificare un campione vocale tra un gruppo di voci.
  • Eliminazione dei profili vocali.

Per un'analisi generale dei concetti relativi al riconoscimento degli altoparlanti, vedere l'articolo Panoramica . Per un elenco delle piattaforme supportate, vedere il nodo Riferimento nel riquadro sinistro.

Importante

Microsoft limita l'accesso al riconoscimento del parlante. Applicare l'applicazione per usarla tramite il modulo di revisione dell'accesso limitato per il riconoscimento del parlante di Intelligenza artificiale di Azure . Dopo l'approvazione, è possibile accedere alle API riconoscimento altoparlanti.

Prerequisiti

  • Sottoscrizione di Azure: creare un account gratuito.
  • nella portale di Azure.
  • Chiave e area della risorsa Voce. Dopo la distribuzione della risorsa Voce, selezionare Vai alla risorsa per visualizzare e gestire le chiavi. Per altre informazioni sulle risorse dei servizi di intelligenza artificiale di Azure, vedere Ottenere le chiavi per la risorsa.

Installare Speech SDK

Prima di iniziare, è necessario installare Speech SDK. A seconda della piattaforma, usare le istruzioni seguenti:

Importare le dipendenze

Per eseguire gli esempi in questo articolo, includere le istruzioni seguenti using nella parte superiore 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 usando Speech SDK, è necessario creare un'istanza SpeechConfig . In questo esempio viene creata un'istanza usando una SpeechConfig chiave di sottoscrizione e un'area. Si crea anche un codice boilerplate di base da usare per la parte restante di questo articolo, che viene modificato per diverse personalizzazioni.

Importante

Al termine, ricordarsi di rimuovere la chiave dal codice e non renderlo mai pubblico. Per la produzione, usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault. Per altre informazioni, vedere l'articolo sulla sicurezza dei servizi di intelligenza artificiale di Azure.

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

Verifica dipendente dal testo

La verifica dell'altoparlante è l'atto di confermare che un altoparlante corrisponde a una voce nota o registrata. Il primo passaggio consiste nel registrare un profilo vocale in modo che il servizio disponga di un elemento per confrontare gli esempi vocali futuri rispetto a . In questo esempio si registra il profilo 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.

Iniziare creando la funzione seguente nella Program classe 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"))
    {
        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}");
            }
        }
    }
}

In questa funzione await client.CreateProfileAsync() rappresenta ciò che crea effettivamente il nuovo profilo vocale. Dopo aver creato, si specifica come si immetteranno esempi audio usando AudioConfig.FromDefaultMicrophoneInput() in questo esempio per acquisire l'audio dal dispositivo di input predefinito. Si registrano quindi esempi audio in un while ciclo che tiene traccia del numero di campioni rimanenti e necessari per la registrazione. In ogni iterazione, client.EnrollProfileAsync(profile, audioInput) ti chiede di parlare la passphrase nel microfono e aggiunge l'esempio al profilo vocale.

Al termine della registrazione, chiamare await SpeakerVerify(config, profile, profileMapping) per verificare il 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. Quindi, await speakerRecognizer.RecognizeOnceAsync(model) ti chiede di parlare di nuovo la passphrase. Questa volta convalida il profilo vocale e restituisce un punteggio di somiglianza compreso tra 0,0 e 1,0. L'oggetto result restituisce Accept o Reject, in base alla corrispondenza della passphrase.

Modificare quindi la funzione Main() per chiamare le nuove funzioni create. Si noti anche che si crea un Dictionary<string, string> oggetto per passare per fare riferimento alle chiamate di funzione. Il motivo è che il servizio non consente di archiviare un nome leggibile con un nome creato VoiceProfilee archivia solo un numero ID a scopo di 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 dall'utente, è necessario archiviare il mapping in un punto qualsiasi 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. Ti viene chiesto di pronunciare la frase "La mia voce è il mio passaporto, verificami" tre volte per la registrazione e una volta più 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

Al contrario della verifica dipendente dal testo , la verifica indipendente dal testo non richiede tre esempi 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"))
    {
        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}");
            }
        }
    }
}

Eseguire di nuovo il programma e viene restituito il punteggio di somiglianza.

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

Identificazione voce

L'identificazione del parlante viene usata per determinare chi parla da un determinato gruppo di voci registrate. Il processo è simile alla verifica indipendente dal testo. La differenza principale è la capacità di verificare su più profili vocali contemporaneamente anziché verificare su 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. Il processo 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))
    {
        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;
}

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(). Viene richiesto di creare un nuovo profilo vocale per ogni nome in questo elenco, in modo da poter aggiungere altri nomi per creare altri profili per gli amici o i colleghi.

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

Eseguire lo script. Viene richiesto di parlare per registrare esempi vocali per il primo profilo. Al termine della registrazione, viene richiesto di ripetere questo processo per ogni nome nell'elenco profileNames . Al termine di ogni registrazione, viene richiesto di avere qualcuno che parla. Il servizio tenta quindi di identificare questa persona tra i profili vocali registrati.

In questo esempio viene restituita solo la corrispondenza più vicina e il punteggio di somiglianza. Per ottenere la risposta completa che include i primi cinque punteggi di somiglianza, aggiungere string json = result.Properties.GetProperty(PropertyId.SpeechServiceResponse_JsonResult) alla SpeakerIdentification funzione.

Modificare il tipo di input audio

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

Eliminare le registrazioni del profilo vocale

Per eliminare un profilo registrato, utilizzare la funzione DeleteProfileAsync() sull'oggetto VoiceProfileClient. La funzione di esempio seguente illustra 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);
    }
}

Documentazione di | riferimentoPacchetto (NuGet) | Esempi aggiuntivi in GitHub

In questa guida introduttiva si apprenderà i modelli di progettazione di base per il riconoscimento degli altoparlanti usando Speech SDK, tra cui:

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

Per un'analisi generale dei concetti relativi al riconoscimento del parlante, vedere l'articolo Panoramica . Per un elenco delle piattaforme supportate, vedere il nodo Riferimento nel riquadro sinistro.

Importante

Microsoft limita l'accesso al riconoscimento del parlante. Applicare per usarlo tramite il modulo di verifica dell'accesso limitato riconoscimento del parlante dell'intelligenza artificiale di Azure . Dopo l'approvazione, è possibile accedere alle API Riconoscimento del parlante.

Prerequisiti

  • Sottoscrizione di Azure: creare un account gratuito.
  • Voce nel portale di Azure.
  • La chiave e l'area della risorsa Voce. Dopo aver distribuito la risorsa Voce, selezionare Vai alla risorsa per visualizzare e gestire le chiavi. Per altre informazioni sulle risorse dei servizi di intelligenza artificiale di Azure, vedere Ottenere le chiavi per la risorsa.

Installare Speech SDK

Prima di iniziare, è necessario installare Speech SDK. A seconda della piattaforma, usare le istruzioni seguenti:

Importare le dipendenze

Per eseguire gli esempi in questo articolo, aggiungere le istruzioni seguenti all'inizio del file con estensione 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 usando Speech SDK, creare una SpeechConfig classe. Questa classe include informazioni sulla sottoscrizione, ad esempio la chiave e l'area associata, l'endpoint, l'host o il token di autorizzazione.

Importante

Al termine, ricordarsi di rimuovere la chiave dal codice e non renderlo mai pubblico. Per la produzione, usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault. Per altre informazioni, vedere l'articolo sulla sicurezza dei servizi di intelligenza artificiale di Azure.

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

Verifica dipendente dal testo

La verifica del parlante è 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 elemento per confrontare i campioni vocali futuri. In questo esempio si registra il profilo 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 TextDependentVerification funzione:

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

In questa funzione si registrano campioni audio in un while ciclo che tiene traccia del numero di campioni rimanenti e necessari per la registrazione. In ogni iterazione , EnrollProfileAsync richiede di pronunciare la passphrase nel microfono e aggiunge l'esempio al profilo vocale.

Funzione SpeakerVerify

Definire SpeakerVerify come segue:

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.

Quindi , SpeechRecognizer::RecognizeOnceAsync richiede di pronunciare nuovamente la passphrase. Questa volta la convalida rispetto al profilo vocale e restituisce un punteggio di somiglianza compreso tra 0,0 e 1,0. L'oggetto SpeakerRecognitionResult restituisce Accept o Reject in base alla corrispondenza della passphrase.

Verifica indipendente dal testo

A differenza della verifica dipendente dal testo , la verifica indipendente dal testo non richiede tre campioni audio, ma richiede 20 secondi di audio totale.

Funzione TextIndependentVerification

Per iniziare, creare la TextIndependentVerification funzione:

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

In questa funzione si registrano campioni audio in un while ciclo che tiene traccia del numero di secondi di audio rimanenti e necessari per la registrazione. In ogni iterazione , EnrollProfileAsync richiede di parlare nel microfono e aggiunge l'esempio al profilo vocale.

Identificazione voce

L'identificazione del parlante viene usata per determinare chi parla da un determinato gruppo di voci registrate. Il processo è simile alla verifica indipendente dal testo. La differenza principale è la possibilità di verificare con più profili vocali contemporaneamente anziché eseguire la verifica su un singolo profilo.

Funzione TextIndependentIdentification

Per iniziare, creare la TextIndependentIdentification funzione:

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 SpeakerIdentify funzione come segue:

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 passa l'oggetto VoiceProfile creato in precedenza. Se si desidera, è possibile passare più VoiceProfile oggetti, ognuno registrato con campioni audio da una voce diversa.

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 main funzione 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 le funzioni definite in precedenza. Prima di tutto, 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 profili vocali. L'oggetto SpeakerRecognizer viene usato per convalidare gli esempi vocali rispetto a uno o più profili vocali registrati.

Modificare il tipo di input audio

Gli esempi in questo articolo usano il microfono del dispositivo predefinito come input per i campioni audio. Negli scenari in cui è necessario usare i file audio anziché l'input del microfono, 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 avere input misti usando un microfono per la registrazione e i file per la verifica, ad esempio.

Documentazione | di riferimentoPacchetto (Go) | Esempi aggiuntivi in GitHub

In questa guida introduttiva vengono illustrati i modelli di progettazione di base per il riconoscimento del parlante usando Speech SDK, tra cui:

  • Verifica dipendente dal testo e indipendente dal testo.
  • Identificazione dell'altoparlante per identificare un campione vocale tra un gruppo di voci.
  • Eliminazione dei profili vocali.

Per un'analisi generale dei concetti relativi al riconoscimento degli altoparlanti, vedere l'articolo Panoramica . Per un elenco delle piattaforme supportate, vedere il nodo Riferimento nel riquadro sinistro.

Importante

Microsoft limita l'accesso al riconoscimento del parlante. Applicare l'applicazione per usarla tramite il modulo di revisione dell'accesso limitato per il riconoscimento del parlante di Intelligenza artificiale di Azure . Dopo l'approvazione, è possibile accedere alle API riconoscimento altoparlanti.

Prerequisiti

  • Sottoscrizione di Azure: creare un account gratuito.
  • nella portale di Azure.
  • Chiave e area della risorsa Voce. Dopo la distribuzione della risorsa Voce, selezionare Vai alla risorsa per visualizzare e gestire le chiavi. Per altre informazioni sulle risorse dei servizi di intelligenza artificiale di Azure, vedere Ottenere le chiavi per la risorsa.

Configurare l'ambiente

Installare Speech SDK per Go. Controllare la guida all'installazione dell'SDK per altri requisiti

Eseguire l'identificazione indipendente

Seguire questa procedura per creare un nuovo modulo GO.

  1. Aprire un prompt dei comandi in cui si vuole il nuovo modulo e creare un nuovo file denominato independent-identification.go.

  2. Sostituire il contenuto di independent-identification.go con il codice seguente.

    package main

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

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

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

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

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

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

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

    EnrollProfile(client, profile, audioConfig)

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

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

  3. In independent-identification.gosostituire YourSubscriptionKey con la chiave di risorsa Voce e sostituire YourServiceRegion con l'area della risorsa Voce.

    Importante

    Al termine, ricordarsi di rimuovere la chiave dal codice e non renderlo mai pubblico. Per la produzione, usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault. Per altre informazioni, vedere l'articolo sulla sicurezza dei servizi di intelligenza artificiale di Azure.

Eseguire i comandi seguenti per creare un go.mod file che collega ai componenti ospitati in GitHub:

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

Compilare ed eseguire il codice:

go build
go run independent-identification

Eseguire la verifica indipendente

Seguire questa procedura per creare un nuovo modulo GO.

  1. Aprire un prompt dei comandi in cui si vuole il nuovo modulo e creare un nuovo file denominato independent-verification.go.

  2. Sostituire il contenuto di independent-verification.go con il codice seguente.

    package main

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

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

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

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

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

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

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

    EnrollProfile(client, profile, audioConfig)

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

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

  3. In independent-verification.gosostituire YourSubscriptionKey con la chiave di risorsa Voce e sostituire YourServiceRegion con l'area della risorsa Voce.

Eseguire i comandi seguenti per creare un go.mod file che collega ai componenti ospitati in GitHub:

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

Compilare ed eseguire il codice:

go build
go run independent-verification

Pulire le risorse

È possibile usare la portale di Azure o l'interfaccia della riga di comando di Azure per rimuovere la risorsa Voce creata.

Documentazione di | riferimentoEsempi aggiuntivi in GitHub

Speech SDK per Java supporta il riconoscimento dell'altoparlante, ma non è ancora stata inclusa una guida qui. Selezionare un altro linguaggio di programmazione per iniziare e informazioni sui concetti oppure vedere i riferimenti e gli esempi Java collegati dall'inizio di questo articolo.

Documentazione di | riferimentoPacchetto (npm) | Esempi aggiuntivi in GitHub | Codice sorgente della libreria

In questa guida introduttiva si apprenderà i modelli di progettazione di base per il riconoscimento degli altoparlanti usando Speech SDK, tra cui:

  • Verifica dipendente dal testo e indipendente dal testo.
  • Identificazione dell'altoparlante per identificare un campione vocale tra un gruppo di voci.
  • Eliminazione dei profili vocali.

Per un'analisi generale dei concetti relativi al riconoscimento degli altoparlanti, vedere l'articolo Panoramica . Per un elenco delle piattaforme supportate, vedere il nodo Riferimento nel riquadro sinistro.

Importante

Microsoft limita l'accesso al riconoscimento del parlante. Applicare l'applicazione per usarla tramite il modulo di revisione dell'accesso limitato per il riconoscimento del parlante di Intelligenza artificiale di Azure . Dopo l'approvazione, è possibile accedere alle API riconoscimento altoparlanti.

Prerequisiti

  • Sottoscrizione di Azure: creare un account gratuito.
  • nella portale di Azure.
  • Chiave e area della risorsa Voce. Dopo la distribuzione della risorsa Voce, selezionare Vai alla risorsa per visualizzare e gestire le chiavi. Per altre informazioni sulle risorse dei servizi di intelligenza artificiale di Azure, vedere Ottenere le chiavi per la risorsa.

Installare Speech SDK

Prima di iniziare, è necessario installare Speech SDK per JavaScript.

A seconda dell'ambiente di destinazione, usare uno dei seguenti elementi:

Scaricare ed estrarre speech SDK per JavaScript microsoft.cognitiveservices.speech.sdk.bundle.js file. Inserirlo in una cartella accessibile al file HTML.

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

Suggerimento

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

Importare le dipendenze

Per eseguire gli esempi in questo articolo, aggiungere le istruzioni seguenti nella parte superiore del file di .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;

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

Importante

Al termine, ricordarsi di rimuovere la chiave dal codice e non renderlo mai pubblico. Per la produzione, usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault. Per altre informazioni, vedere l'articolo sulla sicurezza dei servizi di intelligenza artificiale di Azure.

Creare una funzione helper

Aggiungere la funzione helper seguente per leggere i file audio nei flussi da usare dal servizio Voce:

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

In questa funzione si usano i metodi AudioInputStream.createPushStream e AudioConfig.fromStreamInput per creare un oggetto AudioConfig. L'oggetto AudioConfig rappresenta un flusso audio. Si useranno diversi di questi AudioConfig oggetti durante le attività seguenti.

Verifica dipendente dal testo

La verifica dell'altoparlante è l'atto di confermare che un altoparlante corrisponde a una voce nota o registrata. Il primo passaggio consiste nel registrare un profilo vocale in modo che il servizio disponga di un elemento per confrontare gli esempi vocali futuri rispetto a . In questo esempio si registra il profilo 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 {
        const type = sdk.VoiceProfileType.TextDependentVerification;
        // Create the profile.
        profile = await client.createProfileAsync(type, profile_locale);
        console.log ("Created profile ID: " + profile.profileId);
        // Get the activation phrases
        await GetActivationPhrases(type, profile_locale);
        await AddEnrollmentsToTextDependentProfile(client, profile, passphrase_files);
        const audio_config = GetAudioConfigFromFile(verify_file);
        const recognizer = new sdk.SpeakerRecognizer(speech_config, audio_config);
        await SpeakerVerify(profile, recognizer);
    }
    catch (error) {
        console.log ("Error:\n" + error);
    }
    finally {
        if (profile !== null) {
            console.log ("Deleting profile ID: " + profile.profileId);
            const deleteResult = await client.deleteProfileAsync (profile);
        }
    }
}

Questa funzione crea un oggetto VoiceProfile con il metodo VoiceProfileClient.createProfileAsync. Esistono tre tipi di 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)
{
    try {
        for (const file of audio_files) {
            console.log ("Adding enrollment to text dependent profile...");
            const audio_config = GetAudioConfigFromFile(file);
            const result = await client.enrollProfileAsync(profile, audio_config);
            if (result.reason === sdk.ResultReason.Canceled) {
                throw(JSON.stringify(sdk.VoiceProfileEnrollmentCancellationDetails.fromResult(result)));
            }
            else {
                console.log ("Remaining enrollments needed: " + result.privDetails["remainingEnrollmentsCount"] + ".");
            }
        };
        console.log ("Enrollment completed.\n");
    } catch (error) {
        console.log ("Error adding enrollments: " + error);
    }
}

In questa funzione viene chiamata la funzione GetAudioConfigFromFile definita in precedenza per creare AudioConfig oggetti dai campioni audio. Questi esempi audio contengono una passphrase, ad esempio "La mia voce è il mio passaporto, verificami". Si registrano quindi questi esempi audio usando il metodo VoiceProfileClient.registrProfileAsync .

Funzione SpeakerVerify

Definire SpeakerVerify come segue:

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

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 score proprietà 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 esito positivo, la reason proprietà deve avere il valore RecognizedSpeaker.

Verifica indipendente dal testo

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

  • Non richiede una certa passphrase da parlare. Tutto può essere parlato.
  • Non richiede tre esempi 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 {
        const type = sdk.VoiceProfileType.TextIndependentVerification;
        // Create the profile.
        profile = await client.createProfileAsync(type, profile_locale);
        console.log ("Created profile ID: " + profile.profileId);
        // Get the activation phrases
        await GetActivationPhrases(type, profile_locale);
        await AddEnrollmentsToTextIndependentProfile(client, profile, [identify_file]);
        const audio_config = GetAudioConfigFromFile(passphrase_files[0]);
        const recognizer = new sdk.SpeakerRecognizer(speech_config, audio_config);
        await SpeakerVerify(profile, recognizer);
    }
    catch (error) {
        console.log ("Error:\n" + error);
    }
    finally {
        if (profile !== null) {
            console.log ("Deleting profile ID: " + profile.profileId);
            const deleteResult = await client.deleteProfileAsync (profile);
        }
    }
}

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

In questa funzione viene chiamata la funzione GetAudioConfigFromFile definita in precedenza per creare AudioConfig oggetti dai campioni audio. Si registrano quindi questi esempi audio usando il metodo VoiceProfileClient.registrProfileAsync .

Identificazione voce

L'identificazione del parlante viene usata per determinare chi parla da un determinato gruppo di voci registrate. Il processo è simile alla verifica indipendente dal testo. La differenza principale è la capacità di verificare su più profili vocali contemporaneamente anziché verificare su 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 {
        const type = sdk.VoiceProfileType.TextIndependentIdentification;
        // Create the profile.
        profile = await client.createProfileAsync(type, profile_locale);
        console.log ("Created profile ID: " + profile.profileId);
        // Get the activation phrases
        await GetActivationPhrases(type, profile_locale);
        await AddEnrollmentsToTextIndependentProfile(client, profile, [identify_file]);
        const audio_config = GetAudioConfigFromFile(passphrase_files[0]);
        const recognizer = new sdk.SpeakerRecognizer(speech_config, audio_config);
        await SpeakerIdentify(profile, recognizer);
    }
    catch (error) {
        console.log ("Error:\n" + error);
    }
    finally {
        if (profile !== null) {
            console.log ("Deleting profile ID: " + profile.profileId);
            const deleteResult = await client.deleteProfileAsync (profile);
        }
    }
}

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 SpeakerIdentify funzione come indicato di seguito:

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

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 profileId proprietà identifica la corrispondenza VoiceProfile, se presente, mentre la score proprietà contiene un punteggio di somiglianza compreso tra 0,0 e 1,0.

Funzione main

Infine, definire la main funzione 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.

Documentazione di | riferimentoPacchetto (download) | Esempi aggiuntivi in GitHub

Speech SDK per Objective-C non supporta il riconoscimento altoparlante. Selezionare un altro linguaggio di programmazione o informazioni di riferimento su Objective-C e esempi collegati all'inizio di questo articolo.

Documentazione di | riferimentoPacchetto (download) | Esempi aggiuntivi in GitHub

Speech SDK per Swift non supporta il riconoscimento dell'altoparlante. Selezionare un altro linguaggio di programmazione o i riferimenti a Swift e esempi collegati dall'inizio di questo articolo.

Documentazione di | riferimentoPacchetto (PyPi) | Esempi aggiuntivi in GitHub

Speech SDK per Python non supporta il riconoscimento dell'altoparlante. Selezionare un altro linguaggio di programmazione o i riferimenti e gli esempi python collegati all'inizio di questo articolo.

Informazioni di riferimento per l'API REST di riconoscimento vocale | API REST voce per brevi riferimenti | audioEsempi aggiuntivi in GitHub

In questa guida introduttiva si apprenderà i modelli di progettazione di base per il riconoscimento degli altoparlanti usando Speech SDK, tra cui:

  • Verifica dipendente dal testo e indipendente dal testo.
  • Identificazione dell'altoparlante per identificare un campione vocale tra un gruppo di voci.
  • Eliminazione dei profili vocali.

Per un'analisi generale dei concetti relativi al riconoscimento degli altoparlanti, vedere l'articolo Panoramica . Per un elenco delle piattaforme supportate, vedere il nodo Riferimento nel riquadro sinistro.

Importante

Microsoft limita l'accesso al riconoscimento del parlante. Applicare l'applicazione per usarla tramite il modulo di revisione dell'accesso limitato per il riconoscimento del parlante di Intelligenza artificiale di Azure . Dopo l'approvazione, è possibile accedere alle API riconoscimento altoparlanti.

Prerequisiti

  • Sottoscrizione di Azure: creare un account gratuito.
  • nella portale di Azure.
  • Chiave e area della risorsa Voce. Dopo la distribuzione della risorsa Voce, selezionare Vai alla risorsa per visualizzare e gestire le chiavi. Per altre informazioni sulle risorse dei servizi di intelligenza artificiale di Azure, vedere Ottenere le chiavi per la risorsa.

Verifica dipendente dal testo

La verifica dell'altoparlante è l'atto di confermare che un altoparlante corrisponde a una voce nota o registrata. Il primo passaggio consiste nel registrare un profilo vocale in modo che il servizio disponga di un elemento per confrontare gli esempi vocali futuri rispetto a . In questo esempio si registra il profilo 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. È necessario inserire la chiave e l'area della sottoscrizione del servizio voce in ognuno dei comandi curl in questo articolo.

Importante

Al termine, ricordarsi di rimuovere la chiave dal codice e non renderlo mai pubblico. Per la produzione, usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault. Per altre informazioni, vedere l'articolo sulla sicurezza dei servizi di intelligenza artificiale di Azure.

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

Esistono tre tipi di profilo vocale:

  • 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. È consigliabile ricevere 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 --data-binary parametro, specificare un file audio nel computer che contiene una delle passphrase supportate, ad esempio "La mia voce è il mio passaporto, verificami". È possibile registrare un file audio con un'app come Registratore vocale Windows. In alternativa, è possibile generarlo usando il testo per la voce.

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

È consigliabile ricevere 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 esempi audio, è necessario ricevere 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 momento si è pronti per verificare un esempio audio sul 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-recognition/verification/text-dependent/profiles/INSERT_PROFILE_ID_HERE:verify?api-version=2021-09-05' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE' \
--header 'Content-Type: audio/wav' \
--data-binary @'INSERT_FILE_PATH_HERE'

È consigliabile ricevere la risposta seguente:

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

Accept indica la passphrase corrispondente e 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-recognition/verification/text-dependent/profiles/INSERT_PROFILE_ID_HERE?api-version=2021-09-05' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE'

Non c'è risposta.

Verifica indipendente dal testo

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

  • Non richiede che venga pronunciata una determinata passphrase. Tutto può essere parlato.
  • 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-recognition/verification/text-independent/profiles?api-version=2021-09-05' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE' \
--header 'Content-Type: application/json' \
--data-raw '{
    '\''locale'\'':'\''en-us'\''
}'

Si riceverà la risposta seguente:

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

Successivamente, si procederà alla registrazione del profilo vocale. Anche in questo caso, invece di inviare tre campioni audio, è necessario inviare campioni audio che contengono un totale di 20 secondi di audio.

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

Dopo aver inviato esempi audio sufficienti, 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 momento si è pronti per verificare un campione audio rispetto al profilo vocale. Anche in questo esempio audio non è necessario contenere una passphrase. Può contenere qualsiasi parlato, ma deve contenere un totale di almeno quattro secondi di audio.

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

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-recognition/verification/text-independent/profiles/INSERT_PROFILE_ID_HERE?api-version=2021-09-05' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE'

Non c'è risposta.

Identificazione voce

L'identificazione del parlante viene usata per determinare chi parla da un determinato gruppo di voci registrate. Il processo è simile alla verifica indipendente dal testo. La differenza principale è la possibilità di verificare con più profili vocali contemporaneamente anziché eseguire la verifica su 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-recognition/identification/text-independent/profiles?api-version=2021-09-05' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE' \
--header 'Content-Type: application/json' \
--data-raw '{
    '\''locale'\'':'\''en-us'\''
}'

Si riceverà la risposta seguente:

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

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 esempi non devono contenere una passphrase.

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

Dopo aver inviato esempi audio sufficienti, 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 momento si è pronti per identificare un campione audio usando il profilo vocale. Il comando di identificazione accetta un elenco delimitato da virgole di possibili ID di profilo vocale. In questo caso, si passerà l'ID del profilo vocale creato in precedenza. Se si desidera, è possibile passare più ID profilo vocale in cui ogni profilo vocale viene registrato con campioni audio da una voce diversa.

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

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-recognition/identification/text-independent/profiles/INSERT_PROFILE_ID_HERE?api-version=2021-09-05' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE'

Non c'è risposta.

L'interfaccia della riga di comando di Voce supporta il riconoscimento del parlante, ma non è ancora stata inclusa una guida qui. Selezionare un altro linguaggio di programmazione per iniziare e ottenere informazioni sui concetti.

Passaggi successivi

Vedere gli esempi di avvio rapido in GitHub