Rychlý start: Rozpoznávání a ověření mluvení

  • Článek

Referenční dokumentace | Balíček (NuGet) | Další ukázky na GitHubu

V tomto rychlém startu se seznámíte se základními vzory návrhu pro rozpoznávání mluvčího pomocí sady Speech SDK, mezi které patří:

  • Ověření závislé na textu a nezávislé na textu.
  • Identifikace mluvčího k identifikaci vzorku hlasu mezi skupinou hlasů.
  • Odstraňují se hlasové profily.

Základní pohled na koncepty rozpoznávání mluvčího najdete v článku Přehled . Seznam podporovaných platforem najdete v uzlu Reference v levém podokně.

Důležité

Microsoft omezuje přístup k rozpoznávání mluvčího. Použijte ho, pokud ho chcete použít prostřednictvím formuláře pro kontrolu omezeného přístupu rozpoznávání mluvčího Azure AI . Po schválení budete mít přístup k rozhraním API pro rozpoznávání mluvčího.

Požadavky

Instalace sady Speech SDK

Než začnete, musíte 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, zahrňte do horní části skriptu následující using 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 instanci. V tomto příkladu SpeechConfig vytvoříte instanci pomocí 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í.

Důležité

Až budete hotovi, nezapomeňte klíč z kódu odebrat a nikdy ho nezveřejníte. V produkčním prostředí použijte zabezpečený způsob ukládání a přístupu k přihlašovacím údajům, jako je Azure 密钥保管库. Další informace najdete v článku Zabezpečení služeb Azure AI.

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 byla s čím porovnávat budoucí ukázky hlasových služeb. V tomto příkladu profil zaregistrujete pomocí strategie závislé na textu , která vyžaduje konkrétní přístupové heslo, které se má použít pro registraci a ověření. Seznam podporovaných přístupových hesel najdete v referenční dokumentaci .

