Quickstart: Herkennen en verifiëren wie er spreekt

Referentiedocumentatie | Pakket (NuGet) | Aanvullende voorbeelden op GitHub

In deze quickstart leert u basisontwerppatronen voor sprekerherkenning met behulp van de Speech SDK, waaronder:

• Tekstafhankelijke en tekstonafhankelijke verificatie.
• Sprekeridentificatie om een spraakvoorbeeld te identificeren onder een groep stemmen.
• Spraakprofielen verwijderen.

Zie het artikel Overzicht voor een uitgebreid overzicht van de concepten van sprekerherkenning. Zie het knooppunt Verwijzing in het linkerdeelvenster voor een lijst met ondersteunde platforms.

Belangrijk

Microsoft beperkt de toegang tot sprekerherkenning. Pas toe om het te gebruiken via het formulier Beperkte toegangsbeoordeling van Azure AI Speaker Recognition . Na goedkeuring hebt u toegang tot de Speaker Recognition-API's.

Vereisten

• Azure-abonnement: Maak een gratis abonnement aan.
• Maak een spraakresource in de Azure Portal.
• Uw spraakresourcesleutel en -regio. Nadat uw Spraak-resource is geïmplementeerd, selecteert u Ga naar resource om sleutels weer te geven en te beheren. Zie De sleutels voor uw resource ophalen voor meer informatie over azure AI-servicesresources.

De Speech-SDK installeren

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

• .NET Framework
• .NET Core
• Eenheid
• UWP
• Xamarin

Afhankelijkheden importeren

Als u de voorbeelden in dit artikel wilt uitvoeren, voegt u de volgende using instructies toe aan het begin van uw script:

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 exemplaar maken. In dit voorbeeld maakt u een SpeechConfig exemplaar 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.

Belangrijk

Vergeet niet de sleutel uit uw code te verwijderen wanneer u klaar bent, en plaats deze sleutel nooit in het openbaar. Gebruik voor productie een veilige manier om uw referenties op te slaan en te openen, zoals Azure Key Vault. Zie het artikel Beveiliging van Azure AI-services voor meer informatie.

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

Sprekercontrole is het bevestigen dat een spreker overeenkomt met een bekende of ingeschreven stem. De eerste stap is het inschrijven van een spraakprofiel, zodat de service iets heeft om toekomstige spraaksamples mee te vergelijken. In dit voorbeeld registreert u het profiel met behulp van een tekstafhankelijke strategie. Hiervoor is een specifieke wachtwoordzin vereist voor inschrijving en verificatie. Zie het referentiemateriaal voor een lijst met ondersteunde wachtwoordzinnen.

Begin met het maken van de volgende functie in uw Program klasse om een spraakprofiel in te schrijven:

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 deze functie wordt met await client.CreateProfileAsync() feitelijk het nieuwe spraakprofiel gemaakt. Nadat het is gemaakt, geeft u op hoe u audiosamples invoert door AudioConfig.FromDefaultMicrophoneInput() in dit voorbeeld audio vast te leggen vanaf uw standaardinvoerapparaat. Vervolgens registreert u audiosamples in een while lus die het aantal resterende en vereiste samples voor inschrijving bijhoudt. In elke iteratie client.EnrollProfileAsync(profile, audioInput) wordt u gevraagd de wachtwoordzin in uw microfoon uit te spreken en het voorbeeld toe te voegen aan het spraakprofiel.

Nadat de inschrijving is voltooid, roept await SpeakerVerify(config, profile, profileMapping) u aan om te controleren op basis van 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) Vervolgens wordt u gevraagd de wachtwoordzin opnieuw uit te spreken. Deze keer wordt deze gevalideerd op basis van uw spraakprofiel en wordt een overeenkomstscore van 0,0 tot 1,0 geretourneerd. Het result object retourneert Accept ook of Reject, op basis van of de wachtwoordzin overeenkomt.

