Komma igång med Talarigenkänning

  • Artikel
  • 29 minuter för att läsa

I den här snabbstarten lär du dig grundläggande designmönster för Talarigenkänning med hjälp av Speech SDK, inklusive:

  • Textberoende och textoberoende verifiering
  • Talaridentifiering för att identifiera ett röstexempel bland en grupp röster
  • Ta bort röstprofiler

En översiktlig titt på Talarigenkänning finns i översiktsartikeln. En lista över plattformar som stöds finns i referensnoden i det vänstra navigeringsfältet.

Förutsättningar

Den här artikeln förutsätter att du har ett Azure-konto och en speech-tjänstprenumeration. Om du inte har något konto och en prenumeration kan du prova Speech-tjänsten utan kostnad.

Viktigt

Microsoft begränsar åtkomsten till Talarigenkänning. Använd för att använda den via Azure Cognitive Services Talarigenkänning Granskning av begränsad åtkomst. Efter godkännandet kan du komma åt Talarigenkänning API:er.

Installera Speech SDK

Innan du kan göra något måste du installera Speech SDK. Följ anvisningarna nedan beroende på din plattform:

Importera beroenden

Om du vill köra exemplen i den här artikeln inkluderar using du följande instruktioner överst i skriptet.

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

Skapa en talkonfiguration

Om du vill anropa Speech-tjänsten med hjälp av Speech SDK måste du skapa en SpeechConfig . I det här exemplet skapar du en med SpeechConfig hjälp av en prenumerationsnyckel och region. Du kan också skapa grundläggande exempelkod som ska användas för resten av den här artikeln, som du ändrar för olika anpassningar.

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

Textberoende verifiering

Talarverifiering är att bekräfta att en talare matchar en känd eller registrerad röst. Det första steget är att registrera en röstprofil så att tjänsten har något att jämföra framtida röstexempel med. I det här exemplet registrerar du profilen med hjälp av en textberoende strategi, vilket kräver en specifik lösenfras som ska användas för både registrering och verifiering. En lista över de lösenfraser som stöds finns i referensdokumenten.

Börja med att skapa följande funktion i klassen Program för att registrera en röstprofil.

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

I den här funktionen await client.CreateProfileAsync() är det som skapar den nya röstprofilen. När den har skapats anger du hur du ska mata in ljudexempel, med hjälp av i det här exemplet för AudioConfig.FromDefaultMicrophoneInput() att samla in ljud från din standardenhet för indata. Därefter registrerar du ljudexempel i en while loop som spårar det antal exempel som återstår och som krävs för registrering. I varje iteration uppmanas du att tala in lösenfrasen i mikrofonen och client.EnrollProfileAsync(profile, audioInput) lägga till exemplet i röstprofilen.

När registreringen är klar anropar du await SpeakerVerify(config, profile, profileMapping) för att verifiera mot den profil som du nyss skapade. Lägg till ytterligare en funktion för att definiera 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}");
}

I den här funktionen skickar du objektet VoiceProfile som du nyss skapade för att initiera en modell att verifiera mot. Sedan uppmanas du att tala om lösenfrasen igen, men den här gången valideras den mot din röstprofil och returnerar en await speakerRecognizer.RecognizeOnceAsync(model) likhetspoäng mellan 0,0–1,0. -objektet result returnerar Accept också eller , baserat på om Reject lösenfrasen matchar eller inte.

Ändra sedan funktionen så Main() att den anropar de nya funktioner som du skapade. Observera också att du skapar en som ska Dictionary<string, string> överföras via dina funktionsanrop. Anledningen till detta är att tjänsten inte tillåter lagring av ett läsbart namn med ett skapat och endast lagrar ett ID-nummer i VoiceProfile sekretesssyfte. I funktionen lägger du till en post med det nyligen skapade ID:t tillsammans med ett textnamn i VerificationEnroll den här ordlistan. I programutvecklingsscenarier där du behöver visa ett läsbart namn måste du lagra den här mappningen någonstans, tjänsten kan inte lagra den .

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

Kör skriptet så uppmanas du att tala upp frasen Min röst är mitt pass, verifiera mig tre gånger för registrering och ytterligare en gång för verifiering. Resultatet som returneras är likhetspoängen, som du kan använda för att skapa egna anpassade tröskelvärden för verifiering.

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