Začněte vytvořením následující funkce ve třídě Program 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"))
    {
        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() se ve skutečnosti vytvoří nový hlasový profil. Po jeho vytvoření určíte, jak budete zadávat zvukové ukázky. AudioConfig.FromDefaultMicrophoneInput() V tomto příkladu použijete k zachycení zvuku z výchozího vstupního zařízení. Dále zaregistrujete zvukové ukázky ve smyčce while , která sleduje počet zbývajících a požadovaných ukázek pro registraci. V každé iteraci client.EnrollProfileAsync(profile, audioInput) vás nástroj vyzve, abyste vyslovili heslo do mikrofonu, a přidá ukázku do hlasového profilu.

Po dokončení registrace volejte await SpeakerVerify(config, profile, profileMapping) a 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 VoiceProfile objekt, který jste právě vytvořili, abyste inicializovali model pro ověření. await speakerRecognizer.RecognizeOnceAsync(model) Pak vás vyzve, abyste heslo znovu vyslechli. Tentokrát ho ověří ve vašem hlasovém profilu a vrátí skóre podobnosti v rozsahu od 0,0 do 1,0. Objekt result také vrátí Accept nebo Rejectna základě toho, jestli se přístupové heslo shoduje.

Dále upravte Main() funkci tak, aby volala nové funkce, které jste vytvořili. Všimněte si také, že vytvoříte pro Dictionary<string, string> předání odkazu prostřednictvím volání funkce. Důvodem je to, že služba neumožňuje ukládání názvu čitelného pro člověka s vytvořeným VoiceProfileobjektem a pro účely ochrany osobních údajů ukládá jenom identifikační číslo. VerificationEnroll Ve funkci přidáte do tohoto slovníku položku s nově vytvořeným 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. Třikrát se zobrazí výzva, abyste pro registraci vyslechli frázi "Můj hlas je můj pas, ověřit mě" a ještě jednou pro 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 nevyžaduje ověření nezávislé na textu tři zvukové vzorky , ale vyžaduje 20 sekund celkového zvuku.

Provedením několika jednoduchých změn funkce VerificationEnroll přepněte na ověřování nezávislé na textu . Nejprve změníte typ ověření na VoiceProfileType.TextIndependentVerification. Dále změňte smyčku while na track (sledovat result.RemainingEnrollmentsSpeechLength), která bude dál zobrazovat výzvu k mluvení, dokud nebude zachyceno 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"))
    {
        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 a vrátí se 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ých hlasů. Proces je podobný ověřování nezávislému na textu. Hlavním rozdílem je možnost ověření proti více hlasovým profilům najednou, a ne v jednom profilu.

Vytvořte funkci IdentificationEnroll pro registraci více hlasových profilů. Proces registrace pro každý profil je stejný jako proces registrace pro ověření nezávislé na textu. Tento proces vyžaduje 20 sekund zvuku pro každý profil. Tato funkce přijímá seznam řetězců profileNames a vytvoří nový hlasový profil pro každé jméno v seznamu. Funkce vrátí seznam VoiceProfile objektů, který použijete v další funkci k 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))
    {
        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 žádost o identifikaci. Hlavní rozdíl v této funkci oproti žádosti o ověření mluvčíhoSpeakerIdentificationModel.FromProfiles()VoiceProfile spočívá v použití , který přijímá seznam 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 funkci IdentificationEnroll() . 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. Při registraci hlasových ukázek pro první profil se zobrazí výzva, abyste promluvili. Po dokončení registrace se zobrazí výzva k opakování tohoto procesu pro každé jméno v profileNames seznamu. Po dokončení každé registrace se zobrazí výzva, aby někdo promluvil. Služba se pak pokusí identifikovat tuto osobu z vašich zaregistrovaných hlasových profilů.

Tento příklad vrátí pouze nejbližší shodu a její skóre podobnosti. Pokud chcete získat úplnou odpověď, která obsahuje prvních pět skóre podobnosti, přidejte string json = result.Properties.GetProperty(PropertyId.SpeechServiceResponse_JsonResult) do funkce SpeakerIdentification .

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, změňte libovolnou instanci AudioConfig.FromDefaultMicrophoneInput() na a AudioConfig.FromWavFileInput(path/to/your/file.wav) přepněte na vstup souboru. Můžete také použít smíšené vstupy, například pomocí mikrofonu pro registraci a souborů pro ověření.

Odstranění registrací hlasových profilů

Pokud chcete odstranit zaregistrovaný profil, použijte u objektu DeleteProfileAsync()VoiceProfileClient funkci . 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);
    }
}

Referenční dokumentace | Balíček (NuGet) | Další ukázky na GitHubu

V tomto rychlém startu se seznámíte se základními vzory návrhu pro rozpoznávání mluvčího pomocí sady Speech SDK, mezi které patří:

  • Ověření závislé na textu a nezávislé na textu.
  • Identifikace mluvčího k identifikaci vzorku hlasu mezi skupinou hlasů.
  • Odstraňují se hlasové profily.

Základní pohled na koncepty rozpoznávání mluvčího najdete v článku Přehled . Seznam podporovaných platforem najdete v uzlu Reference v levém podokně.

Důležité

Microsoft omezuje přístup k rozpoznávání mluvčího. Použijte ho, pokud ho chcete použít prostřednictvím formuláře pro kontrolu omezeného přístupu rozpoznávání mluvčího Azure AI . Po schválení budete mít přístup k rozhraním API pro rozpoznávání mluvčího.

Požadavky

Instalace sady Speech SDK

Než začnete, musíte 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, vytvořte SpeechConfig třídu. 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.

Důležité

Až budete hotovi, nezapomeňte klíč z kódu odebrat a nikdy ho nezveřejníte. V produkčním prostředí použijte zabezpečený způsob ukládání a přístupu k přihlašovacím údajům, jako je Azure 密钥保管库. Další informace najdete v článku Zabezpečení služeb Azure AI.

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 byla s čím porovnávat budoucí ukázky hlasových služeb. V tomto příkladu profil zaregistrujete pomocí strategie závislé na textu , která vyžaduje konkrétní přístupové heslo, které se má použít pro registraci a ověření. Seznam podporovaných přístupových hesel najdete v referenční dokumentaci .

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 . Existují tři typyVoiceProfile:

  • TextIndependentIdentification
  • TextDependentVerification
  • TextIndependentVerification

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