Wijzig vervolgens de Main()-functie om de nieuwe functies aan te roepen die u hebt gemaakt. Houd er ook rekening mee dat u een Dictionary<string, string> maakt om door te geven op verwijzing via uw functie-aanroepen. De reden hiervoor is dat de service het opslaan van een door mensen leesbare naam met een gemaakt VoiceProfileniet toestaat en alleen een id-nummer opslaat voor privacydoeleinden. 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 toepassingsontwikkeling waarin u een door mensen leesbare naam moet weergeven, moet u deze toewijzing ergens opslaan omdat de service deze niet kan opslaan.

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. U wordt gevraagd om de zin 'Mijn stem is mijn paspoort, verifieer mij' drie keer uit te spreken voor inschrijving en nog één keer voor verificatie. 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 vereist tekstonafhankelijke verificatie geen drie audiosamples, maar wel 20 seconden aan totale 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"))
    {
        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 en de overeenkomstscore wordt 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

Sprekeridentificatie wordt gebruikt om te bepalen wie er spreekt vanuit een bepaalde groep geregistreerde stemmen. Het proces is vergelijkbaar met tekstonafhankelijke verificatie. Het belangrijkste verschil is de mogelijkheid om te verifiëren op basis van meerdere spraakprofielen tegelijk in plaats van te verifiëren op basis van één profiel.

Maak een IdentificationEnroll-functie om meerdere spraakprofielen te registreren. Het inschrijvingsproces voor elk profiel is hetzelfde als het inschrijvingsproces voor tekstonafhankelijke verificatie. Het proces vereist 20 seconden audio voor elk profiel. Deze functie accepteert een lijst met 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))
    {
        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. U wordt gevraagd een nieuw spraakprofiel te maken voor elke naam in deze lijst, zodat u meer namen kunt toevoegen om meer 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. U wordt gevraagd om te spreken om spraakvoorbeelden in te schrijven voor het eerste profiel. Nadat de inschrijving is voltooid, wordt u gevraagd dit proces te herhalen voor elke naam in de profileNames lijst. Nadat elke inschrijving is voltooid, wordt u gevraagd om iemand te laten spreken. De service probeert deze persoon vervolgens te identificeren op basis van uw geregistreerde spraakprofielen.

In dit voorbeeld wordt alleen de dichtstbijzijnde overeenkomst en de bijbehorende gelijkenisscore geretourneerd. Als u het volledige antwoord wilt krijgen met de vijf belangrijkste overeenkomstenscores, voegt u toe string json = result.Properties.GetProperty(PropertyId.SpeechServiceResponse_JsonResult) aan uw SpeakerIdentification functie.

Audio-invoertype wijzigen

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

Inschrijvingen voor 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 verwijdert uit een bekende spraakprofiel-id:

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

Referentiedocumentatie | Pakket (NuGet) | Aanvullende voorbeelden op GitHub

In deze quickstart leert u basisontwerppatronen voor sprekerherkenning met behulp van de Speech SDK, waaronder:

• Tekstafhankelijke en tekstonafhankelijke verificatie.
• Sprekeridentificatie om een spraakvoorbeeld te identificeren tussen een groep stemmen.
• Spraakprofielen verwijderen.

Zie het artikel Overzicht voor een uitgebreid overzicht van de concepten voor sprekerherkenning. Zie het knooppunt Verwijzing in het linkerdeelvenster voor een lijst met de ondersteunde platforms.

Belangrijk

Microsoft beperkt de toegang tot sprekerherkenning. Pas toe om het te gebruiken via het formulier Azure AI Speaker Recognition Limited Access Review . Na goedkeuring hebt u toegang tot de Speaker Recognition-API's.

Vereisten

• Azure-abonnement: Maak een gratis abonnement aan.
• maken Maak een spraakresource in de Azure Portal.
• Uw spraakresourcesleutel en -regio. Nadat uw Spraak-resource is geïmplementeerd, selecteert u Ga naar resource om sleutels weer te geven en te beheren. Zie De sleutels voor uw resource ophalen voor meer informatie over azure AI-servicesresources.

De Speech-SDK installeren

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

• Linux
• Macos
• Windows

Afhankelijkheden importeren

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

#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, maakt u een SpeechConfig klasse. Deze klasse bevat informatie over uw abonnement, zoals uw sleutel en de bijbehorende regio, het eindpunt, de host of het autorisatietoken.

Belangrijk

Vergeet niet de sleutel uit uw code te verwijderen wanneer u klaar bent, en plaats deze sleutel nooit in het openbaar. Gebruik voor productie een veilige manier om uw referenties op te slaan en te openen, zoals Azure Key Vault. Zie het artikel Beveiliging van Azure AI-services voor meer informatie.

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

Sprekercontrole is het bevestigen dat een spreker overeenkomt met een bekende of ingeschreven stem. De eerste stap is het inschrijven van een spraakprofiel, zodat de service iets heeft om toekomstige spraaksamples mee te vergelijken. In dit voorbeeld schrijft u het profiel in met behulp van een tekstafhankelijke strategie. Hiervoor is een specifieke wachtwoordzin vereist die moet worden gebruikt voor inschrijving en verificatie. Zie het referentiemateriaal voor een lijst met ondersteunde wachtwoordzinnen.

De functie TextDependentVerification

Begin met het maken van de TextDependentVerification functie:

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. Er zijn drie typenVoiceProfile:

• 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;
    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 deze functie registreert u audiosamples in een while lus die het aantal resterende en vereiste samples voor inschrijving bijhoudt. In elke iteratie vraagt EnrollProfileAsync u om de wachtwoordzin in uw microfoon uit te spreken en wordt het voorbeeld toegevoegd aan het spraakprofiel.

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 uit te spreken. Deze keer wordt deze gevalideerd op basis van uw spraakprofiel en wordt een vergelijkbaarheidsscore geretourneerd die varieert van 0,0 tot 1,0. Het object SpeakerRecognitionResult retourneert Accept ook of Reject op basis van of de wachtwoordzin overeenkomt.

Tekstonafhankelijke verificatie

In tegenstelling tot tekstafhankelijke verificatie vereist tekstonafhankelijke verificatie niet drie audiosamples, maar wel 20 seconden aan totale audio.

De functie TextIndependentVerification

Begin met het maken van de TextIndependentVerification functie:

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;
    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 deze functie registreert u audiosamples in een while lus die het aantal resterende en vereiste seconden aan audio voor inschrijving bijhoudt. In elke iteratie vraagt EnrollProfileAsync u om in uw microfoon te spreken en wordt het voorbeeld toegevoegd aan het spraakprofiel.

Sprekeridentificatie

Sprekeridentificatie wordt gebruikt om te bepalen wie er spreekt vanuit een bepaalde groep geregistreerde stemmen. Het proces is vergelijkbaar met tekstonafhankelijke verificatie. Het belangrijkste verschil is de mogelijkheid om meerdere spraakprofielen tegelijk te verifiëren in plaats van te verifiëren op basis van één profiel.

De functie TextIndependentIdentification

Begin met het maken van de TextIndependentIdentification functie:

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 al 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 SpeakerIdentify functie 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 het VoiceProfile object door dat u eerder hebt gemaakt. Als u wilt, kunt u meerdere VoiceProfile objecten doorgeven, elk 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 ten slotte de main functie 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";
}