Textoberoende verifiering

Till skillnad från textberoende verifiering, textoberoende verifiering:

  • Kräver inte tre ljudexempel, men kräver 20 sekunders totalt ljud

Gör några enkla ändringar i funktionen VerificationEnroll för att växla till textoberoende verifiering. Först ändrar du verifieringstypen till VoiceProfileType.TextIndependentVerification . Ändra sedan loopen för att spåra , vilket fortsätter att uppmana dig att tala while result.RemainingEnrollmentsSpeechLength tills 20 sekunders ljud har avbildats.

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

Kör programmet igen. Återigen returneras likhetspoängen.

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

Talaridentifiering

Talaridentifiering används för att avgöra vem som talar från en viss grupp med registrerade röster. Processen liknar textoberoende verifiering, där den största skillnaden är att kunna verifiera mot flera röstprofiler samtidigt, i stället för att verifiera mot en enda profil.

Skapa en funktion IdentificationEnroll för att registrera flera röstprofiler. Registreringsprocessen för varje profil är samma som registreringsprocessen för textoberoende verifiering och kräver 20 sekunder ljud för varje profil. Den här funktionen accepterar en lista med strängar profileNames och skapar en ny röstprofil för varje namn i listan. Funktionen returnerar en lista med VoiceProfile objekt som du använder i nästa funktion för att identifiera en talare.

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

Skapa följande funktion för SpeakerIdentification att skicka en identifieringsbegäran. Den största skillnaden i den här funktionen jämfört med en begäran om talarverifiering är användningen av , som accepterar en lista SpeakerIdentificationModel.FromProfiles() över 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}");
}

Ändra Main() funktionen till följande. Du skapar en lista med strängar profileNames som du skickar till IdentificationEnroll() funktionen. Då uppmanas du att skapa en ny röstprofil för varje namn i listan, så att du kan lägga till fler namn för att skapa ytterligare profiler för vänner eller kollegor.

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

Kör skriptet så uppmanas du att tala för att registrera röstexempel för den första profilen. När registreringen är klar uppmanas du att upprepa den här processen för varje namn i listan profileNames . När varje registrering är klar uppmanas du att tala med vem som helst, och tjänsten kommer att försöka identifiera den här personen bland dina registrerade röstprofiler.

Det här exemplet returnerar bara den närmaste matchningen och dess likhetspoäng, men du kan få det fullständiga svaret som innehåller de fem främsta likhetspoängen genom att lägga string json = result.Properties.GetProperty(PropertyId.SpeechServiceResponse_JsonResult) till i SpeakerIdentification din funktion.

Ändra ljudindatatyp

Exemplen i den här artikeln använder enhetens standardmi mikrofon som indata för ljudexempel. Men i scenarier där du behöver använda ljudfiler i stället för mikrofonindata ändrar du helt enkelt valfri instans av till för AudioConfig.FromDefaultMicrophoneInput() att växla till en AudioConfig.FromWavFileInput(path/to/your/file.wav) filindata. Du kan också ha blandade indata med hjälp av en mikrofon för registrering och filer för verifiering, till exempel.

Ta bort röstprofilregistreringar

Om du vill ta bort en registrerad profil använder DeleteProfileAsync() du funktionen för VoiceProfileClient -objektet. Följande exempelfunktion visar hur du tar bort en röstprofil från ett känt röstprofil-ID.

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

I den här snabbstarten lär du dig grundläggande designmönster för Talarigenkänning med hjälp av Speech SDK, inklusive:

  • Textberoende och textoberoende verifiering
  • Talaridentifiering för att identifiera ett röstexempel bland en grupp röster
  • Ta bort röstprofiler

En översikt över de Talarigenkänning finns i översiktsartikeln. En lista över plattformar som stöds finns i referensnoden i det vänstra navigeringsfältet.

Gå vidare till exempel på GitHub

Om du vill hoppa direkt till exempelkoden kan du gå till C++-snabbstartsexempel på GitHub.

Förutsättningar

Den här artikeln förutsätter att du har ett Azure-konto och en prenumeration på Speech-tjänsten. Om du inte har ett konto och en prenumeration kan du prova Speech-tjänsten utan kostnad.