Potom zavoláte dvě pomocné funkce, které budete definovat jako další, AddEnrollmentsToTextDependentProfile a SpeakerVerify. Nakonec volejte DeleteProfileAsync , abyste profil vyčistili.

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

V této funkci zaregistrujete zvukové vzorky do while smyčky, která sleduje počet zbývajících a požadovaných vzorků pro registraci. Při každé iteraci vás Funkce EnrollProfileAsync vyzve, abyste vyslovili heslo do mikrofonu, a přidá ukázku do hlasového profilu.

Funkce SpeakerVerify

Definujte SpeakerVerify ho takto:

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.

V dalším kroku se speechRecognizer::RecognizeOnceAsync zobrazí výzva, abyste heslo znovu vyslovili. Tentokrát ho ověří ve vašem hlasovém profilu a vrátí skóre podobnosti v rozsahu od 0,0 do 1,0. Objekt SpeakerRecognitionResult také vrátí Accept nebo Reject na základě toho, zda heslo 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é vzorky , ale vyžaduje 20 sekund celkového 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);
}

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

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

Pak zavoláte dvě pomocné funkce: AddEnrollmentsToTextIndependentProfile, které definujete jako další, a SpeakerVerify, které jste už definovali. Nakonec volejte DeleteProfileAsync , abyste profil vyčistili.

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

V této funkci zaregistrujete zvukové vzorky do while smyčky, která sleduje počet sekund zbývajícího zvuku a to, které jsou potřeba k registraci. Při každé iteraci vás Funkce EnrollProfileAsync vyzve, abyste promluvili do mikrofonu, a přidá ukázku do hlasového profilu.

Identifikace mluvčího

Identifikace mluvčího se používá k určení toho, kdo mluví z dané skupiny zaregistrovaných hlasů. Proces je podobný ověřování nezávislému na textu. Hlavním rozdílem je možnost ověření proti více hlasovým profilům najednou, a ne v jednom profilu.

TextIndependentIdentification – funkce

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

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

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

Potom zavoláte dvě pomocné funkce: AddEnrollmentsToTextIndependentProfile, které jste už definovali, a SpeakerIdentify, které definujete dále. Nakonec volejte DeleteProfileAsync , abyste profil vyčistili.

Funkce SpeakerIdentify

SpeakerIdentify Definujte 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::FromProfiles přijímá seznam objektů VoiceProfile . V tomto případě předáte objekt, který VoiceProfile jste vytvořili dříve. Pokud chcete, můžete předat více VoiceProfile objektů, z nichž každý je zaregistrovaný se zvukovými ukázkami z jiného hlasu.

V dalším kroku vás SpeechRecognizer::RecognizeOnceAsync vyzve, abyste znovu mluvili. Tentokrát porovná váš hlas s registrovanými hlasovými profily a vrátí nejvíce podobný hlasový profil.

Hlavní funkce

Nakonec definujte main 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 volá funkce, které jste definovali dříve. Nejprve vytvoří objekt VoiceProfileClient a Objekt SpeakerRecognizer .

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

Objekt slouží VoiceProfileClient k vytváření, registraci a odstraňování hlasových profilů. Objekt SpeakerRecognizer se používá k ověření ukázek řeči v jednom nebo více zaregistrovaných hlasových profilech.

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 místo vstupu z mikrofonu potřebujete použít zvukové soubory, změňte následující řádek:

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

na

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

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

Referenční dokumentace | Balíček (Go) | Další ukázky na GitHubu