Met deze functie worden de functies aangeroepen die u eerder hebt gedefinieerd. Eerst wordt er 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);

Het VoiceProfileClient object wordt gebruikt om spraakprofielen te maken, in te schrijven en te verwijderen. Het SpeakerRecognizer object 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 audiobestanden moet gebruiken in plaats van 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. U kunt ook gemengde invoer gebruiken door bijvoorbeeld een microfoon te gebruiken voor inschrijving en bestanden voor verificatie.

Referentiedocumentatie | Pakket (Ga) | Aanvullende voorbeelden op GitHub

In deze quickstart leert u basisontwerppatronen voor sprekerherkenning met behulp van de Speech SDK, waaronder:

• Tekstafhankelijke en tekstonafhankelijke verificatie.
• Sprekeridentificatie om een spraakvoorbeeld te identificeren onder een groep stemmen.
• Spraakprofielen verwijderen.

Zie het artikel Overzicht voor een uitgebreid overzicht van de concepten van sprekerherkenning. Zie het knooppunt Verwijzing in het linkerdeelvenster voor een lijst met ondersteunde platforms.

Belangrijk

Microsoft beperkt de toegang tot sprekerherkenning. Pas toe om het te gebruiken via het formulier Beperkte toegangsbeoordeling van Azure AI Speaker Recognition . Na goedkeuring hebt u toegang tot de Speaker Recognition-API's.