Viktigt

Microsoft begränsar åtkomsten till Talarigenkänning. Använd för att använda den via Azure Cognitive Services Talarigenkänning Limited Access Review. Efter godkännandet kan du komma åt Talarigenkänning API:er.

Installera Speech SDK

Innan du kan göra något måste du installera Speech SDK. Följ anvisningarna nedan beroende på din plattform:

Importera beroenden

Om du vill köra exemplen i den här artikeln lägger du till följande -instruktioner överst i .cpp-filen.

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

Skapa en talkonfiguration

Om du vill anropa Speech-tjänsten med hjälp av Speech SDK måste du skapa en SpeechConfig . Den här klassen innehåller information om din prenumeration, till exempel din nyckel och tillhörande region, slutpunkt, värd eller auktoriseringstoken.

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

Textberoende verifiering

Talarverifiering är att bekräfta att en talare matchar en känd eller registrerad röst. Det första steget är att registrera en röstprofil så att tjänsten har något att jämföra framtida röstexempel med. I det här exemplet registrerar du profilen med hjälp av en textberoende strategi, vilket kräver en specifik lösenfras som ska användas för både registrering och verifiering. En lista över lösenfraser som stöds finns i referensdokumenten.

Funktionen TextDependentVerification

Börja med att skapa TextDependentVerification funktionen.

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

Den här funktionen skapar ett VoiceProfile-objekt med metoden CreateProfileAsync. Observera att det finns tre typer av VoiceProfile :

  • TextIndependentIdentification
  • TextDependentVerification
  • TextIndependentVerification

I det här fallet skickar du VoiceProfileType::TextDependentVerification till CreateProfileAsync .

Sedan anropar du två hjälpfunktioner som du definierar härnäst, AddEnrollmentsToTextDependentProfile och SpeakerVerify . Anropa slutligen DeleteProfileAsync för att rensa profilen.

Funktionen AddEnrollmentsToTextDependentProfile

Definiera följande funktion för att registrera en röstprofil.

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

I den här funktionen registrerar du ljudexempel i en loop som spårar antalet while återstående exempel och krävs för registrering. I varje iteration uppmanar EnrollProfileAsync dig att tala in lösenfrasen i mikrofonen och lägger till exemplet i röstprofilen.

Funktionen SpeakerVerify

Definiera SpeakerVerify på följande sätt.

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

I den här funktionen skapar du ett SpeakerVerificationModel-objekt med metoden SpeakerVerificationModel::FromProfile och skicka in VoiceProfile-objektet som du skapade tidigare.

Därefter uppmanar SpeechRecognizer::RecognizeOnceAsync dig att tala lösenfrasen igen, men den här gången valideras den mot din röstprofil och returnerar en likhetspoäng från 0,0-1.0. SpeakerRecognitionResult-objektet returnerar också eller , baserat på Accept Reject om lösenfrasen matchar eller inte.

Textoberoende verifiering

Till skillnad från textberoende verifiering kräver textoberoende verifiering inte tre ljudexempel, men det krävs 20 sekunder totalt ljud.

Funktionen TextIndependentVerification

Börja med att skapa TextIndependentVerification funktionen.

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

Precis som TextDependentVerification funktionen skapar den här funktionen ett VoiceProfile-objekt med metoden CreateProfileAsync.

I det här fallet skickar du VoiceProfileType::TextIndependentVerification till CreateProfileAsync .

Sedan anropar du två hjälpfunktioner: AddEnrollmentsToTextIndependentProfile , som du definierar härnäst och , SpeakerVerify som du redan har definierat. Anropa slutligen DeleteProfileAsync för att rensa profilen.

AddEnrollmentsToTextIndependentProfile

Definiera följande funktion för att registrera en röstprofil.

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

I den här funktionen registrerar du ljudexempel i en loop som spårar antalet sekunder återstående ljud och krävs while för registrering. I varje iteration uppmanar EnrollProfileAsync dig att tala in i mikrofonen och lägger till exemplet i röstprofilen.

Talaridentifiering

Talaridentifiering används för att avgöra vem som talar från en viss grupp med registrerade röster. Processen liknar textoberoende verifiering, där den största skillnaden är att kunna verifiera mot flera röstprofiler samtidigt, i stället för att verifiera mot en enda profil.