V tomto rychlém startu se seznámíte se základními vzory návrhu pro rozpoznávání mluvčího pomocí sady Speech SDK, mezi které patří:

  • Ověření závislé na textu a nezávislé na textu.
  • Identifikace mluvčího k identifikaci vzorku hlasu mezi skupinou hlasů.
  • Odstraňují se hlasové profily.

Základní pohled na koncepty rozpoznávání mluvčího najdete v článku Přehled . Seznam podporovaných platforem najdete v uzlu Reference v levém podokně.

Důležité

Microsoft omezuje přístup k rozpoznávání mluvčího. Použijte ho, pokud ho chcete použít prostřednictvím formuláře pro kontrolu omezeného přístupu rozpoznávání mluvčího Azure AI . Po schválení budete mít přístup k rozhraním API pro rozpoznávání mluvčího.

Požadavky

Nastavení prostředí

Nainstalujte sadu Speech SDK pro Go. Další požadavky najdete v průvodci instalací sady SDK .

Provést nezávislou identifikaci

Podle těchto kroků vytvořte nový modul GO.

  1. Otevřete příkazový řádek, na kterém chcete nový modul použít, a vytvořte nový soubor s názvem independent-identification.go.

  2. Nahraďte obsah independent-identification.go souboru následujícím kódem.

    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. V independent-identification.gosouboru nahraďte YourSubscriptionKey klíčem prostředku služby Speech a nahraďte YourServiceRegion oblastí prostředku služby Speech.

    Důležité

    Až budete hotovi, nezapomeňte klíč z kódu odebrat a nikdy ho nezveřejníte. V produkčním prostředí použijte zabezpečený způsob ukládání a přístupu k přihlašovacím údajům, jako je Azure 密钥保管库. Další informace najdete v článku Zabezpečení služeb Azure AI.

Spuštěním následujících příkazů vytvořte soubor, který odkazuje go.mod na komponenty hostované na GitHubu:

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

Teď sestavte a spusťte kód:

go build
go run independent-identification

Provést nezávislé ověření

Podle těchto kroků vytvořte nový modul GO.

  1. Otevřete příkazový řádek, na kterém chcete nový modul použít, a vytvořte nový soubor s názvem independent-verification.go.

  2. Nahraďte obsah independent-verification.go souboru následujícím kódem.

    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. V independent-verification.gosouboru nahraďte YourSubscriptionKey klíčem prostředku služby Speech a nahraďte YourServiceRegion oblastí prostředku služby Speech.

Spuštěním následujících příkazů vytvořte soubor, který odkazuje go.mod na komponenty hostované na GitHubu:

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

Teď sestavte a spusťte kód:

go build
go run independent-verification

Vyčištění prostředků

Vytvořený prostředek služby Speech můžete odebrat pomocí Azure-Portal nebo rozhraní příkazového řádku Azure (CLI).

Referenční dokumentace | Další ukázky na GitHubu

Sada Speech SDK pro Javu sice podporuje rozpoznávání mluvčího, ale zatím jsme sem nezahrnuli příručku. Začněte tím, že vyberete jiný programovací jazyk a seznámíte se s koncepty, nebo se podívejte na referenční informace o Javě a ukázky uvedené na začátku tohoto článku.

Referenční dokumentace | Balíček (npm) | Další ukázky na GitHubu | Zdrojový kód knihovny

V tomto rychlém startu se seznámíte se základními vzory návrhu pro rozpoznávání mluvčího pomocí sady Speech SDK, mezi které patří:

  • Ověření závislé na textu a nezávislé na textu.
  • Identifikace mluvčího k identifikaci vzorku hlasu mezi skupinou hlasů.
  • Odstraňují se hlasové profily.

Základní pohled na koncepty rozpoznávání mluvčího najdete v článku Přehled . Seznam podporovaných platforem najdete v uzlu Reference v levém podokně.

Důležité

Microsoft omezuje přístup k rozpoznávání mluvčího. Použijte ho, pokud ho chcete použít prostřednictvím formuláře pro kontrolu omezeného přístupu rozpoznávání mluvčího Azure AI . Po schválení budete mít přístup k rozhraním API pro rozpoznávání mluvčího.

