Začínáme s rozpoznáváním mluvčího

Článek
11/24/2021
28 min ke čtení

V tomto rychlém startu se seznámíte se základními vzory návrhu pro rozpoznávání mluvčího s využitím sady Speech SDK, včetně:

Ověření závislé na textu a nezávislé na textu
Identifikace mluvčího pro identifikaci ukázky hlasu mezi skupinou hlasů
Odstranění hlasových profilů

Základní informace o konceptech rozpoznávání mluvčího najdete v článku s přehledem. Seznam podporovaných platforem najdete v části Referenční uzel v levém navigačním panelu.

Požadavky

Tento článek předpokládá, že máte účet Azure a předplatné služby Speech. Pokud nemáte účet a předplatné, vyzkoušejte si službu Speech zdarma.

Důležité

Microsoft omezuje přístup k rozpoznávání mluvčího. Použijte pro jeho použití prostřednictvím Azure Cognitive Services rozpoznávání mluvčího omezená kontrola přístupu. Po schválení budete mít přístup k rozpoznávání mluvčího API.

Instalace sady Speech SDK

Než budete moci cokoli udělat, budete si muset nainstalovat sadu Speech SDK. V závislosti na vaší platformě postupujte podle následujících pokynů:

Import závislostí

Příklady v tomto článku spustíte tak, že na začátek skriptu zahrníte using následující příkazy.

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

Vytvoření konfigurace řeči

Pokud chcete volat službu Speech pomocí sady Speech SDK, musíte vytvořit SpeechConfig . V tomto příkladu vytvoříte pomocí SpeechConfig klíče předplatného a oblasti. Vytvoříte také základní často používaný kód pro zbytek tohoto článku, který upravíte pro různá přizpůsobení.

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

Ověření závislé na textu

Ověření mluvčího je potvrzení, že mluvčí odpovídá známému nebo zaregistrovanému hlasu. Prvním krokem je registrace hlasového profilu, aby služba získala něco pro porovnání budoucích hlasových ukázek. V tomto příkladu zaregistrujete profil pomocí strategie závislé na textu, která vyžaduje konkrétní přístupovou frázi pro registraci i ověřování. Seznam podporovaných přístupových frází najdete v referenčních dokumentech.

Začněte vytvořením následující funkce ve Program třídě pro registraci hlasového profilu.

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

V této funkci await client.CreateProfileAsync() je to, co ve skutečnosti vytvoří nový hlasový profil. Po vytvoření určíte, jak budete zabírat zvukové ukázky, a v tomto příkladu pomocí příkazu zachytíte zvuk z AudioConfig.FromDefaultMicrophoneInput() výchozího vstupního zařízení. Dále zaregistrujete zvukové ukázky ve smyčce, která sleduje počet zbývajících a požadovaných while vzorků pro registraci. V každé iteraci se zobrazí výzva k vyslovení pass-phrase do mikrofonu a přidání ukázky client.EnrollProfileAsync(profile, audioInput) do hlasového profilu.

Po dokončení registrace zavoláte a await SpeakerVerify(config, profile, profileMapping) ověříte profil, který jste právě vytvořili. Přidejte další funkci pro definování SpeakerVerify .

public static async Task SpeakerVerify(SpeechConfig config, VoiceProfile profile, Dictionary<string, string> profileMapping)
{
    var speakerRecognizer = new SpeakerRecognizer(config, AudioConfig.FromDefaultMicrophoneInput());
    var model = SpeakerVerificationModel.FromProfile(profile);

    Console.WriteLine("Speak the passphrase to verify: \"My voice is my passport, please verify me.\"");
    var result = await speakerRecognizer.RecognizeOnceAsync(model);
    Console.WriteLine($"Verified voice profile for speaker {profileMapping[result.ProfileId]}, score is {result.Score}");
}

V této funkci předáte objekt, VoiceProfile který jste právě vytvořili, za účelem inicializace modelu k ověření. Dále vás vyzve, abyste heslo vyslovil znovu, ale tentokrát ji ověří proti vašemu hlasovému profilu a vrátí skóre podobnosti v rozsahu await speakerRecognizer.RecognizeOnceAsync(model) od 0,0 do 1,0. Objekt také vrátí nebo na základě toho, jestli odpovídá result Accept Reject pass-phrase.