Vereisten

• Azure-abonnement: Maak een gratis abonnement aan.
• Maak een spraakresource in de Azure Portal.
• Uw spraakresourcesleutel en -regio. Nadat uw Spraak-resource is geïmplementeerd, selecteert u Ga naar resource om sleutels weer te geven en te beheren. Zie De sleutels voor uw resource ophalen voor meer informatie over azure AI-servicesresources.

De omgeving instellen

Installeer de Speech SDK voor Go. Raadpleeg de SDK-installatiehandleiding voor meer vereisten

Onafhankelijke identificatie uitvoeren

Volg deze stappen om een nieuwe GO-module te maken.

1. Open een opdrachtprompt waar u de nieuwe module wilt en maak een nieuw bestand met de naam independent-identification.go.

2. Vervang de inhoud van independent-identification.go door de volgende code.

   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. Vervang in independent-identification.godoor YourSubscriptionKey uw spraakresourcesleutel en vervang door YourServiceRegion uw spraakresourceregio.

   Belangrijk

   Vergeet niet de sleutel uit uw code te verwijderen wanneer u klaar bent, en plaats deze sleutel nooit in het openbaar. Gebruik voor productie een veilige manier om uw referenties op te slaan en te openen, zoals Azure Key Vault. Zie het artikel Beveiliging van Azure AI-services voor meer informatie.

Voer de volgende opdrachten uit om een go.mod bestand te maken dat is gekoppeld aan onderdelen die worden gehost op GitHub:

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

Bouw nu de code en voer deze uit:

go build
go run independent-identification

Onafhankelijke verificatie uitvoeren

Volg deze stappen om een nieuwe GO-module te maken.

1. Open een opdrachtprompt waar u de nieuwe module wilt en maak een nieuw bestand met de naam independent-verification.go.

2. Vervang de inhoud van independent-verification.go door de volgende code.

   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. Vervang in independent-verification.godoor YourSubscriptionKey uw spraakresourcesleutel en vervang door YourServiceRegion uw spraakresourceregio.

Voer de volgende opdrachten uit om een go.mod bestand te maken dat is gekoppeld aan onderdelen die worden gehost op GitHub:

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

Bouw nu de code en voer deze uit:

go build
go run independent-verification

Resources opschonen

U kunt de Azure Portal of azure-opdrachtregelinterface (CLI) gebruiken om de spraakresource die u hebt gemaakt, te verwijderen.

Referentiedocumentatie | Aanvullende voorbeelden op GitHub

De Speech SDK voor Java biedt ondersteuning voor sprekerherkenning, maar we hebben hier nog geen handleiding opgenomen. Selecteer een andere programmeertaal om aan de slag te gaan en meer te weten te komen over de concepten, of raadpleeg de Java-verwijzing en voorbeelden die aan het begin van dit artikel zijn gekoppeld.

Referentiedocumentatie | Pakket (npm) | Aanvullende voorbeelden op GitHub | Broncode van bibliotheek

