Aan de slag met Speaker Recognition

  • Artikel
  • 31 minuten om te lezen

In deze quickstart leert u basispatronen voor het ontwerp van Speaker Recognition met behulp van de Speech SDK, met inbegrip van:

  • Tekstafhankelijke en tekstonafhankelijke verificatie
  • Sprekeridentificatie voor het identificeren van een spraaksample in een groep stemmen
  • Spraakprofielen verwijderen

Zie het overzichtsartikel voor Speaker Recognition algemene concepten. Zie het knooppunt Verwijzing aan de linkerkant voor een lijst met de ondersteunde platforms.

Vereisten

In dit artikel wordt ervan uitgegaan dat u een Azure-account en een abonnement op de Speech-service hebt. Als u geen account en abonnement hebt, kunt u de Speech-service gratis uitproberen.

Belangrijk

Microsoft beperkt de toegang tot Speaker Recognition. Pas toe om dit te gebruiken via Azure Cognitive Services Speaker Recognition beperkte toegangsbeoordeling. Na goedkeuring hebt u toegang tot de Speaker Recognition API's.

De Speech-SDK installeren

Voordat u iets kunt doen, moet u de Speech SDK installeren. Gebruik de volgende instructies, afhankelijk van uw platform:

Afhankelijkheden importeren

Als u de voorbeelden in dit artikel wilt uitvoeren, voegt u boven aan het script de volgende using-instructies toe.

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

Een spraakconfiguratie maken

Als u de Speech-service wilt aanroepen met behulp van de Speech SDK, moet u een SpeechConfig maken. In dit voorbeeld maakt u een SpeechConfig met behulp van een abonnementssleutel en regio. U schrijft ook wat eenvoudige standaardcode voor gebruik in de rest van dit artikel. U gaat de code voor verschillende aanpassingen wijzigen.

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

Tekstafhankelijke verificatie

Met Speaker Verification wordt bevestigd dat een spreker overeenkomt met een bekende of geregistreerde stem. De eerste stap bestaat uit het registreren van een spraakprofiel, zodat dit met latere spraaksamples kan worden vergeleken. In dit voorbeeld moet u het profiel registreren door middel van een tekstafhankelijke strategie, waarvoor een specifieke wachtwoordzin is vereist voor zowel de registratie als de verificatie. Zie het referentiemateriaal voor een lijst met ondersteunde wachtwoordenzinnen.

Begin met het maken van de volgende functie in uw Program-klasse om een spraakprofiel te registreren.

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

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

In deze functie wordt met await client.CreateProfileAsync() feitelijk het nieuwe spraakprofiel gemaakt. Nadat dit is gemaakt, geeft u op hoe u audiosamples wilt invoeren. Dat doet u in dit voorbeeld met AudioConfig.FromDefaultMicrophoneInput() om audio op te nemen van uw standaardinvoerapparaat. Vervolgens registreert u audiosamples in een while-lus, waarmee het aantal voor de registratie resterende en vereiste samples wordt gevolgd. In elke iteratie vraagt client.EnrollProfileAsync(profile, audioInput) u om de wachtwoordzin in uw microfoon in te spreken en voegt u de sample aan het spraakprofiel toe.

Nadat de sample is geregistreerd, roept u await SpeakerVerify(config, profile, profileMapping) aan als verificatie tegen het profiel dat u zojuist hebt gemaakt. Voeg een andere functie toe om SpeakerVerify te definiëren.

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

Met deze functie geeft u het VoiceProfile-object door dat u zojuist hebt gemaakt om een model te initialiseren waartegen de verificatie moet worden uitgevoerd. await speakerRecognizer.RecognizeOnceAsync(model) vraagt u vervolgens de wachtwoordzin opnieuw uit te spreken, maar deze keer wordt de zin gevalideerd tegen uw spraakprofiel en wordt er een vergelijkingsscore geretourneerd. Deze loopt van 0,0 tot 1.0. Het result-object retourneert ook Accept of Reject, op basis van het feit of de wachtwoordzin al dan niet overeenkomt.