Dále upravte funkci Main() tak, aby volala nové funkce, které jste vytvořili. Všimněte si také, že vytvoříte objekt , Dictionary<string, string> který bude prostřednictvím volání funkce předávat odkazem. Důvodem je to, že služba neumožňuje ukládat lidsky čitelný název s vytvořeným názvem a ukládá pouze identifikační číslo pro VoiceProfile účely ochrany osobních údajů. Ve funkci přidáte do tohoto slovníku položku s nově vytvořeným VerificationEnroll ID a textovým názvem. Ve scénářích vývoje aplikací, kde potřebujete zobrazit lidsky čitelný název, musíte toto mapování někam uložit, protože služba ho nemůže uložit.

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

Spusťte skript a zobrazí se výzva k vyslovení fráze Můj hlas je můj pas, třikrát mě ověřte pro registraci a ještě jednou k ověření. Vrácený výsledek je skóre podobnosti, které můžete použít k vytvoření vlastních prahových hodnot pro ověření.

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

Ověření nezávislé na textu

Na rozdíl od ověření závislého na textu je ověření nezávislé na textu:

Nevyžaduje tři zvukové ukázky, ale vyžaduje celkem 20 sekund zvuku.

Proveďte několik jednoduchých změn VerificationEnroll funkce a přepněte na ověřování nezávislé na textu. Nejprve změníte typ ověřování na VoiceProfileType.TextIndependentVerification . Dále změňte smyčku tak, aby sledovala , která vás bude dál vyzývat k vyslovování, dokud se nezachytá while result.RemainingEnrollmentsSpeechLength 20 sekund zvuku.

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

Spusťte program znovu. Opět se vrátí skóre podobnosti.

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

Identifikace mluvčího

Identifikace mluvčího se používá k určení toho, kdo mluví z dané skupiny zaregistrované hlasy. Tento proces se velmi podobá ověřování nezávislému na textu, hlavní rozdíl spočívá v tom, že je možné ověřovat pomocí více hlasových profilů najednou místo ověřování u jednoho profilu.

Vytvořte funkci pro IdentificationEnroll registraci více hlasových profilů. Proces registrace pro každý profil je stejný jako proces registrace pro ověření nezávislý na textu a vyžaduje 20 sekund zvuku pro každý profil. Tato funkce přijme seznam řetězců a vytvoří nový hlasový profil pro každé profileNames jméno v seznamu. Funkce vrátí seznam objektů, které použijete v další funkci pro VoiceProfile identifikaci mluvčího.

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

Vytvořte následující funkci, SpeakerIdentification která odešle požadavek na identifikaci. Hlavní rozdíl v této funkci v porovnání s žádostí o ověření mluvčího spočívá v použití metody , která přijímá SpeakerIdentificationModel.FromProfiles() seznam VoiceProfile objektů.

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

Změňte Main() funkci na následující. Vytvoříte seznam řetězců profileNames , které předáte IdentificationEnroll() funkci. Zobrazí se výzva k vytvoření nového hlasového profilu pro každé jméno v tomto seznamu, abyste mohli přidat další jména a vytvořit další profily pro přátele nebo kolegy.

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

Spusťte skript a zobrazí se výzva k registraci hlasových ukázek pro první profil. Po dokončení registrace budete vyzváni k opakování tohoto procesu pro každý název v seznamu profileNames . Po dokončení každé registrace se zobrazí výzva, abyste mohli mluvit s kýmkoli, a služba se pokusí identifikovat tuto osobu z vašich zaregistrovaných hlasových profilů.

Tento příklad vrátí pouze nejbližší shodu a je to skóre podobnosti, ale přidáním do funkce můžete získat úplnou odpověď, která obsahuje pět nejlepších skóre string json = result.Properties.GetProperty(PropertyId.SpeechServiceResponse_JsonResult) SpeakerIdentification podobnosti.

Změna typu zvukového vstupu