Požadavky

Instalace sady Speech SDK

Než začnete, musíte nainstalovat sadu Speech SDK pro JavaScript.

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

Stáhněte a extrahujte microsoft.cognitiveservices.speech.sdk.bundle.js soubor sady Speech SDK pro JavaScript. Umístěte ho do složky přístupné vašemu souboru HTML.

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

Tip

Pokud cílíte na webový prohlížeč a používáte <script> značku , sdk není předpona potřeba. Předpona sdk je alias, který slouží k pojmenování require modulu.

Import závislostí

Příklady v tomto článku spustíte tak, že na začátek souboru .js přidáte následující příkazy:

"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 získávají klíč a oblast předplatného služby Speech z proměnných prostředí. Určují také cesty ke zvukovým souborům, které použijete v následujících úlohách.

Důležité

Až budete hotovi, nezapomeňte klíč z kódu odebrat a nikdy ho nezveřejníte. V produkčním prostředí použijte zabezpečený způsob ukládání a přístupu k přihlašovacím údajům, jako je Azure 密钥保管库. Další informace najdete v článku Zabezpečení služeb Azure AI.

Vytvoření pomocné funkce

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

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

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

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 byla s čím porovnávat budoucí ukázky hlasových služeb. V tomto příkladu profil zaregistrujete pomocí strategie závislé na textu , která vyžaduje konkrétní přístupové heslo, které se má použít pro registraci a ověření. Seznam podporovaných přístupových hesel najdete v referenční dokumentaci .

Funkce TextDependentVerification

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

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

Tato funkce vytvoří objekt VoiceProfile pomocí metody VoiceProfileClient.createProfileAsync . Existují tři typyVoiceProfile:

  • TextIndependentIdentification
  • TextDependentVerification
  • TextIndependentVerification

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

Potom zavoláte dvě pomocné funkce, které budete definovat jako další, AddEnrollmentsToTextDependentProfile a SpeakerVerify. Nakonec zavolejte VoiceProfileClient.deleteProfileAsync a odeberte profil.

Funkce AddEnrollmentsToTextDependentProfile

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

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

V této funkci zavoláte GetAudioConfigFromFile funkci, kterou jste definovali dříve, abyste vytvořili AudioConfig objekty ze zvukových ukázek. Tyto zvukové ukázky obsahují přístupové heslo, například "Můj hlas je můj pas, ověřte mě". Tyto zvukové ukázky pak zaregistrujete pomocí metody VoiceProfileClient.enrollProfileAsync .

Funkce SpeakerVerify

Definujte SpeakerVerify ho takto:

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

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 zavoláte metodu SpeechRecognizer.recognizeOnceAsync k ověření zvukové ukázky, která obsahuje stejné heslo jako zvukové ukázky, které jste zaregistrovali dříve. SpeechRecognizer.recognizeOnceAsync vrátí SpeakerRecognitionResult objekt, jehož score vlastnost obsahuje skóre podobnosti v rozsahu od 0.0 do 1.0. Objekt SpeakerRecognitionResult obsahuje reason také vlastnost typu ResultReason. Pokud bylo ověření úspěšné, reason vlastnost by měla mít hodnotu RecognizedSpeaker.

Ověření nezávislé na textu

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

  • Nevyžaduje vyslovení určitého přístupového hesla. Mluvit se dá cokoliv.
  • Nevyžaduje tři zvukové ukázky , ale vyžaduje 20 sekund celkového zvuku.

Funkce TextIndependentVerification

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

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

TextDependentVerification Podobně jako funkce vytvoří tato funkce objekt VoiceProfile pomocí metody VoiceProfileClient.createProfileAsync.

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

Pak zavoláte dvě pomocné funkce: AddEnrollmentsToTextIndependentProfile, které definujete jako další, a SpeakerVerify, které jste už definovali. Nakonec zavolejte VoiceProfileClient.deleteProfileAsync a odeberte profil.