Wijzig vervolgens de Main()-functie om de nieuwe functies aan te roepen die u hebt gemaakt. Houd er tevens rekening mee dat u een Dictionary<string, string> maakt, die als verwijzing via de functieaanroepen moet worden doorgegeven. De reden hiervoor is dat de service geen door de mens leesbare naam met een gemaakt VoiceProfile mag opslaan en vanwege privacydoeleinden alleen een id-nummer opslaat. In de VerificationEnroll-functie voegt u aan deze woordenlijst een item met de zojuist gemaakte id toe, samen met een tekstnaam. In scenario's voor het ontwikkelen van toepassingen waarbij u een leesbare naam moet weergeven, moet u deze toewijzing ergens opslaan. Dat kan niet met de service.

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

Voer het script uit en u wordt gevraagd om de volgende zin driemaal voor de registratie uit te spreken en nogmaals ter verificatie: Mijn stem is mijn paspoort, verifieer mij. Het resultaat dat wordt geretourneerd, is de vergelijkingsscore. Deze kunt u kunt gebruiken om uw eigen drempelwaarden voor de verificatie te maken.

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

Tekstonafhankelijke verificatie

In tegenstelling tot tekstafhankelijke verificatie, geldt voor tekstonafhankelijke verificatie:

  • Vereist geen drie audiosamples, maar vereist in totaal wel twintig seconden aan audio

Breng enkele eenvoudige wijzigingen aan uw VerificationEnroll-functie aan om over te schakelen op tekstonafhankelijke verificatie. Eerst wijzigt u het verificatietype in VoiceProfileType.TextIndependentVerification. Wijzig vervolgens de while-lus om result.RemainingEnrollmentsSpeechLength te volgen, waarna u net zolang wordt gevraagd te spreken totdat er twintig seconden aan audio is vastgelegd.

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

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

Voer het programma opnieuw uit. De vergelijkingsscore wordt ook hier geretourneerd.

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

Sprekeridentificatie

Speaker Identification wordt gebruikt om vast te stellen wie er spreekt uit een bepaalde groep geregistreerde stemmen. Het proces is vergelijkbaar met tekstonafhankelijke verificatie, waarbij het belangrijkste verschil is dat tegelijkertijd verificatie tegen meerdere spraakprofielen kan worden uitgevoerd in plaats van te verifiëren tegen één profiel.

Maak een IdentificationEnroll-functie om meerdere spraakprofielen te registreren. Het registratieproces voor elk profiel is hetzelfde als het registratieproces voor tekstonafhankelijke verificatie en vereist twintig seconden aan audio voor elk profiel. Deze functie accepteert een lijst tekenreeksen, profileNames, en maakt een nieuw spraakprofiel voor elke naam in de lijst. De functie retourneert een lijst VoiceProfile-objecten, die u in de volgende functie gebruikt om een spreker te identificeren.

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

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

Maak de volgende SpeakerIdentification-functie om een identificatieverzoek in te dienen. Het belangrijkste verschil in deze functie vergeleken met een verzoek tot sprekercontrole is het gebruik van SpeakerIdentificationModel.FromProfiles(), waarmee een lijst met VoiceProfile-objecten wordt geaccepteerd.

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

Wijzig de Main()-functie in de volgende. U maakt een lijst met tekenreeksen, profileNames, die u doorgeeft aan de IdentificationEnroll()-functie. Hiermee wordt u gevraagd om voor elke naam in deze lijst een nieuw spraakprofiel te maken, zodat u meer namen kunt toevoegen om extra profielen voor vrienden of collega's te maken.

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

Voer het script uit en u wordt gevraagd om te spreken om spraakvoorbeelden voor het eerste profiel te registreren. Nadat de registratie is voltooid, wordt u gevraagd dit proces te herhalen voor elke naam in lijst profileNames. Nadat alle registraties zijn voltooid, wordt u gevraagd iemand te laten spreken. De service probeert deze persoon te identificeren uit de geregistreerde spraakprofielen.

In dit voorbeeld worden alleen de vergelijkingsscore en het resultaat dat het meest overeenkomt geretourneerd. U kunt het volledige antwoord krijgen met de vijf hoogste vergelijkingsscores door string json = result.Properties.GetProperty(PropertyId.SpeechServiceResponse_JsonResult) aan de SpeakerIdentification-functie toe te voegen.