V příkladech v tomto článku se jako vstup pro zvukové ukázky používá výchozí mikrofon zařízení. Ve scénářích, kdy potřebujete místo vstupu z mikrofonu použít zvukové soubory, stačí změnit jakoukoli instanci na , aby přepne AudioConfig.FromDefaultMicrophoneInput() AudioConfig.FromWavFileInput(path/to/your/file.wav) na vstup souboru. Můžete mít také smíšené vstupy, například pomocí mikrofonu pro registraci a souborů pro ověření.

Odstranění registrací hlasových profilů

Pokud chcete zaregistrované profil odstranit, použijte DeleteProfileAsync() pro objekt funkci VoiceProfileClient . Následující příklad funkce ukazuje, jak odstranit hlasový profil ze známého ID hlasového profilu.

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

V tomto rychlém startu se seznámíte se základními vzory návrhu pro rozpoznávání mluvčího s využitím sady Speech SDK, včetně:

Ověření závislé na textu a nezávislé na textu
Identifikace mluvčího pro identifikaci ukázky hlasu mezi skupinou hlasů
Odstranění hlasových profilů

Základní informace o konceptech rozpoznávání mluvčího najdete v článku s přehledem. Seznam podporovaných platforem najdete v části Referenční uzel v levém navigačním panelu.

Pokud chcete přeskočit přímo na ukázkový kód, podívejte se na ukázky rychlého startu pro C++ na GitHub.

Požadavky

Tento článek předpokládá, že máte účet Azure a předplatné služby Speech. Pokud nemáte účet a předplatné, vyzkoušejte si službu Speech zdarma.

Důležité

Instalace sady Speech SDK

Než budete moci cokoli udělat, budete si muset nainstalovat sadu Speech SDK. V závislosti na vaší platformě postupujte podle následujících pokynů:

Import závislostí

Pokud chcete spustit příklady v tomto článku, přidejte na začátek souboru .cpp následující příkazy.

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

Vytvoření konfigurace řeči

Pokud chcete volat službu Speech pomocí sady Speech SDK, musíte vytvořit SpeechConfig . Tato třída obsahuje informace o vašem předplatném, jako je klíč a přidružená oblast, koncový bod, hostitel nebo autorizační token.

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

Ověření závislé na textu

Ověření mluvčího je potvrzení, že mluvčí odpovídá známému nebo zaregistrovanému hlasu. Prvním krokem je registrace hlasového profilu, aby služba získala něco pro porovnání budoucích hlasových ukázek. V tomto příkladu profil zaregistrujete pomocí strategie závislé na textu, která vyžaduje konkrétní přístupové heslo pro registraci i ověřování. Seznam podporovaných přístupových frází najdete v referenčních dokumentech.

Funkce TextDependentVerification

Začněte vytvořením TextDependentVerification funkce .

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

Tato funkce vytvoří objekt VoiceProfile pomocí metody CreateProfileAsync. Všimněte si, že existují tři VoiceProfile typy:

Vlastnost TextIndependentIdentification
Vlastnost TextDependentVerification
Vlastnost TextIndependentVerification

V tomto případě předáte VoiceProfileType::TextDependentVerification do CreateProfileAsync .

Potom zavoláte dvě pomocné funkce, které definujete jako další, a AddEnrollmentsToTextDependentProfile SpeakerVerify . Nakonec profil vyčistěte voláním metody DeleteProfileAsync.

Funkce AddEnrollmentsToTextDependentProfile

Definujte následující funkci pro registraci hlasového profilu.

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

V této funkci zaregistrujete zvukové ukázky ve smyčce, která sleduje počet zbývajících a požadovaných while vzorků pro registraci. V každé iteraci vás EnrollProfileAsync vyzve k vyslovení hesla do mikrofonu a přidá ukázku do hlasového profilu.

Funkce SpeakerVerify

SpeakerVerifyDefinujte následujícím způsobem.

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

V této funkci vytvoříte objekt SpeakerVerificationModel pomocí metody SpeakerVerificationModel::FromProfile a předáte objekt VoiceProfile, který jste vytvořili dříve.