AddEnrollmentsToTextIndependentProfile

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

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

V této funkci zavoláte GetAudioConfigFromFile funkci, kterou jste definovali dříve, abyste vytvořili AudioConfig objekty ze zvukových ukázek. Tyto zvukové ukázky pak zaregistrujete pomocí metody VoiceProfileClient.enrollProfileAsync .

Identifikace mluvčího

Identifikace mluvčího se používá k určení toho, kdo mluví z dané skupiny zaregistrovaných hlasů. Proces je podobný ověřování nezávislému na textu. Hlavním rozdílem je možnost ověření proti více hlasovým profilům najednou, a ne v jednom 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 {
        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);
        }
    }
}

TextDependentVerification Stejně jako funkce a TextIndependentVerification vytvoří tato funkce objekt VoiceProfile pomocí metody VoiceProfileClient.createProfileAsync.

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

Potom zavoláte dvě pomocné funkce: AddEnrollmentsToTextIndependentProfile, které jste už definovali, a SpeakerIdentify, které definujete dále. Nakonec zavolejte VoiceProfileClient.deleteProfileAsync a odeberte profil.

Funkce SpeakerIdentify

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

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

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

Dále zavoláte metodu SpeechRecognizer.recognizeOnceAsync a předáte vzorek zvuku. SpeechRecognizer.recognizeOnceAsync se pokusí identifikovat hlas pro tuto ukázku zvuku VoiceProfile na základě objektů, které jste použili k vytvoření objektu SpeakerIdentificationModel. Vrátí SpeakerRecognitionResult objekt, 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.

Hlavní funkce

Nakonec definujte main funkci následujícím 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ý slouží k vytváření, registraci a odstraňování hlasových profilů. Potom zavolá funkce, které jste definovali dříve.

Referenční dokumentace | Balíček (stáhnout) | Další ukázky na GitHubu

Sada Speech SDK pro Objective-C nepodporuje rozpoznávání mluvčího. Vyberte jiný programovací jazyk nebo odkaz Objective-C a ukázky propojené od začátku tohoto článku.

Referenční dokumentace | Balíček (stáhnout) | Další ukázky na GitHubu

Sada Speech SDK pro Swift nepodporuje rozpoznávání mluvčího. Vyberte jiný programovací jazyk nebo referenční informace a ukázky Swiftu propojené od začátku tohoto článku.

Referenční dokumentace | Balíček (PyPi) | Další ukázky na GitHubu

Sada Speech SDK pro Python nepodporuje rozpoznávání mluvčího. Vyberte jiný programovací jazyk nebo referenční informace o Pythonu a ukázky, na které odkazujeme na začátku tohoto článku.

Referenční informace | k rozhraní REST API pro převod řeči na textRozhraní REST API pro převod řeči na text pro krátkou referenci | zvukuDalší ukázky na GitHubu

V tomto rychlém startu se seznámíte se základními vzory návrhu pro rozpoznávání mluvčího pomocí sady Speech SDK, mezi které patří:

  • Ověření závislé na textu a nezávislé na textu.
  • Identifikace mluvčího k identifikaci vzorku hlasu mezi skupinou hlasů.
  • Odstraňují se hlasové profily.

Základní pohled na koncepty rozpoznávání mluvčího najdete v článku Přehled . Seznam podporovaných platforem najdete v uzlu Reference v levém podokně.

Důležité

Microsoft omezuje přístup k rozpoznávání mluvčího. Použijte ho, pokud ho chcete použít prostřednictvím formuláře pro kontrolu omezeného přístupu rozpoznávání mluvčího Azure AI . Po schválení budete mít přístup k rozhraním API pro rozpoznávání mluvčího.

Požadavky

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 byla s čím porovnávat budoucí ukázky hlasových služeb. V tomto příkladu profil zaregistrujete pomocí strategie závislé na textu , která vyžaduje konkrétní přístupové heslo, které se má použít pro registraci a ověření. Seznam podporovaných přístupových hesel najdete v referenční dokumentaci .

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