Type audio-invoer wijzigen

In de voorbeelden in dit artikel wordt de standaardmicrofoon van het apparaat gebruikt als invoer voor audiosamples. In scenario's waarin u echter audiobestanden moet gebruiken in plaats van de microfooninvoer, wijzigt u een willekeurige instantie van AudioConfig.FromDefaultMicrophoneInput() in AudioConfig.FromWavFileInput(path/to/your/file.wav) om over te schakelen naar een bestandsinvoer. Gemengde invoer is ook mogelijk, met behulp van bijvoorbeeld een microfoon voor de inschrijving en bestanden voor de verificatie.

Registraties van spraakprofielen verwijderen

Als u een geregistreerd profiel wilt verwijderen, gebruikt u de DeleteProfileAsync()-functie voor het VoiceProfileClient-object. In de volgende voorbeeldfunctie ziet u hoe u een spraakprofiel van een bekende spraakprofiel-id verwijdert.

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

In deze quickstart leert u basispatronen voor het ontwerp van Speaker Recognition met behulp van de Speech SDK, met inbegrip van:

  • Tekstafhankelijke en tekstonafhankelijke verificatie
  • Sprekeridentificatie voor het identificeren van een spraaksample in een groep stemmen
  • Spraakprofielen verwijderen

Zie het overzichtsartikel voor Speaker Recognition algemene concepten. Zie het knooppunt Verwijzing aan de linkerkant voor een lijst met de ondersteunde platforms.

Naar voorbeelden op GitHub

Raadpleeg de C++-quickstartvoorbeelden op GitHub als u direct naar voorbeeldcode wilt gaan.

Vereisten

In dit artikel wordt ervan uitgegaan dat u een Azure-account en een abonnement op de Speech-service hebt. Als u geen account en abonnement hebt, kunt u de Speech-service gratis uitproberen.

Belangrijk

Microsoft beperkt de toegang tot Speaker Recognition. Pas toe om dit te gebruiken via Azure Cognitive Services Speaker Recognition Beperkte toegangsbeoordeling. Na goedkeuring hebt u toegang tot de Speaker Recognition API's.

De Speech-SDK installeren

Voordat u iets kunt doen, moet u de Speech SDK installeren. Gebruik de volgende instructies, afhankelijk van uw platform:

Afhankelijkheden importeren

Als u de voorbeelden in dit artikel wilt uitvoeren, voegt u boven aan het cpp-bestand de volgende instructies toe.

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

Een spraakconfiguratie maken

Als u de Speech-service wilt aanroepen met behulp van de Speech SDK, moet u een SpeechConfig maken. Deze klasse bevat informatie over uw abonnement, zoals uw sleutel en de bijbehorende regio, het eindpunt, de host of het autorisatietoken.

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

Tekstafhankelijke verificatie

Met Speaker Verification wordt bevestigd dat een spreker overeenkomt met een bekende of geregistreerde stem. De eerste stap bestaat uit het registreren van een spraakprofiel, zodat dit met latere spraaksamples kan worden vergeleken. In dit voorbeeld moet u het profiel registreren door middel van een tekstafhankelijke strategie, waarvoor een specifieke wachtwoordzin is vereist voor zowel de registratie als de verificatie. Zie het referentiemateriaal voor een lijst met ondersteunde wachtwoordzinnen.

De functie TextDependentVerification

Begin door de functie TextDependentVerification te maken.

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

Deze functie maakt een VoiceProfile-object met de methode CreateProfileAsync. Houd er rekening mee dat er drie typen van VoiceProfile zijn:

  • TextIndependentIdentification
  • TextDependentVerification
  • TextIndependentVerification

In dit geval geeft u VoiceProfileType::TextDependentVerification door aan CreateProfileAsync.

Vervolgens roept u twee hulpfuncties aan die u hierna definieert, AddEnrollmentsToTextDependentProfile en SpeakerVerify. Ten slotte roept u DeleteProfileAsync aan om het profiel op te schonen.

De functie AddEnrollmentsToTextDependentProfile