Dále vás SpeechRecognizer::RecognizeOnceAsync vyzve k tomu, abyste heslo znovu vyslovili, ale tentokrát se ověří vůči vašemu hlasovému profilu a vrátí skóre podobnosti v rozsahu 0.0 až 1.0. Objekt SpeakerRecognitionResult také vrátí nebo , podle toho, jestli heslo Accept Reject odpovídá.

Ověření nezávislé na textu

Na rozdíl od ověření závislého na textu nevyžaduje ověření nezávislé na textu tři zvukové ukázky, ale vyžaduje celkem 20 sekund zvuku.

Funkce TextIndependentVerification

Začněte vytvořením TextIndependentVerification funkce .

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

Podobně jako TextDependentVerification funkce i tato funkce vytvoří objekt VoiceProfile pomocí metody CreateProfileAsync.

V tomto případě předáte VoiceProfileType::TextIndependentVerification do CreateProfileAsync .

Potom zavoláte dvě pomocné funkce: AddEnrollmentsToTextIndependentProfile , které definujete jako další, a , které jste už SpeakerVerify definovali. Nakonec profil vyčistěte voláním metody DeleteProfileAsync.

AddEnrollmentsToTextIndependentProfile

Definujte následující funkci pro registraci hlasového profilu.

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

V této funkci zaregistrujete zvukové ukázky ve smyčce, která sleduje zbývající počet sekund zbývajícího zvuku a vyžaduje se while pro registraci. V každé iteraci vás EnrollProfileAsync vyzve, abyste mluví do mikrofonu, a přidá ukázku do hlasového profilu.

Identifikace mluvčího

Funkce TextIndependentIdentification

Začněte vytvořením TextIndependentIdentification funkce .

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

Podobně jako TextDependentVerification funkce a tato funkce vytvoří objekt TextIndependentVerification VoiceProfile pomocí metody CreateProfileAsync.

V tomto případě předáte VoiceProfileType::TextIndependentIdentification do CreateProfileAsync .

Potom zavoláte dvě pomocné funkce: , které jste už definovali, a , které AddEnrollmentsToTextIndependentProfile SpeakerIdentify definujete jako další. Nakonec profil vyčistěte voláním metody DeleteProfileAsync.

Funkce SpeakerIdentify

SpeakerIdentifyDefinujte funkci následujícím způsobem.

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

V této funkci vytvoříte objekt SpeakerIdentificationModel pomocí metody SpeakerIdentificationModel::FromProfiles. SpeakerIdentificationModel::FromProfilespřijímá seznam objektů VoiceProfile. V tomto případě jednoduše předáte VoiceProfile objekt, který jste vytvořili dříve. Pokud ale chcete, můžete předat více objektů, z nichž každý je zaregistrovaný pomocí zvukových VoiceProfile ukázek z jiného hlasu.

Dále vás SpeechRecognizer::RecognizeOnceAsync vyzve, abyste znovu mluvili. Tentokrát porovná váš hlas s zaregistrovaným hlasovým profilem a vrátí nej podobnější hlasový profil.

Main – funkce

Nakonec main definujte funkci následujícím způsobem.

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

Tato funkce jednoduše volá funkce, které jste definovali dříve. Nejprve ale vytvoří objekt VoiceProfileClient a objekt SpeakerRecognizer.

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

Slouží VoiceProfileClient k vytváření, registraci a odstraňování hlasových profilů. Slouží SpeakerRecognizer k ověření ukázek řeči proti jednomu nebo více zaregistrovaým hlasovým profilům.

Změna typu zvukového vstupu

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

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

Nebo nahraďte použití audio_config parametrem textem Audio::AudioConfig::FromWavFileInput. Můžete mít také smíšené vstupy, například pomocí mikrofonu pro registraci a souborů pro ověření.

V tomto rychlém startu se naučíte základní vzory návrhu pro rozpoznávání mluvčího pomocí sady Speech SDK, včetně těchto:

Ověřování závislé na textu a nezávislé na textu
Identifikace mluvčího pro identifikaci hlasového vzorku mezi skupinou hlasů
Odstraňování hlasových profilů

Nejdůležitější informace o rozpoznávání mluvčího konceptech najdete v článku Přehled . Seznam podporovaných platforem najdete v uzlu reference na levém navigačním panelu.