Důležité

Až budete hotovi, nezapomeňte klíč z kódu odebrat a nikdy ho nezveřejníte. V produkčním prostředí použijte zabezpečený způsob ukládání a přístupu k přihlašovacím údajům, jako je Azure 密钥保管库. Další informace najdete v článku Zabezpečení služeb Azure AI.

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

Existují tři typy hlasových profilů:

  • Ověření závislé na textu
  • Ověření nezávislé na textu
  • Identifikace nezávislá na textu

V takovém případě vytvoříte hlasový profil pro ověření 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. Jako hodnotu parametru --data-binary zadejte zvukový soubor v počítači, který obsahuje jednu z podporovaných přístupových hesel, například "Můj hlas je můj pas, ověřte mě". 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-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'

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
}

Z této odpovědi se dozvíte, že je potřeba zaregistrovat další dvě zvukové ukázky.

Po registraci celkem tří zvukových ukázek byste měli obdržet 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
}

Teď jste připraveni ověřit vzorek zvuku v hlasovém profilu. Tato ukázka zvuku by měla obsahovat stejné heslo jako ukázky, které jste použili k registraci hlasového profilu.

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'

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

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

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

Dokončete odstranění hlasového profilu.

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'

Není na to žádná odpověď.

Ověření nezávislé na textu

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

  • Nevyžaduje vyslovení určitého přístupového hesla. Můžete mluvit o čemkoli.
  • Nevyžaduje tři zvukové ukázky , ale vyžaduje 20 sekund celkového zvuku.

Začněte vytvořením ověřovacího profilu nezávislého na textu.

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

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

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

V dalším kroku zaregistrujte hlasový profil. Opět platí, že místo odeslání tří zvukových ukázek musíte odeslat zvukové ukázky, které obsahují celkem 20 sekund zvuku.

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'

Po odeslání dostatečného množství zvukových ukázek byste měli obdržet 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
}

Teď jste připravení ověřit vzorek zvuku pro hlasový profil. Opět platí, že tato ukázka zvuku nemusí obsahovat přístupové heslo. Může obsahovat libovolnou řeč, ale musí obsahovat celkem alespoň čtyři sekundy zvuku.

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'

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

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

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

Dokončete odstraněním hlasového profilu.

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'

Nepřišla odpověď.

Identifikace mluvčího

Identifikace mluvčího se používá k určení toho, kdo mluví z dané skupiny zaregistrovaných hlasů. Proces je podobný ověřování nezávislému na textu. Hlavním rozdílem je možnost ověření proti více hlasovým profilům najednou, a ne v jednom profilu.

Začněte vytvořením identifikačního profilu nezávislého na textu.

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

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

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

V dalším kroku zaregistrujete hlasový profil. Opět musíte odeslat zvukové ukázky, které obsahují celkem 20 sekund zvuku. Tyto ukázky nemusí obsahovat přístupové heslo.

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'

Po odeslání dostatečného množství zvukových ukázek byste měli obdržet 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
}

Teď můžete pomocí hlasového profilu identifikovat vzorek zvuku. Příkaz identify přijímá seznam možných ID hlasových profilů oddělených čárkami. V takovém případě předáte ID hlasového profilu, který jste vytvořili dříve. Pokud chcete, můžete předat několik ID hlasových profilů, ve kterých je každý hlasový profil zaregistrovaný se zvukovými ukázkami z jiného hlasu.

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

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é nejvíce odpovídá zvukové ukázce, kterou jste odeslali. Obsahuje také seznam kandidátských hlasových profilů seřazených podle podobnosti.

Dokončete odstraněním hlasového profilu.

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'

Nepřišla odpověď.

Rozhraní příkazového řádku služby Speech podporuje rozpoznávání mluvčího, ale zatím jsme sem nezahrnuli průvodce. Začněte tím, že vyberete jiný programovací jazyk a seznámíte se s koncepty.

Další kroky

Podívejte se na ukázky rychlého startu na GitHubu.