Definieer de volgende functie om een spraakprofiel in te schrijven.

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 deze functie registreert u audiosamples in een while-lus, waarmee het aantal voor de registratie resterende en vereiste samples wordt gevolgd. In elke iteratie vraagt EnrollProfileAsync u om de wachtwoordzin in uw microfoon in te spreken en voegt u de sample aan het spraakprofiel toe.

De functie SpeakerVerify

Definieer SpeakerVerify als volgt.

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 deze functie maakt u een SpeakerVerificationModel-object met de methode SpeakerVerificationModel::FromProfile, waarbij u het VoiceProfile-object dat u eerder hebt gemaakt, doorgeeft.

Vervolgens vraagt SpeechRecognizer:: RecognizeOnceAsync u om de wachtwoordzin opnieuw te spreken, maar deze keer wordt deze gecontroleerd aan de hand van uw spraakprofiel en wordt een vergelijkingsscore van 0,0 -1,0 geretourneerd. Het SpeakerRecognitionResult-object retourneert ook Accept of Reject, afhankelijk van of de wachtwoordzin overeenkomt.

Tekstonafhankelijke verificatie

In tegenstelling tot tekstafhankelijke verificatie zijn voor tekst-onafhankelijke verificatie geen drie audiovoorbeelden nodig, maar wel 20 seconden aan totale audio.

De functie TextIndependentVerification

Begin door de functie TextIndependentVerification te maken.

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

Net als de functie TextDependentVerification maakt deze functie een VoiceProfile-object met de methode CreateProfileAsync.

In dit geval geeft u VoiceProfileType::TextIndependentVerification door aan CreateProfileAsync.

Vervolgens roept u twee hulpfuncties aan: AddEnrollmentsToTextIndependentProfile, die u hierna definieert, en SpeakerVerify, die u al hebt gedefinieerd. Ten slotte roept u DeleteProfileAsync aan om het profiel op te schonen.

AddEnrollmentsToTextIndependentProfile

Definieer de volgende functie om een spraakprofiel in te schrijven.

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 deze functie registreert u audiosamples in een while-lus, waarmee het aantal voor de registratie resterende en vereiste seconden audio wordt gevolgd. In elke iteratie vraagt EnrollProfileAsync u om in uw microfoon te spreken en voegt de sample aan het spraakprofiel toe.

Sprekeridentificatie

Speaker Identification wordt gebruikt om vast te stellen wie er spreekt uit een bepaalde groep geregistreerde stemmen. Het proces is vergelijkbaar met tekstonafhankelijke verificatie, waarbij het belangrijkste verschil is dat tegelijkertijd verificatie tegen meerdere spraakprofielen kan worden uitgevoerd in plaats van te verifiëren tegen één profiel.

De functie TextIndependentIdentification

Begin door de functie TextIndependentIdentification te maken.

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

Net als de functies TextDependentVerification en TextIndependentVerification maakt deze functie een VoiceProfile-object met de methode CreateProfileAsync.

In dit geval geeft u VoiceProfileType::TextIndependentIdentification door aan CreateProfileAsync.

Vervolgens roept u twee hulpfuncties aan: AddEnrollmentsToTextIndependentProfile, die u als hebt gedefinieerd, en SpeakerIdentify, die u hierna definieert. Ten slotte roept u DeleteProfileAsync aan om het profiel op te schonen.

De functie SpeakerIdentify

Definieer de functie SpeakerIdentify als volgt.

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 deze functie maakt u een SpeakerIdentificationModel-object met de methode SpeakerIdentificationModel::FromProfiles. SpeakerIdentificationModel::FromProfiles accepteert een lijst van VoiceProfile-objecten. In dit geval geeft u alleen het object VoiceProfile dat u eerder hebt gemaakt door. Als u wilt, kunt u echter meerdere VoiceProfile-objecten doorgeven, die allemaal zijn ingeschreven met audiosamples van een andere stem.

Vervolgens vraagt SpeechRecognizer::RecognizeOnceAsync u om opnieuw te spreken. Nu vergelijkt deze uw stem met de ingeschreven spraakprofielen en wordt het meest vergelijkbare spraakprofiel geretourneerd.