Pokud chcete přeskočit přímý na vzorový kód, přečtěte si ukázky rychlý Start JavaScriptu na GitHub.

Požadavky

V tomto článku se předpokládá, že máte účet Azure a předplatné služby Speech. Pokud účet a předplatné nemáte, Vyzkoušejte službu Speech Service zdarma.

Důležité

Rozpoznávání mluvčího se aktuálně podporuje jenom v prostředcích Azure pro rozpoznávání řeči vytvořených v westus oblasti.

Instalace sady Speech SDK

Předtím, než můžete cokoli udělat, musíte nainstalovat sadu Speech SDK pro JavaScript . V závislosti na vaší platformě postupujte podle následujících pokynů:

V závislosti na cílovém prostředí navíc použijte jednu z následujících možností:

Stáhněte a extrahujte sadu Speech SDK pro JavaScript microsoft.cognitiveservices.speech.sdk.bundle.js soubor a umístěte ji do složky přístupné pro váš soubor HTML.

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

Tip

Pokud cílíte na webový prohlížeč a použijete <script> značku; sdk Předpona není nutná. sdkPředpona je alias použitý k pojmenování require modulu.

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

Další informace o najdete v import tématu Export a import .

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

Další informace o najdete v require tématu co je potřeba? .

Importovat závislosti

Chcete-li spustit příklady v tomto článku, přidejte následující příkazy v horní části souboru .js.

"use strict";

/* To run this sample, install:
npm install microsoft-cognitiveservices-speech-sdk
*/
var sdk = require("microsoft-cognitiveservices-speech-sdk");
var fs = require("fs");

// Note: Change the locale if desired.
const profile_locale = "en-us";

/* Note: passphrase_files and verify_file should contain paths to audio files that contain \"My voice is my passport, verify me.\"
You can obtain these files from:
https://github.com/Azure-Samples/cognitive-services-speech-sdk/tree/fa6428a0837779cbeae172688e0286625e340942/quickstart/javascript/node/speaker-recognition/verification
*/ 
const passphrase_files = ["myVoiceIsMyPassportVerifyMe01.wav", "myVoiceIsMyPassportVerifyMe02.wav", "myVoiceIsMyPassportVerifyMe03.wav"];
const verify_file = "myVoiceIsMyPassportVerifyMe04.wav";
/* Note: identify_file should contain a path to an audio file that uses the same voice as the other files, but contains different speech. You can obtain this file from:
https://github.com/Azure-Samples/cognitive-services-speech-sdk/tree/fa6428a0837779cbeae172688e0286625e340942/quickstart/javascript/node/speaker-recognition/identification
*/
const identify_file = "aboutSpeechSdk.wav";

var subscription_key = 'PASTE_YOUR_SPEECH_SUBSCRIPTION_KEY_HERE';
var region = 'PASTE_YOUR_SPEECH_ENDPOINT_REGION_HERE';

const ticks_per_second = 10000000;

Tyto příkazy importují požadované knihovny a k získání klíče a oblasti předplatného služby Speech z proměnných prostředí. Také určují cesty ke zvukovým souborům, které budete používat v následujících úlohách.

Vytvořit pomocnou funkci

Přidejte následující funkci pomocníka pro čtení zvukových souborů do datových proudů pro použití službou Speech.

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

V této funkci použijete metody AudioInputStream. createPushStream a AudioConfig. fromStreamInput k vytvoření objektu AudioConfig . Tento AudioConfig objekt představuje zvukový datový proud. AudioConfigV následujících úlohách použijete několik těchto objektů.

Ověřování závislé na textu

Ověření mluvčího je potvrzení, že mluvčí odpovídá známému nebo zaregistrovanému hlasu. Prvním krokem je zápis hlasového profilu, aby služba měla něco pro porovnání budoucích ukázek hlasu s. V tomto příkladu zaregistrujete profil s použitím strategie závislé na textu , která vyžaduje konkrétní přístupové heslo, které se má použít pro zápis i ověřování. Seznam podporovaných přístupových hesel najdete v referenční dokumentaci .

TextDependentVerification – funkce

Začněte vytvořením TextDependentVerification funkce.

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