Funktionen TextIndependentIdentification

Börja med att skapa TextIndependentIdentification funktionen.

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

Precis som TextDependentVerification funktionerna och skapar den här funktionen ett TextIndependentVerification VoiceProfile-objekt med metoden CreateProfileAsync.

I det här fallet skickar du VoiceProfileType::TextIndependentIdentification till CreateProfileAsync .

Sedan anropar du två hjälpfunktioner: AddEnrollmentsToTextIndependentProfile , som du redan har definierat och , som du SpeakerIdentify definierar härnäst. Anropa slutligen DeleteProfileAsync för att rensa profilen.

Funktionen SpeakerIdentify

Definiera funktionen SpeakerIdentify på följande sätt.

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

I den här funktionen skapar du ett SpeakerIdentificationModel-objekt med metoden SpeakerIdentificationModel::FromProfiles. SpeakerIdentificationModel::FromProfilesaccepterar en lista över VoiceProfile-objekt. I det här fallet skickar du bara in det VoiceProfile -objekt som du skapade tidigare. Men om du vill kan du skicka in flera VoiceProfile objekt som vart och ett registreras med ljudexempel från en annan röst.

Därefter uppmanar SpeechRecognizer::RecognizeOnceAsync dig att tala igen. Den här gången jämför den din röst med de registrerade röstprofilerna och returnerar den mest liknande röstprofilen.

Main-funktion

Definiera slutligen funktionen main på följande sätt.

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

Den här funktionen anropar helt enkelt de funktioner som du definierade tidigare. Först skapas dock ett VoiceProfileClient-objekt och ett SpeakerRecognizer-objekt.

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

VoiceProfileClientanvänds för att skapa, registrera och ta bort röstprofiler. SpeakerRecognizeranvänds för att verifiera talexempel mot en eller flera registrerade röstprofiler.

Ändra ljudindatatyp

Exemplen i den här artikeln använder enhetens standardmi mikrofon som indata för ljudexempel. Men i scenarier där du behöver använda ljudfiler i stället för mikrofonindata ändrar du helt enkelt följande rad:

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

till:

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

Eller ersätt all användning av audio_config med Audio::AudioConfig::FromWavFileInput. Du kan också ha blandade indata med hjälp av en mikrofon för registrering och filer för verifiering, till exempel.

I den här snabbstarten lär du dig grundläggande designmönster för Talarigenkänning med hjälp av Speech SDK, inklusive:

  • Textberoende och textoberoende verifiering
  • Talaridentifiering för att identifiera ett röstexempel bland en grupp röster
  • Ta bort röstprofiler

En översikt över de Talarigenkänning finns i översiktsartikeln. En lista över plattformar som stöds finns i referensnoden i det vänstra navigeringsfältet.

Gå vidare till exempel på GitHub

Om du vill hoppa direkt till exempelkod kan du gå till Snabbstartsexempel för JavaScript på GitHub.

Förutsättningar

Den här artikeln förutsätter att du har ett Azure-konto och en prenumeration på Speech-tjänsten. Om du inte har ett konto och en prenumeration kan du prova Speech-tjänsten utan kostnad.

Viktigt

Talarigenkänning stöds för närvarande endast i Azure Speech-resurser som skapats i westus regionen.

Installera Speech SDK

Innan du kan göra något måste du installera Speech SDK för JavaScript. Följ anvisningarna nedan beroende på din plattform:

Beroende på målmiljön använder du dessutom något av följande:

Ladda ned och extrahera Speech SDK för JavaScript microsoft.cognitiveservices.speech.sdk.bundle.js och placera den i en mapp som är tillgänglig för HTML-filen.

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

Tips

Om du riktar in dig på en webbläsare och använder <script> taggen sdk behövs inte prefixet . Prefixet sdk är ett alias som används för att namnge require modulen.

Importera beroenden

Om du vill köra exemplen i den här artikeln lägger du till följande -instruktioner överst i .js filen.

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

De här isatserna importerar de bibliotek som krävs och hämtar din prenumerationsnyckel och region för Speech-tjänsten från dina miljövariabler. De anger också sökvägar till ljudfiler som du kommer att använda i följande uppgifter.