In deze quickstart leert u basisontwerppatronen voor sprekerherkenning met behulp van de Speech SDK, waaronder:

• Tekstafhankelijke en tekstonafhankelijke verificatie.
• Sprekeridentificatie om een spraakvoorbeeld te identificeren onder een groep stemmen.
• Spraakprofielen verwijderen.

Zie het artikel Overzicht voor een uitgebreid overzicht van de concepten van sprekerherkenning. Zie het knooppunt Verwijzing in het linkerdeelvenster voor een lijst met ondersteunde platforms.

Belangrijk

Microsoft beperkt de toegang tot sprekerherkenning. Pas toe om het te gebruiken via het formulier Beperkte toegangsbeoordeling van Azure AI Speaker Recognition . Na goedkeuring hebt u toegang tot de Speaker Recognition-API's.

Vereisten

• Azure-abonnement: Maak een gratis abonnement aan.
• Maak een spraakresource in de Azure Portal.
• Uw spraakresourcesleutel en -regio. Nadat uw Spraak-resource is geïmplementeerd, selecteert u Ga naar resource om sleutels weer te geven en te beheren. Zie De sleutels voor uw resource ophalen voor meer informatie over azure AI-servicesresources.

De Speech-SDK installeren

Voordat u begint, moet u de Speech SDK voor JavaScript installeren.

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

script

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

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

Tip

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

import

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

Zie Exporteren en importeren voor meer informatie overimport.

require

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

Afhankelijkheden importeren

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

"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. Ze geven ook paden naar audiobestanden op die u in de volgende taken gaat gebruiken.

Belangrijk

Vergeet niet de sleutel uit uw code te verwijderen wanneer u klaar bent, en plaats deze sleutel nooit in het openbaar. Gebruik voor productie een veilige manier om uw referenties op te slaan en te openen, zoals Azure Key Vault. Zie het artikel Beveiliging van Azure AI-services voor meer informatie.

Een helperfunctie maken

Voeg de volgende helperfunctie toe om audiobestanden in streams te lezen voor gebruik door de Speech-service:

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

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 van deze AudioConfig objecten tijdens de volgende taken.

Tekstafhankelijke verificatie

Sprekercontrole is het bevestigen dat een spreker overeenkomt met een bekende of ingeschreven stem. De eerste stap is het inschrijven van een spraakprofiel, zodat de service iets heeft om toekomstige spraaksamples mee te vergelijken. In dit voorbeeld registreert u het profiel met behulp van een tekstafhankelijke strategie. Hiervoor is een specifieke wachtwoordzin vereist voor inschrijving en 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 {
        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);
        }
    }
}

Met deze functie wordt een object VoiceProfile gemaakt met de methode VoiceProfileClient.createProfileAsync. Er zijn drie typenVoiceProfile:

• 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)
{
    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 deze functie roept u de functie GetAudioConfigFromFile aan die u eerder hebt gedefinieerd, om AudioConfig-objecten te maken uit audiobestanden. Deze audiosamples bevatten een wachtwoordzin, zoals 'Mijn stem is mijn paspoort, verifieer mij'. Vervolgens registreert u deze audiovoorbeelden met behulp van de methode VoiceProfileClient.enrollProfileAsync .

De functie SpeakerVerify

Definieer SpeakerVerify als volgt:

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 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 SpeakerRecognitionResult-object , waarvan de score eigenschap een gelijkenisscore bevat die varieert van 0,0 tot 1,0. Het object SpeakerRecognitionResult bevat ook een eigenschap reason van het type ResultReason. Als de verificatie is geslaagd, moet de reason eigenschap de waarde RecognizedSpeakerhebben.

Tekstonafhankelijke verificatie

In tegenstelling tot tekstafhankelijke verificatie, geldt voor tekstonafhankelijke verificatie:

• Hiervoor is geen bepaalde wachtwoordzin vereist. Alles kan gesproken worden.
• Hiervoor zijn geen drie audiosamples vereist, maar wel 20 seconden aan totale 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 {
        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);
        }
    }
}

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