Tato funkce vytvoří objekt VoiceProfile s metodou VoiceProfileClient. createProfileAsync . Všimněte si, že existují tři typy VoiceProfile :

TextIndependentIdentification
TextDependentVerification
TextIndependentVerification

V tomto případě předáte VoiceProfileType.TextDependentVerification VoiceProfileClient.createProfileAsync .

Pak zavoláte dvě pomocné funkce, které definujete jako další, AddEnrollmentsToTextDependentProfile a SpeakerVerify . Nakonec zavolejte VoiceProfileClient. deleteProfileAsync a odstraňte profil.

AddEnrollmentsToTextDependentProfile – funkce

Zadejte následující funkci pro zápis hlasového profilu.

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

V této funkci zavoláte GetAudioConfigFromFile funkci, kterou jste definovali dříve, a vytvoříte AudioConfig objekty ze vzorků zvuku. Tyto zvukové vzorky obsahují přístupové heslo, například "můj hlas je můj účet Passport, ověřit mě." Tyto ukázky zvuku pak zaregistrujete pomocí metody VoiceProfileClient. enrollProfileAsync .

SpeakerVerify – funkce

Definujte SpeakerVerify následujícím způsobem.

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

V této funkci vytvoříte objekt SpeakerVerificationModel s metodou SpeakerVerificationModel. FromProfile předáním objektu VoiceProfile , který jste vytvořili dříve.

Dále zavoláte metodu SpeechRecognizer. recognizeOnceAsync , která ověří ukázku zvuku, která obsahuje stejné heslo jako ukázky zvuku, které jste předtím zaregistrovali. SpeechRecognizer.recognizeOnceAsync Vrátí objekt SpeakerRecognitionResult , jehož score vlastnost obsahuje skóre podobnosti v rozsahu od 0,0 do 1,0. SpeakerRecognitionResultObjekt obsahuje také reason vlastnost typu ResultReason. Pokud bylo ověření úspěšné, reason vlastnost by měla mít hodnotu RecognizedSpeaker .

Ověřování nezávislé na textu

Na rozdíl od ověřování závislého na textu, ověřování nezávislého na textu :

Nevyžaduje, aby bylo možné některé heslo vymluveným, cokoli se dá přehlasovat.
Nevyžaduje tři zvukové vzorky , ale vyžaduje 20 sekund celkového zvuku.

TextIndependentVerification – funkce

Začněte vytvořením TextIndependentVerification funkce.

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

Podobně jako TextDependentVerification funkce Tato funkce vytvoří objekt VoiceProfile s metodou VoiceProfileClient. createProfileAsync .

V tomto případě předáte VoiceProfileType.TextIndependentVerification createProfileAsync .

Potom zavolejte dvě pomocné funkce: AddEnrollmentsToTextIndependentProfile , které definujete další, a SpeakerVerify , které jste již definovali. Nakonec zavolejte VoiceProfileClient. deleteProfileAsync a odstraňte profil.

AddEnrollmentsToTextIndependentProfile

Zadejte následující funkci pro zápis hlasového profilu.

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

V této funkci zavoláte GetAudioConfigFromFile funkci, kterou jste definovali dříve, a vytvoříte AudioConfig objekty ze vzorků zvuku. Tyto ukázky zvuku pak zaregistrujete pomocí metody VoiceProfileClient. enrollProfileAsync .

Identifikace mluvčího

Identifikace mluvčího slouží k určení toho , kdo z dané skupiny zaregistrovaných hlasů mluví. Tento proces se podobá ověřování nezávisle na textu, s hlavním rozdílem, který je schopný ověřit u několika hlasových profilů najednou, a ne u jednoho profilu.

TextIndependentIdentification – funkce

Začněte vytvořením TextIndependentIdentification funkce.

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

Podobně jako TextDependentVerification TextIndependentVerification funkce a vytvoří tato funkce objekt VoiceProfile s metodou VoiceProfileClient. createProfileAsync .

V tomto případě předáte VoiceProfileType.TextIndependentIdentification VoiceProfileClient.createProfileAsync .