Skapa hjälpfunktion

Lägg till följande hjälpfunktion för att läsa ljudfiler i strömmar för användning av Speech-tjänsten.

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

I den här funktionen använder du metoderna AudioInputStream.createPushStream och AudioConfig.fromStreamInput för att skapa ett AudioConfig-objekt. Det AudioConfig här objektet representerar en ljudström. Du kommer att använda flera av AudioConfig dessa objekt under följande uppgifter.

Textberoende verifiering

Talarverifiering är att bekräfta att en talare matchar en känd eller registrerad röst. Det första steget är att registrera en röstprofil så att tjänsten har något att jämföra framtida röstexempel med. I det här exemplet registrerar du profilen med hjälp av en textberoende strategi, vilket kräver en specifik lösenfras som ska användas för både registrering och verifiering. En lista över lösenfraser som stöds finns i referensdokumenten.

Funktionen TextDependentVerification

Börja med att skapa TextDependentVerification funktionen.

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

Den här funktionen skapar ett VoiceProfile-objekt med metoden VoiceProfileClient.createProfileAsync. Observera att det finns tre typer av VoiceProfile :

  • TextIndependentIdentification
  • TextDependentVerification
  • TextIndependentVerification

I det här fallet skickar du VoiceProfileType.TextDependentVerification till VoiceProfileClient.createProfileAsync .

Sedan anropar du två hjälpfunktioner som du definierar härnäst, AddEnrollmentsToTextDependentProfile och SpeakerVerify . Anropa slutligen VoiceProfileClient.deleteProfileAsync för att ta bort profilen.

Funktionen AddEnrollmentsToTextDependentProfile

Definiera följande funktion för att registrera en röstprofil.

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

I den här funktionen anropar du funktionen GetAudioConfigFromFile som du definierade tidigare för att skapa objekt från AudioConfig ljudexempel. Dessa ljudexempel innehåller en lösenfras som "Min röst är mitt pass, verifiera mig". Sedan registrerar du dessa ljudexempel med hjälp av metoden VoiceProfileClient.enrollProfileAsync.

Funktionen SpeakerVerify

Definiera SpeakerVerify på följande sätt.

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

I den här funktionen skapar du ett SpeakerVerificationModel-objekt med metoden SpeakerVerificationModel.FromProfile och skicka in VoiceProfile-objektet som du skapade tidigare.

Därefter anropar du metoden SpeechRecognizer.recognizeOnceAsync för att verifiera ett ljudexempel som innehåller samma lösenfras som de ljudexempel som du registrerade tidigare. SpeechRecognizer.recognizeOnceAsync returnerar ett SpeakerRecognitionResult-objekt vars egenskap innehåller en score likhetspoäng mellan 0,0-1,0. -objektet SpeakerRecognitionResult innehåller också en egenskap av typen reason ResultReason. Om verifieringen lyckades ska reason egenskapen ha värdet RecognizedSpeaker .

Textoberoende verifiering

Till skillnad från textberoende verifiering, textoberoende verifiering:

  • Kräver inte att en viss lösenfras talas, något kan talas
  • Kräver inte tre ljudexempel, men kräver 20 sekunders totalt ljud

Funktionen TextIndependentVerification

Börja med att skapa TextIndependentVerification funktionen.

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

Precis som TextDependentVerification funktionen skapar den här funktionen ett VoiceProfile-objekt med metoden VoiceProfileClient.createProfileAsync.

I det här fallet skickar du VoiceProfileType.TextIndependentVerification till createProfileAsync .

Sedan anropar du två hjälpfunktioner: AddEnrollmentsToTextIndependentProfile , som du definierar härnäst och , SpeakerVerify som du redan har definierat. Anropa slutligen VoiceProfileClient.deleteProfileAsync för att ta bort profilen.

AddEnrollmentsToTextIndependentProfile

Definiera följande funktion för att registrera en röstprofil.

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

I den här funktionen anropar du funktionen GetAudioConfigFromFile som du definierade tidigare för att skapa objekt från AudioConfig ljudexempel. Sedan registrerar du dessa ljudexempel med hjälp av metoden VoiceProfileClient.enrollProfileAsync.

Talaridentifiering