Sprekeridentificatie

Sprekeridentificatie wordt gebruikt om te bepalen wie er spreekt vanuit een bepaalde groep geregistreerde stemmen. Het proces is vergelijkbaar met tekstonafhankelijke verificatie. Het belangrijkste verschil is de mogelijkheid om te verifiëren op basis van meerdere spraakprofielen tegelijk in plaats van te verifiëren op basis van éé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 {
        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);
        }
    }
}

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 SpeakerIdentify functie als volgt:

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 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 retourneert een SpeakerRecognitionResult-object , waarvan profileId de eigenschap de overeenkomende VoiceProfile, indien aanwezig, identificeert, terwijl de score eigenschap een gelijkenisscore bevat die varieert van 0,0 tot 1,0.

Hoofdfunctie

Definieer ten slotte de main functie 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.

Referentiedocumentatie | Pakket (downloaden) | Aanvullende voorbeelden op GitHub

De Speech SDK voor Objective-C biedt geen ondersteuning voor sprekerherkenning. Selecteer een andere programmeertaal of de Objective-C-verwijzing en voorbeelden die zijn gekoppeld aan het begin van dit artikel.

Referentiedocumentatie | Pakket (downloaden) | Aanvullende voorbeelden op GitHub

De Speech SDK voor Swift biedt geen ondersteuning voor sprekerherkenning. Selecteer een andere programmeertaal of de Swift-verwijzing en voorbeelden die zijn gekoppeld aan het begin van dit artikel.

Referentiedocumentatie | Pakket (PyPi) | Aanvullende voorbeelden op GitHub

De Speech SDK voor Python biedt geen ondersteuning voor sprekerherkenning. Selecteer een andere programmeertaal of de Python-verwijzing en voorbeelden die zijn gekoppeld aan het begin van dit artikel.

Naslaginformatie | over de REST API voor spraak-naar-tekstSpraak-naar-tekst-REST API voor korte audioverwijzing | Aanvullende voorbeelden op GitHub

In deze quickstart leert u basisontwerppatronen voor sprekerherkenning met behulp van de Speech SDK, waaronder:

• Tekstafhankelijke en tekstonafhankelijke verificatie.
• Sprekeridentificatie om een spraakvoorbeeld te identificeren onder een groep stemmen.
• Spraakprofielen verwijderen.

Zie het artikel Overzicht voor een uitgebreid overzicht van de concepten van sprekerherkenning. Zie het knooppunt Verwijzing in het linkerdeelvenster voor een lijst met ondersteunde platforms.

Belangrijk

Microsoft beperkt de toegang tot sprekerherkenning. Pas toe om het te gebruiken via het formulier Beperkte toegangsbeoordeling van Azure AI Speaker Recognition . Na goedkeuring hebt u toegang tot de Speaker Recognition-API's.

Vereisten

• Azure-abonnement: Maak een gratis abonnement aan.
• Maak een spraakresource in de Azure Portal.
• Uw spraakresourcesleutel en -regio. Nadat uw Spraak-resource is geïmplementeerd, selecteert u Ga naar resource om sleutels weer te geven en te beheren. Zie De sleutels voor uw resource ophalen voor meer informatie over azure AI-servicesresources.

Tekstafhankelijke verificatie

Sprekercontrole is het bevestigen dat een spreker overeenkomt met een bekende of ingeschreven stem. De eerste stap is het inschrijven van een spraakprofiel, zodat de service iets heeft om toekomstige spraaksamples mee te vergelijken. In dit voorbeeld registreert u het profiel met behulp van een tekstafhankelijke strategie. Hiervoor is een specifieke wachtwoordzin vereist voor inschrijving en verificatie. Zie het referentiemateriaal voor een lijst met ondersteunde wachtwoordzinnen.

Eerst moet u een spraakprofiel maken. U moet de abonnementssleutel en regio van uw Speech-service invoegen in elk van de curl-opdrachten in dit artikel.