Potom zavolejte dvě pomocné funkce: AddEnrollmentsToTextIndependentProfile , které jste již definovali a SpeakerIdentify které definujete další. Nakonec zavolejte VoiceProfileClient. deleteProfileAsync a odstraňte profil.

SpeakerIdentify – funkce

Definujte SpeakerIdentify funkci následujícím způsobem.

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

V této funkci vytvoříte objekt SpeakerIdentificationModel s metodou SpeakerIdentificationModel. fromProfiles předáním objektu VoiceProfile , který jste vytvořili dříve.

Dále zavoláte metodu SpeechRecognizer. recognizeOnceAsync a předáte ukázku zvuku. SpeechRecognizer.recognizeOnceAsync pokusí se identifikovat hlas pro tuto ukázku zvuku na základě VoiceProfile objektů, které jste použili k vytvoření SpeakerIdentificationModel . Vrátí objekt SpeakerRecognitionResult , jehož profileId vlastnost identifikuje odpovídající VoiceProfile , pokud existuje, zatímco score vlastnost obsahuje skóre podobnosti v rozsahu od 0,0 do 1,0.

Main – funkce

Nakonec definujte funkci následujícím main způsobem.

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

Tato funkce vytvoří objekt VoiceProfileClient , který se používá k vytváření, registraci a odstraňování hlasových profilů. Potom volá dříve definované funkce.

V tomto rychlém startu se naučíte základní vzory návrhu pro rozpoznávání mluvčího pomocí sady Speech SDK, včetně těchto:

Ověřování závislé na textu a nezávislé na textu
Identifikace mluvčího pro identifikaci hlasového vzorku mezi skupinou hlasů
Odstraňování hlasových profilů

Nejdůležitější informace o rozpoznávání mluvčího konceptech najdete v článku Přehled . Seznam podporovaných platforem najdete v uzlu reference na levém navigačním panelu.

Požadavky

V tomto článku se předpokládá, že máte účet Azure a předplatné služby Speech. Pokud účet a předplatné nemáte, Vyzkoušejte službu Speech Service zdarma.

Důležité

Rozpoznávání mluvčího se aktuálně podporuje jenom v prostředcích Azure pro rozpoznávání řeči vytvořených v westus oblasti.

Ověřování závislé na textu

Začněte vytvořením hlasového profilu. Do každého z příkazů v tomto článku budete muset vložit klíč a oblast předplatného služby Speech.

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

Všimněte si, že existují tři typy hlasového profilu:

Ověřování závislé na textu
Ověřování nezávislé na textu
Identifikace nezávislá na textu

V tomto případě vytvoříte profilový hlasový profil závislý na textu. Měla by se zobrazit následující odpověď.

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

V dalším kroku zaregistrujete hlasový profil. V poli --data-binary hodnota parametru zadejte zvukový soubor v počítači, který obsahuje jedno z podporovaných přístupových hesel, například "můj hlas je můj pas, ověřit mě." takový zvukový soubor můžete nahrát pomocí aplikace, jako je Windows Hlasový záznam, nebo ho můžete vygenerovat pomocí převodu textu na řeč.

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'

Měla by se zobrazit následující odpověď.

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

Tato odpověď vám ukáže, že je potřeba zaregistrovat ještě dvě zvukové ukázky.

Po registraci celkem tří ukázek zvuku by se měla zobrazit následující odpověď.

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

Nyní jste připraveni ověřit ukázku zvuku proti profilu hlasu. Tento zvukový vzorek by měl obsahovat stejné přístupové heslo jako ukázky, které jste použili k zápisu hlasového profilu.

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'

Měla by se zobrazit následující odpověď.

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

AcceptTo znamená, že heslo odpovídá a ověření bylo úspěšné. Odpověď obsahuje také skóre podobnosti v rozsahu od 0,0 do 1,0.

Chcete-li dokončit, odstraňte hlasový profil.

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'

Neexistuje žádná odpověď.

Ověřování nezávislé na textu

Na rozdíl od ověřování závislého na textu, ověřování nezávislého na textu :

Nevyžaduje, aby bylo možné některé heslo vymluveným, cokoli se dá přehlasovat.
Nevyžaduje tři zvukové vzorky , ale vyžaduje 20 sekund celkového zvuku.