Talaridentifiering används för att avgöra vem som talar från en viss grupp med registrerade röster. Processen liknar textoberoende verifiering, där den största skillnaden är att kunna verifiera mot flera röstprofiler samtidigt, i stället för att verifiera mot en enda profil.

Funktionen TextIndependentIdentification

Börja med att skapa TextIndependentIdentification funktionen.

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

Precis som TextDependentVerification funktionerna och skapar den här funktionen ett TextIndependentVerification VoiceProfile-objekt med metoden VoiceProfileClient.createProfileAsync.

I det här fallet skickar du VoiceProfileType.TextIndependentIdentification till VoiceProfileClient.createProfileAsync .

Sedan anropar du två hjälpfunktioner: AddEnrollmentsToTextIndependentProfile , som du redan har definierat och , som du SpeakerIdentify definierar härnäst. Anropa slutligen VoiceProfileClient.deleteProfileAsync för att ta bort profilen.

Funktionen SpeakerIdentify

Definiera funktionen SpeakerIdentify på följande sätt.

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

I den här funktionen skapar du ett SpeakerIdentificationModel-objekt med metoden SpeakerIdentificationModel.fromProfiles och skicka in VoiceProfile-objektet som du skapade tidigare.

Därefter anropar du metoden SpeechRecognizer.recognizeOnceAsync och skickar ett ljudexempel. SpeechRecognizer.recognizeOnceAsync försöker identifiera rösten för det här ljudprovet baserat på VoiceProfile de objekt som du använde för att skapa SpeakerIdentificationModel . Den returnerar ett SpeakerRecognitionResult-objekt vars egenskap identifierar den matchande , om en sådan finns, medan egenskapen innehåller en profileId likhetspoäng mellan VoiceProfile score 0,0–1,0.

Main-funktion

Definiera slutligen funktionen main på följande sätt.

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

Den här funktionen skapar ett VoiceProfileClient-objekt som används för att skapa, registrera och ta bort röstprofiler. Sedan anropas de funktioner som du definierade tidigare.

I den här snabbstarten lär du dig grundläggande designmönster för Talarigenkänning med hjälp av Speech SDK, inklusive:

  • Textberoende och textoberoende verifiering
  • Talaridentifiering för att identifiera ett röstexempel bland en grupp röster
  • Ta bort röstprofiler

En översiktlig titt på Talarigenkänning finns i översiktsartikeln. En lista över de plattformar som stöds finns i referensnoden i det vänstra navigeringsfältet.

Förutsättningar

Den här artikeln förutsätter att du har ett Azure-konto och en speech-tjänstprenumeration. Om du inte har något konto och en prenumeration kan du prova Speech-tjänsten utan kostnad.

Viktigt

Talarigenkänning stöds för närvarande endast i Azure Speech-resurser som skapats i westus regionen.

Textberoende verifiering

Talarverifiering är att bekräfta att en talare matchar en känd eller registrerad röst. Det första steget är att registrera en röstprofil så att tjänsten har något att jämföra framtida röstexempel med. I det här exemplet registrerar du profilen med hjälp av en textberoende strategi, vilket kräver att en specifik lösenfras används för både registrering och verifiering. En lista över lösenfraser som stöds finns i referensdokumenten.

Börja med att skapa en röstprofil. Du måste infoga din prenumerationsnyckel och region för Speech-tjänsten i vart och ett av curl-kommandona i den här artikeln.

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

Observera att det finns tre typer av röstprofiler:

  • Textberoende verifiering
  • Textoberoende verifiering
  • Textoberoende identifiering

I det här fallet skapar du en textberoende röstprofil för verifiering. Du bör få följande svar.

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

Därefter registrerar du röstprofilen. För parametervärdet anger du en ljudfil på datorn som innehåller en av de lösenfraser som stöds, till exempel "min röst är mitt --data-binary pass, verifiera mig". Du kan spela in en sådan ljudfil med en app som Windows Röstinspelaren, eller så kan du generera den med hjälp av text-till-tal.

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'

Du bör få följande svar.

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

Det här svaret anger att du behöver registrera ytterligare två ljudexempel.

När du har registrerat totalt tre ljudexempel bör du få följande svar.