Belangrijk

Vergeet niet de sleutel uit uw code te verwijderen wanneer u klaar bent, en plaats deze sleutel nooit in het openbaar. Gebruik voor productie een veilige manier om uw referenties op te slaan en te openen, zoals Azure Key Vault. Zie het artikel Beveiliging van Azure AI-services voor meer informatie.

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

Er zijn drie typen spraakprofielen:

• Tekstafhankelijke verificatie
• Tekstonafhankelijke verificatie
• Tekstonafhankelijke identificatie

In dit geval maakt u een spraakprofiel van het type tekstafhankelijke verificatie. Als het goed is, ontvangt u 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 --data-binary parameterwaarde een audiobestand op uw computer op dat een van de ondersteunde wachtwoordzinnen bevat, zoals 'Mijn stem is mijn paspoort, verifieer mij'. U kunt een audiobestand opnemen met een app zoals Windows Voicerecorder. U kunt deze ook genereren met behulp van tekst-naar-spraak.

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'

Als het goed is, ontvangt u 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.

Nadat u in totaal drie audiosamples hebt ingeschreven, 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
}

U bent nu klaar om een audiovoorbeeld te controleren op basis van 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-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'

Als het goed is, ontvangt u het volgende antwoord:

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

Accept betekent dat de wachtwoordzin overeenkomt en de verificatie is geslaagd. Het antwoord bevat ook een gelijkenisscore die varieert van 0,0 tot 1,0.

Tot slot verwijdert u het spraakprofiel.

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'

Er is geen reactie.

Tekstonafhankelijke verificatie

In tegenstelling tot tekstafhankelijke verificatie, geldt voor tekstonafhankelijke verificatie:

• Hiervoor is geen bepaalde wachtwoordzin vereist. Alles kan gesproken worden.
• Hiervoor zijn geen drie audiosamples vereist, maar wel 20 seconden aan totale audio.

Eerst maakt u een profiel voor tekstonafhankelijke verificatie.

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

Als het goed is, ontvangt u het volgende antwoord:

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

Vervolgens registreert u het spraakprofiel. Nogmaals, in plaats van drie audiosamples in te dienen, moet u audiosamples indienen die in totaal 20 seconden aan audio bevatten.

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'

Nadat u voldoende audiosamples hebt verzonden, 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
}

U bent nu klaar om een audiovoorbeeld te controleren op basis van het spraakprofiel. Ook dit audiovoorbeeld hoeft geen wachtwoordzin te bevatten. Het kan elke spraak bevatten, maar het moet in totaal ten minste vier seconden aan audio bevatten.

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'

Als het goed is, ontvangt u het volgende antwoord:

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

Accept betekent dat de verificatie is geslaagd. Het antwoord bevat ook een gelijkenisscore die varieert van 0,0 tot 1,0.

Tot slot verwijdert u het spraakprofiel.

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'

Er is geen reactie.

Sprekeridentificatie

Sprekeridentificatie wordt gebruikt om te bepalen wie er spreekt vanuit een bepaalde groep geregistreerde stemmen. Het proces is vergelijkbaar met tekstonafhankelijke verificatie. Het belangrijkste verschil is de mogelijkheid om te verifiëren op basis van meerdere spraakprofielen tegelijk in plaats van te verifiëren op basis van één profiel.

Eerst maakt u een profiel voor tekstonafhankelijke identificatie.

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

Als het goed is, ontvangt u het volgende antwoord:

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

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

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'

Nadat u voldoende audiosamples hebt verzonden, 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
}

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

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

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

Er is geen reactie.

De Speech CLI ondersteunt sprekerherkenning, maar we hebben hier nog geen handleiding opgenomen. Selecteer een andere programmeertaal om aan de slag te gaan en meer te weten te komen over de concepten.

Volgende stappen

Bekijk de quickstart-voorbeelden op GitHub