Začněte vytvořením nezávislého textového profilu pro ověřování.

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

Měla by se zobrazit následující odpověď.

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

Pak Zaregistrujte hlasový profil. Místo toho, abyste odeslali tři zvukové vzorky, potřebujete odeslat zvukové vzorky, které obsahují celkem 20 sekund zvukového zvuku.

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'

Po odeslání dostatečného počtu zvukových ukázek by se měla zobrazit následující odpověď.

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

Nyní jste připraveni ověřit ukázku zvuku proti profilu hlasu. Tato ukázka zvuku zase nemusí obsahovat přístupové heslo. Může obsahovat jakýkoli řeč, pokud obsahuje celkem alespoň čtyři sekundy zvukového zařízení.

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'

Měla by se zobrazit následující odpověď.

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

AcceptTo znamená, že ověření bylo úspěšné. Odpověď obsahuje také skóre podobnosti v rozsahu od 0,0 do 1,0.

Chcete-li dokončit, odstraňte hlasový profil.

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'

Neexistuje žádná odpověď.

Identifikace mluvčího

Začněte vytvořením nezávislého textu pro identifikaci.

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

Měla by se zobrazit následující odpověď.

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

V dalším kroku zaregistrujete hlasový profil. Znovu je potřeba odeslat zvukové vzorky, které obsahují celkem 20 sekund zvukového zvuku. Tyto ukázky nemusejí obsahovat přístupové heslo.

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'

Po odeslání dostatečného počtu zvukových ukázek by se měla zobrazit následující odpověď.

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

Nyní jste připraveni identifikovat zvukový vzorek pomocí hlasového profilu. Příkaz identifikovat přijímá seznam možných ID hlasových profilů oddělený čárkami. V takovém případě pouze předáte ID hlasového profilu, který jste vytvořili dříve. Pokud ale chcete, můžete předat víc ID hlasových profilů, kde každý hlasový profil je zaregistrovaný pomocí zvukového vzorku z jiného hlasu.

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'

Měla by se zobrazit následující odpověď.

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

Odpověď obsahuje ID hlasového profilu, který nejlépe odpovídá vzorku zvuk, který jste odeslali. Obsahuje také seznam kandidátních hlasových profilů seřazený podle podobnosti.

Chcete-li dokončit, odstraňte hlasový profil.

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'

Neexistuje žádná odpověď.

Další kroky

Podrobnosti o rozpoznávání mluvčího a funkcích najdete v referenční dokumentaci k referenčním informacím.
Viz ukázky C# a C++ na GitHub.

Začínáme s rozpoznáváním mluvčího

Ohodnoťte vaše zkušenosti

Požadavky

Instalace sady Speech SDK

Import závislostí

Vytvoření konfigurace řeči

Ověření závislé na textu

Ověření nezávislé na textu

Identifikace mluvčího

Změna typu zvukového vstupu

Odstranění registrací hlasových profilů

Přeskočit na ukázky na GitHub

Požadavky

Instalace sady Speech SDK

Import závislostí

Vytvoření konfigurace řeči

Ověření závislé na textu

Funkce TextDependentVerification

Funkce AddEnrollmentsToTextDependentProfile

Funkce SpeakerVerify

Ověření nezávislé na textu

Funkce TextIndependentVerification

AddEnrollmentsToTextIndependentProfile

Identifikace mluvčího

Funkce TextIndependentIdentification

Funkce SpeakerIdentify

Main – funkce

Změna typu zvukového vstupu

Přeskočit na ukázky v GitHub

Požadavky

Instalace sady Speech SDK

Importovat závislosti

Vytvořit pomocnou funkci

Ověřování závislé na textu

TextDependentVerification – funkce

AddEnrollmentsToTextDependentProfile – funkce

SpeakerVerify – funkce

Ověřování nezávislé na textu

TextIndependentVerification – funkce

AddEnrollmentsToTextIndependentProfile

Identifikace mluvčího

TextIndependentIdentification – funkce

SpeakerIdentify – funkce

Main – funkce

Požadavky

Ověřování závislé na textu

Ověřování nezávislé na textu

Identifikace mluvčího

Další kroky