{
    "remainingEnrollmentsCount": 0,
    "passPhrase": "my voice is my passport verify me",
    "profileId": "714ce523-de76-4220-b93f-7c1cc1882d6e",
    "enrollmentStatus": "Enrolled",
    "enrollmentsCount": 3,
    "enrollmentsLength": 10.5,
    "enrollmentsSpeechLength": 8.64,
    "audioLength": 3.5,
    "audioSpeechLength": 2.88
}

Nu är du redo att verifiera ett ljudexempel mot röstprofilen. Det här ljudexempel bör innehålla samma lösenfras som de exempel som du använde för att registrera röstprofilen.

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'

Du bör få följande svar.

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

Innebär Accept att lösenfrasen matchade och att verifieringen lyckades. Svaret innehåller också en likhetspoäng mellan 0,0–1,0.

Avsluta genom att ta bort röstprofilen.

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'

Det finns inget svar.

Textoberoende verifiering

Till skillnad från textberoende verifiering, textoberoende verifiering:

  • Kräver inte att en viss lösenfras talas, allt kan sägas
  • Kräver inte tre ljudexempel, men kräver 20 sekunders totalt ljud

Börja med att skapa en textoberoende verifieringsprofil.

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

Du bör få följande svar.

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

Registrera sedan röstprofilen. I stället för att skicka tre ljudexempel måste du skicka ljudexempel som innehåller totalt 20 sekunders ljud.

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'

När du har skickat tillräckligt med ljudexempel bör du få följande svar.

{
    "remainingEnrollmentsSpeechLength": 0.0,
    "profileId": "3f85dca9-ffc9-4011-bf21-37fad2beb4d2",
    "enrollmentStatus": "Enrolled",
    "enrollmentsCount": 1,
    "enrollmentsLength": 33.16,
    "enrollmentsSpeechLength": 29.21,
    "audioLength": 33.16,
    "audioSpeechLength": 29.21
}

Nu är du redo att verifiera ett ljudexempel mot röstprofilen. Återigen behöver det här ljudexempel inte innehålla en lösenfras. Det kan innehålla val annat tal, så länge det innehåller totalt minst fyra sekunders ljud.

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'

Du bör få följande svar.

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

Innebär Accept att verifieringen lyckades. Svaret innehåller också en likhetspoäng mellan 0,0–1,0.

Avsluta genom att ta bort röstprofilen.

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'

Det finns inget svar.

Talaridentifiering

Talaridentifiering används för att avgöra vem som talar från en viss grupp med registrerade röster. Processen liknar textoberoende verifiering, där den största skillnaden är att kunna verifiera mot flera röstprofiler samtidigt, i stället för att verifiera mot en enda profil.

Börja med att skapa en textoberoende identifieringsprofil.

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

Du bör få följande svar.

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

Därefter registrerar du röstprofilen. Återigen måste du skicka ljudexempel som innehåller totalt 20 sekunders ljud. De här exemplen behöver inte innehålla en lösenfras.

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'

När du har skickat tillräckligt med ljudexempel bör du få följande svar.

{
    "remainingEnrollmentsSpeechLength": 0.0,
    "profileId": "de99ab38-36c8-4b82-b137-510907c61fe8",
    "enrollmentStatus": "Enrolled",
    "enrollmentsCount": 2,
    "enrollmentsLength": 36.69,
    "enrollmentsSpeechLength": 31.95,
    "audioLength": 33.16,
    "audioSpeechLength": 29.21
}

Nu är du redo att identifiera ett ljudexempel med hjälp av röstprofilen. Kommandot identify accepterar en kommaavgränsad lista över möjliga röstprofil-ID:er. I det här fallet skickar du bara ID:t för röstprofilen som du skapade tidigare. Men om du vill kan du skicka in flera röstprofil-ID:er där varje röstprofil registreras med ljudexempel från en annan röst.

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'

Du bör få följande svar.

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

Svaret innehåller ID:t för röstprofilen som bäst matchar ljudprovet som du skickade. Den innehåller också en lista över kandidatröstprofiler, rangordnade i likhetsordning.

Avsluta genom att ta bort röstprofilen.

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'

Det finns inget svar.

Nästa steg

  • Mer information Talarigenkänning finns i referensdokumentationen om klasser och funktioner.

  • Se C# och C++-exempel på GitHub.