Hoofdfunctie

Definieer tenslotte de functie main als volgt.

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

Deze functie roept gewoon de functies aan die u eerder hebt gedefinieerd. Er wordt echter eerst een VoiceProfileClient-object en een SpeakerRecognizer-object gemaakt.

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

De VoiceProfileClient wordt gebruikt voor het maken, inschrijven en verwijderen van spraakprofielen. De SpeakerRecognizer wordt gebruikt om spraakvoorbeelden te valideren op basis van een of meer ingeschreven spraakprofielen.

Type audio-invoer wijzigen

In de voorbeelden in dit artikel wordt de standaardmicrofoon van het apparaat gebruikt als invoer voor audiosamples. In scenario's waarin u echter audiobestanden moet gebruiken in plaats van de microfooninvoer, wijzigt u de volgende regel:

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

in:

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

Of u vervangt het gebruik van audio_config door Audio::AudioConfig::FromWavFileInput. Gemengde invoer is ook mogelijk, met behulp van bijvoorbeeld een microfoon voor de inschrijving en bestanden voor de verificatie.

In deze quickstart leert u basispatronen voor het ontwerp van Speaker Recognition met behulp van de Speech SDK, met inbegrip van:

  • Tekstafhankelijke en tekstonafhankelijke verificatie
  • Sprekeridentificatie voor het identificeren van een spraaksample in een groep stemmen
  • Spraakprofielen verwijderen

Zie het overzichtsartikel voor Speaker Recognition algemene concepten. Zie het knooppunt Verwijzing aan de linkerkant voor een lijst met de ondersteunde platforms.

Naar voorbeelden op GitHub

Raadpleeg de JavaScript-quickstartvoorbeelden op GitHub als u direct naar voorbeeldcode wilt gaan.

Vereisten

In dit artikel wordt ervan uitgegaan dat u een Azure-account en een abonnement op de Speech-service hebt. Als u geen account en abonnement hebt, kunt u de Speech-service gratis uitproberen.

Belangrijk

Speaker Recognition wordt momenteel alleen ondersteund in Azure Speech-resources die in de regio westus zijn gemaakt.

De Speech-SDK installeren

Voordat u iets kunt doen, moet u de Speech-SDK installeren voor JavaScript. Gebruik de volgende instructies, afhankelijk van uw platform:

Afhankelijk van de doelomgeving gebruikt u daarnaast een van de volgende opties:

Download en extraheerde de Speech SDK voor JavaScript microsoft.cognitiveservices.speech.sdk.bundle.js en plaats het in een map die toegankelijk is voor uw HTML-bestand.

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

Tip

Als u een webbrowser als doel hebt en de tag <script> gebruikt, is het voorvoegsel sdk niet nodig. Het voorvoegsel sdk is een alias die wordt gebruikt om de require-module te benoemen.

Afhankelijkheden importeren

Als u de voorbeelden in dit artikel wilt uitvoeren, voegt u boven aan het JS-bestand de volgende instructies toe.

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

Met deze instructies worden de vereiste bibliotheken geïmporteerd, en worden uw abonnementssleutel en -regio voor de Speech-service opgehaald uit de omgevingsvariabelen. Ook worden paden naar audiobestanden opgeven die u gebruikt in de volgende taken.

Hulpfuncties maken

Voeg de volgende hulpfuncties toe om audiobestanden te lezen voor gebruik met de Speech-service.

/* 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 deze functie gebruikt u de methoden AudioInputStream.createPushStream en AudioConfig.fromStreamInput om een object AudioConfig te maken. Dit object AudioConfig vertegenwoordigt een audiostream. U gebruikt verschillende AudioConfig-objecten gedurende de volgende taken.

Tekstafhankelijke verificatie

Met Speaker Verification wordt bevestigd dat een spreker overeenkomt met een bekende of geregistreerde stem. De eerste stap bestaat uit het registreren van een spraakprofiel, zodat dit met latere spraaksamples kan worden vergeleken. In dit voorbeeld moet u het profiel registreren door middel van een tekstafhankelijke strategie, waarvoor een specifieke wachtwoordzin is vereist voor zowel de registratie als de verificatie. Zie het referentiemateriaal voor een lijst met ondersteunde wachtwoordzinnen.

De functie TextDependentVerification

Begin door de functie TextDependentVerification te maken.

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

Met deze functie wordt een object VoiceProfile gemaakt met de methode VoiceProfileClient.createProfileAsync. Houd er rekening mee dat er drie typen VoiceProfile zijn:

  • TextIndependentIdentification
  • TextDependentVerification
  • TextIndependentVerification

In dit geval geeft u VoiceProfileType.TextDependentVerification door aan VoiceProfileClient.createProfileAsync.

Vervolgens roept u twee hulpfuncties aan die u hierna definieert, AddEnrollmentsToTextDependentProfile en SpeakerVerify. Roep ten slotte VoiceProfileClient.deleteProfileAsync aan om het profiel te verwijderen.

De functie AddEnrollmentsToTextDependentProfile

Definieer de volgende functie om een spraakprofiel in te schrijven.

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 deze functie roept u de functie GetAudioConfigFromFile aan die u eerder hebt gedefinieerd, om AudioConfig-objecten te maken uit audiobestanden. Deze audiovoorbeelden bevatten een wachtwoordzin zoals: Mijn stem is mijn paspoort, verifieer mij. U kunt deze audiovoorbeelden vervolgens inschrijven met behulp van de methode VoiceProfileClient.enrollProfileAsync.

De functie SpeakerVerify

Definieer SpeakerVerify als volgt.

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 deze functie maakt u een object SpeakerVerificationModel met de methode SpeakerVerificationModel.FromProfile, waarbij u het object VoiceProfile doorgeeft dat u eerder hebt gemaakt.

Vervolgens roept u de methode SpeechRecognizer.recognizeOnceAsync aan om een audiovoorbeeld te valideren dat dezelfde wachtwoordzin bevat als de audiovoorbeelden die u eerder hebt ingeschreven. SpeechRecognizer.recognizeOnceAsync retourneert een object SpeakerRecognitionResult, waarvan eigenschap score een vergelijkbare score bevat, tussen 0.0-1.0. Het object SpeakerRecognitionResult bevat ook een eigenschap reason van het type ResultReason. Als de verificatie is geslaagd, moet de eigenschap reason de waarde RecognizedSpeaker hebben.

Tekstonafhankelijke verificatie

In tegenstelling tot tekstafhankelijke verificatie, geldt voor tekstonafhankelijke verificatie:

  • Vereist niet dat een bepaalde wachtwoordzin wordt uitgesproken. Alles mag worden uitgesproken
  • Vereist niet drie audiovoorbeelden, maar vereist in totaal wel twintig seconden aan audio

De functie TextIndependentVerification

Begin door de functie TextIndependentVerification te maken.

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

Net zoals met de functie TextDependentVerification wordt met deze functie een object VoiceProfile gemaakt met de methode VoiceProfileClient.createProfileAsync.

In dit geval geeft u VoiceProfileType.TextIndependentVerification door aan createProfileAsync.

Vervolgens roept u twee hulpfuncties aan: AddEnrollmentsToTextIndependentProfile, die u hierna definieert, en SpeakerVerify, die u al hebt gedefinieerd. Roep ten slotte VoiceProfileClient.deleteProfileAsync aan om het profiel te verwijderen.

AddEnrollmentsToTextIndependentProfile

Definieer de volgende functie om een spraakprofiel in te schrijven.

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 deze functie roept u de functie GetAudioConfigFromFile aan die u eerder hebt gedefinieerd, om AudioConfig-objecten te maken uit audiobestanden. U kunt deze audiovoorbeelden vervolgens inschrijven met behulp van de methode VoiceProfileClient.enrollProfileAsync.

Sprekeridentificatie

Speaker Identification wordt gebruikt om vast te stellen wie er spreekt uit een bepaalde groep geregistreerde stemmen. Het proces is vergelijkbaar met tekstonafhankelijke verificatie, waarbij het belangrijkste verschil is dat tegelijkertijd verificatie via meerdere spraakprofielen kan worden uitgevoerd in plaats van te verifiëren via één profiel.

De functie TextIndependentIdentification

Begin door de functie TextIndependentIdentification te maken.

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

Net zoals met de functies TextDependentVerification en TextIndependentVerification wordt met deze functie een object VoiceProfile gemaakt met de methode VoiceProfileClient.createProfileAsync.

In dit geval geeft u VoiceProfileType.TextIndependentIdentification door aan VoiceProfileClient.createProfileAsync.

Vervolgens roept u twee hulpfuncties aan: AddEnrollmentsToTextIndependentProfile, die u al hebt gedefinieerd, en SpeakerIdentify, die u hierna definieert. Roep ten slotte VoiceProfileClient.deleteProfileAsync aan om het profiel te verwijderen.

De functie SpeakerIdentify

Definieer de functie SpeakerIdentify als volgt.

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 deze functie maakt u een SpeakerIdentificationModel-object met de methode SpeakerIdentificationModel.fromProfile, waarbij u het object VoiceProfile doorgeeft dat u eerder hebt gemaakt.

Vervolgens roept u de methode SpeechRecognizer.recognizeOnceAsync aan en geeft u een audiovoorbeeld door. Met SpeechRecognizer.recognizeOnceAsync wordt geprobeerd om de spraak voor dit audiovoorbeeld te identificeren op basis van de VoiceProfile-objecten die u hebt gebruikt om de SpeakerIdentificationModel te maken. Het object SpeakerRecognitionResult wordt geretourneerd, waarvan de eigenschap profileId de overeenkomende VoiceProfile identificeert, indien aanwezig, terwijl de eigenschap score een vergelijkbare score bevat, tussen 0.0-1.0.

Hoofdfunctie

Definieer tenslotte de functie main als volgt.

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

Met deze functie wordt het object VoiceProfileClient gemaakt, dat wordt gebruikt om spraakprofielen te maken, in te schrijven en te verwijderen. Vervolgens worden de functies aangeroepen die u eerder hebt gedefinieerd.

In deze quickstart leert u basispatronen voor het ontwerp van Speaker Recognition met behulp van de Speech SDK, met inbegrip van:

  • Tekstafhankelijke en tekstonafhankelijke verificatie
  • Sprekeridentificatie voor het identificeren van een spraaksample in een groep stemmen
  • Spraakprofielen verwijderen

Zie het overzichtsartikel voor Speaker Recognition algemene concepten. Zie het knooppunt Verwijzing aan de linkerkant voor een lijst met de ondersteunde platforms.

Vereisten

In dit artikel wordt ervan uitgegaan dat u een Azure-account en een abonnement op de Speech-service hebt. Als u geen account en abonnement hebt, kunt u de Speech-service gratis uitproberen.

Belangrijk

Speaker Recognition wordt momenteel alleen ondersteund in Azure Speech-resources die in de regio westus zijn gemaakt.

Tekstafhankelijke verificatie

Met Speaker Verification wordt bevestigd dat een spreker overeenkomt met een bekende of geregistreerde stem. De eerste stap bestaat uit het registreren van een spraakprofiel, zodat dit met latere spraaksamples kan worden vergeleken. In dit voorbeeld moet u het profiel registreren door middel van een tekstafhankelijke strategie, waarvoor een specifieke wachtwoordzin is vereist voor zowel de registratie als de verificatie. Zie het referentiemateriaal voor een lijst met ondersteunde wachtwoordzinnen.

Eerst moet u een spraakprofiel maken. U moet de abonnementssleutel en regio voor uw spraakservice invoegen in elke cURL-opdracht in dit artikel.

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

Er zijn drie typen spraakprofielen:

  • Tekstafhankelijke verificatie
  • Tekstonafhankelijke verificatie
  • Tekstonafhankelijke identificatie

In dit geval maakt u een spraakprofiel van het type tekstafhankelijke verificatie. U ontvangt het volgende antwoord.

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

Vervolgens registreert u het spraakprofiel. Geef voor de parameterwaarde --data-binary een audiobestand op uw computer op dat een van de ondersteunde wachtwoordzinnen bevat, zoals 'mijn stem is mijn paspoort, verifieer mij'. U kunt een dergelijk audiobestand opnemen met een app, zoals Windows Voicerecorder, of u kunt deze genereren met behulp van tekst-naar-spraak.

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'

U ontvangt het volgende antwoord.

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

Dit antwoord vertelt u dat u nog twee audiosamples moet registreren.

Als u in totaal drie audiosamples hebt geregistreerd, ontvangt u het volgende antwoord.

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

Nu bent u klaar om een audiosample te verifiëren met het spraakprofiel. Dit audiosample moet dezelfde wachtwoordzin bevatten als de samples die u hebt gebruikt om het spraakprofiel te registreren.

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'

U ontvangt het volgende antwoord.

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

Accept betekent dat de wachtwoordzin overeenkomt en de verificatie is geslaagd. Het antwoord bevat ook een vergelijkingsscore, die kan variëren van 0,0 tot 1,0.

Tot slot verwijdert u het spraakprofiel.

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'

U ontvangt geen antwoord.

Tekstonafhankelijke verificatie

In tegenstelling tot tekstafhankelijke verificatie, geldt voor tekstonafhankelijke verificatie:

  • Vereist niet dat een bepaalde wachtwoordzin wordt uitgesproken. Alles mag worden uitgesproken
  • Vereist geen drie audiosamples, maar vereist in totaal wel twintig seconden aan audio

Eerst maakt u een profiel voor tekstonafhankelijke verificatie.

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

U ontvangt het volgende antwoord.

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

Vervolgens registreert u het spraakprofiel. In plaats van drie audiosamples in te dienen, moet u audiosamples met in totaal 20 seconden audio indienen.

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'

Als u genoeg audiosamples hebt geregistreerd, ontvangt u het volgende antwoord.

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

Nu bent u klaar om een audiosample te verifiëren met het spraakprofiel. Nogmaals, dit audiosample hoeft geen wachtwoordzin te bevatten. Het kan willekeurige spraak bevatten, zolang deze in een totaal ten minste vier seconden aan audio bevat.

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'

U ontvangt het volgende antwoord.

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

Accept betekent dat de verificatie is geslaagd. Het antwoord bevat ook een vergelijkingsscore, die kan variëren van 0,0 tot 1,0.

Tot slot verwijdert u het spraakprofiel.

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'

U ontvangt geen antwoord.

Sprekeridentificatie

Speaker Identification wordt gebruikt om vast te stellen wie er spreekt uit een bepaalde groep geregistreerde stemmen. Het proces is vergelijkbaar met tekstonafhankelijke verificatie, waarbij het belangrijkste verschil is dat tegelijkertijd verificatie tegen meerdere spraakprofielen kan worden uitgevoerd in plaats van te verifiëren tegen één profiel.

Eerst maakt u een profiel voor tekstonafhankelijke identificatie.

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

U ontvangt het volgende antwoord.

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

Vervolgens registreert u het spraakprofiel. Nogmaals, u moet audiosamples met in totaal twintig seconden audio indienen. Deze samples hoeven geen wachtwoordzin te bevatten.

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'

Als u genoeg audiosamples hebt geregistreerd, ontvangt u het volgende antwoord.

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

Nu bent u klaar om een audiosample te identificeren met het spraakprofiel. De identificatieopdracht accepteert een door komma's gescheiden lijst met mogelijke spraakprofiel-id's. In dit geval geeft u alleen de id op van het spraakprofiel dat u eerder hebt gemaakt. Als u wilt, kunt u echter meerdere spraakprofiel-id's doorgeven, waarbij elk spraakprofiel is ingeschreven met audiosamples van een andere stem.

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'

U ontvangt het volgende antwoord.

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

Het antwoord bevat de id van het spraakprofiel dat het meest overeenkomt met het audiosample dat u hebt ingediend. Het bevat ook een lijst met kandidaat-spraakprofielen, gerangschikt op volgorde van overeenkomst.

Tot slot verwijdert u het spraakprofiel.

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'

U ontvangt geen antwoord.

Volgende stappen

  • Raadpleeg het referentiemateriaal voor Speaker Recognition voor meer informatie over klassen en functies.

  • Kijk op GitHub voor voorbeelden in C# en C++.