Komma igång med Talarigenkänning

I den här snabb starten lär du dig grundläggande design mönster för Talarigenkänning med hjälp av tal-SDK, inklusive:

  • Text beroende och text oberoende verifiering
  • Högtalar identifiering för att identifiera ett röst exempel bland en grupp röster
  • Ta bort röst profiler

En övergripande överblick över tal igenkännings koncept finns i översikts artikeln.

Förutsättningar

Den här artikeln förutsätter att du har ett Azure-konto och en röst tjänst prenumeration. Om du inte har ett konto och en prenumeration kan du prova att använda tal tjänsten kostnads fritt.

Viktigt

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

Installera Speech SDK

Innan du kan göra något måste du installera talet SDK. Använd följande instruktioner, beroende på plattform:

Importera beroenden

Om du vill köra exemplen i den här artikeln inkluderar du följande using 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 tal konfiguration

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

Observera att regionen är inställt på westus , eftersom det är den enda region som stöds för tjänsten.

public class Program 
{
    static async Task Main(string[] args)
    {
        // replace with your own subscription key 
        string subscriptionKey = "YourSubscriptionKey";
        string region = "westus";
        var config = SpeechConfig.FromSubscription(subscriptionKey, region);
    }
}

Text beroende verifiering

Talarverifiering är en bekräftelse på att en talare matchar en känd eller registrerad röst. Det första steget är att Registrera en röst profil, så att tjänsten har något att jämföra framtida röst exempel mot. I det här exemplet registrerar du profilen med en text beroende strategi, som kräver att en speciell pass fras används för både registrering och verifiering. En lista över de pass fraser som stöds finns i referens dokumenten .

Börja med att skapa följande funktion i din- Program klass för att registrera en röst profil.

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 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, \"My voice is my passport, verify me.\"");
                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 faktiskt skapar den nya röst profilen. När den har skapats anger du hur du vill att ljud exempel ska matas in med hjälp av AudioConfig.FromDefaultMicrophoneInput() i det här exemplet för att avbilda ljud från din standardenhet för indata. Sedan registrerar du ljud exempel i en while slinga som spårar antalet återstående prover och krävs för registrering. I varje iteration client.EnrollProfileAsync(profile, audioInput) kommer du att uppmanas att prata med pass frasen till din mikrofon och lägga till exemplet i röst profilen.

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 en annan funktion som ska definieras 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 det VoiceProfile objekt som du nyss skapade för att initiera en modell att verifiera mot. Sedan await speakerRecognizer.RecognizeOnceAsync(model) uppmanas du att prata med pass frasen igen, men den här gången kommer den att verifieras mot din röst profil och returnerar en likhets poäng på mellan 0,0 – 1,0. resultObjektet returnerar också Accept eller Reject , baserat på om pass fras matchningen ska matchas eller inte.

Ändra sedan Main() funktionen så att den anropar de nya funktionerna som du skapade. Observera också att du skapar en Dictionary<string, string> för att skicka en att skicka med-referens via dina funktions anrop. Orsaken till detta är att tjänsten inte tillåter lagring av ett människo läsbart namn med ett skapat VoiceProfile , och lagrar bara ett ID-nummer i sekretess syfte. I VerificationEnroll funktionen lägger du till en post med det nya ID: t, tillsammans med ett text namn i den här ord listan. I program utvecklings scenarier där du behöver visa ett människo läsbart namn måste du lagra 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 och du uppmanas att tala om frasen min röst är mitt Passport, verifiera mig tre gånger för registrering och en ytterligare tid för verifiering. Resultatet som returneras är likhets poä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

Text oberoende verifiering

I motsats till text beroende verifiering, text oberoende verifiering:

  • Kräver ingen viss pass-fras för att bli talas, allt kan ses över
  • Kräver inte tre ljud exempel , men kräver 20 sekunders total ljud

Gör några enkla ändringar i din VerificationEnroll funktion för att växla till text oberoende verifiering. Först ändrar du verifierings typen till VoiceProfileType.TextIndependentVerification . Ändra sedan while slingan till Track result.RemainingEnrollmentsSpeechLength , som kommer fortsätta att uppmana dig att tala tills 20 sekunder ljud har fångats.

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 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("Continue speaking to add to the profile enrollment sample.");
                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 och tala om vad som helst under verifierings fasen eftersom det inte krävs någon pass fras. Återigen returneras likhets poängen.

Enrolling profile id 4tt87d4-f2d3-44ae-b5b4-f1a8d4036ee9.
Continue speaking to add to the profile enrollment sample.
Remaining enrollment audio time needed: 00:00:15.3200000

Continue speaking to add to the profile enrollment sample.
Remaining enrollment audio time needed: 00:00:09.8100008

Continue speaking to add to the profile enrollment sample.
Remaining enrollment audio time needed: 00:00:05.1900000

Continue speaking to add to the profile enrollment sample.
Remaining enrollment audio time needed: 00:00:00.8700000

Continue speaking to add to the profile enrollment sample.
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 bestämma vem som talar från en specifik grupp med registrerade röster. Processen liknar text oberoende verifiering, med den största skillnaden att kunna verifiera mot flera röst profiler samtidigt, i stället för att verifiera mot en enskild profil.

Skapa en funktion IdentificationEnroll för att registrera flera röst profiler. Registrerings processen för varje profil är samma som registrerings processen för text oberoende verifiering och kräver 20 sekunders ljud för varje profil. Den här funktionen accepterar en lista med strängar profileNames och skapar en ny röst profil för varje namn i listan. Funktionen returnerar en lista med VoiceProfile objekt som du kan använda 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))
    {
        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($"Continue speaking 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 SpeakerIdentification en identifierings förfrågan genom att skapa följande funktion. Den största skillnaden i den här funktionen jämfört med en begäran om att Verifiera en talare är att använda SpeakerIdentificationModel.FromProfiles() , vilket accepterar en lista med 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 din IdentificationEnroll() funktion. Då uppmanas du att skapa en ny röst profil för varje namn i listan, så 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";
    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>();
    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 och uppmanas att tala om att registrera röst exempel 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 färdig uppmanas du att låta någon tala och tjänsten försöker identifiera personen från dina registrerade röst profiler.

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

Ändrar typ av ljud inspelning

I exemplen i den här artikeln används standard mikrofonen för enheten som indata för ljud exempel. I scenarier där du behöver använda ljudfiler i stället för mikrofon indata kan du dock bara ändra en instans av till för att AudioConfig.FromDefaultMicrophoneInput() AudioConfig.FromWavFileInput(path/to/your/file.wav) Växla till en fil indata. Du kan också använda blandade indata med en mikrofon för registrering och filer för verifiering, till exempel.

Ta bort röst profil registreringar

Om du vill ta bort en registrerad profil använder du DeleteProfileAsync() funktionen på VoiceProfileClient objektet. Följande exempel funktion visar hur du tar bort en röst profil från ett känt röst profil-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 begreppen för taligenkänning finns i översiktsartikeln.

Hoppa till exempel på GitHub

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

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.

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 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.

TextDependentVerification-funktion

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.

AddEnrollmentsToTextDependentProfile-funktion

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 återstående exempel och krävs while för registrering. I varje iteration uppmanar EnrollProfileAsync dig att tala 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 sedan skicka voiceProfile-objektet som du skapade tidigare.

Därefter uppmanar SpeechRecognizer::RecognizeOnceAsync dig att tala lösenfrasen igen, men den här gången validerar den den mot din röstprofil och returnerar en likhetspoäng mellan 0,0–1,0. Objektet SpeakerRecognitionResult returnerar Accept också eller , baserat på om Reject lösenfrasen matchar eller inte.

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

TextIndependentVerification-funktion

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 har registrerats med ljudexempel från en annan röst.

Därefter uppmanar SpeechRecognizer::RecognizeOnceAsync dig att tala igen. Den här gången jämförs 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, till exempel med en mikrofon för registrering och filer för verifiering.

I den här snabb starten lär du dig grundläggande design mönster för Talarigenkänning med hjälp av tal-SDK, inklusive:

  • Text beroende och text oberoende verifiering
  • Högtalar identifiering för att identifiera ett röst exempel bland en grupp röster
  • Ta bort röst profiler

En övergripande överblick över tal igenkännings koncept finns i översikts artikeln.

Hoppa till exempel på GitHub

Om du vill hoppa över direkt till exempel kod kan du läsa snabb starts exemplen för Java Script på GitHub.

Förutsättningar

Den här artikeln förutsätter att du har ett Azure-konto och en röst tjänst prenumeration. Om du inte har ett konto och en prenumeration kan du prova att använda tal tjänsten kostnads fritt.

Viktigt

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

Installera Speech SDK

Innan du kan göra något måste du installera Speech SDK för Java Script . Använd följande instruktioner, beroende på plattform:

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

Hämta och extrahera talet SDK för java script microsoft.cognitiveservices.speech.sdk.bundle.js -filen 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 är mål för en webbläsare och använder <script> taggen, sdk behövs inte prefixet. sdkPrefixet ä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;

Dessa påståenden importerar de bibliotek som krävs och hämtar prenumerations nyckeln för din röst tjänst och region från dina miljövariabler. De anger även sökvägar till ljudfiler som du kommer att använda i följande uppgifter.

Skapa hjälp funktion

Lägg till följande hjälp funktion för att läsa ljudfiler i strömmar för användning av tal 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. AudioConfigObjektet representerar en ljud ström. Du kommer att använda flera av dessa AudioConfig objekt under följande uppgifter.

Text beroende verifiering

Talarverifiering är en bekräftelse på att en talare matchar en känd eller registrerad röst. Det första steget är att Registrera en röst profil, så att tjänsten har något att jämföra framtida röst exempel mot. I det här exemplet registrerar du profilen med en text beroende strategi, som kräver att en unik lösen fras används för både registrering och verifiering. En lista över lösen fraser som stöds finns i referens dokumenten .

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älp funktioner 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öst profil.

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 GetAudioConfigFromFile funktionen som du definierade tidigare för att skapa AudioConfig objekt från ljud exempel. Dessa ljud exempel innehåller en lösen fras som "min röst är mitt Passport, verifiera mig". Du registrerar sedan dessa ljud exempel med hjälp av metoden VoiceProfileClient. enrollProfileAsync .

Funktionen SpeakerVerify

Definiera SpeakerVerify enligt följande.

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 som skickar i VoiceProfile -objektet som du skapade tidigare.

Sedan anropar du metoden SpeechRecognizer. recognizeOnceAsync för att verifiera ett ljud prov som innehåller samma lösen fras som de ljud exempel du registrerade tidigare. SpeechRecognizer.recognizeOnceAsync Returnerar ett SpeakerRecognitionResult -objekt, vars score egenskap innehåller en likhets Poäng i intervallet 0,0-1.0. SpeakerRecognitionResultObjektet innehåller också en reason egenskap av typen ResultReason. Om verifieringen lyckades måste reason egenskapen ha ett värde RecognizedSpeaker .

Text oberoende verifiering

I motsats till text beroende verifiering, text oberoende verifiering:

  • Kräver ingen viss lösen fras för att kunna läsas, något kan ses över
  • Kräver inte tre ljud exempel , men kräver 20 sekunders total 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älp funktioner: AddEnrollmentsToTextIndependentProfile , som du definierar härnäst och SpeakerVerify , som du definierade redan. Anropa slutligen VoiceProfileClient. deleteProfileAsync för att ta bort profilen.

AddEnrollmentsToTextIndependentProfile

Definiera följande funktion för att registrera en röst profil.

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 GetAudioConfigFromFile funktionen som du definierade tidigare för att skapa AudioConfig objekt från ljud exempel. Du registrerar sedan dessa ljud exempel med hjälp av metoden VoiceProfileClient. enrollProfileAsync .

Talaridentifiering

Talaridentifiering används för att bestämma vem som talar från en specifik grupp med registrerade röster. Processen liknar text oberoende verifiering, med den största skillnaden att kunna verifiera mot flera röst profiler samtidigt, i stället för att verifiera mot en enskild 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 TextIndependentVerification -och-funktionerna skapar den här funktionen ett VoiceProfile -objekt med metoden VoiceProfileClient. createProfileAsync .

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

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

Funktionen SpeakerIdentify

Definiera SpeakerIdentify funktionen enligt följande.

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 som skickar i VoiceProfile -objektet som du skapade tidigare.

Sedan anropar du metoden SpeechRecognizer. recognizeOnceAsync och skickar i ett ljud exempel. SpeechRecognizer.recognizeOnceAsync försöker identifiera rösten för det här ljud exemplet baserat på de VoiceProfile objekt som du använde för att skapa SpeakerIdentificationModel . Den returnerar ett SpeakerRecognitionResult -objekt, vars profileId egenskap identifierar matchningen VoiceProfile , om det finns några, medan score egenskapen innehåller ett likhets resultat mellan 0,0-1.0.

Huvud funktion

Definiera slutligen main funktionen enligt följande.

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öst profiler. Sedan anropas de funktioner som du definierade tidigare.

I den här snabb starten lär du dig grundläggande design mönster för Talarigenkänning med hjälp av tal-SDK, inklusive:

  • Text beroende och text oberoende verifiering
  • Högtalar identifiering för att identifiera ett röst exempel bland en grupp röster
  • Ta bort röst profiler

En övergripande överblick över tal igenkännings koncept finns i översikts artikeln.

Förutsättningar

Den här artikeln förutsätter att du har ett Azure-konto och en röst tjänst prenumeration. Om du inte har ett konto och en prenumeration kan du prova att använda tal tjänsten kostnads fritt.

Viktigt

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

Text beroende verifiering

Talarverifiering är en bekräftelse på att en talare matchar en känd eller registrerad röst. Det första steget är att Registrera en röst profil, så att tjänsten har något att jämföra framtida röst exempel mot. I det här exemplet registrerar du profilen med en text beroende strategi, som kräver att en unik lösen fras används för både registrering och verifiering. En lista över lösen fraser som stöds finns i referens dokumenten .

Börja med att skapa en röst profil. Du måste lägga till din prenumerations nyckel och region för röst tjänsten i var och en av de olika Vändnings 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öst profiler:

  • Text beroende verifiering
  • Text oberoende verifiering
  • Text oberoende identifiering

I det här fallet skapar du en text beroende verifierings röst profil. 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
}

Sedan registrerar du röst profilen. För --data-binary parametervärdet anger du en ljudfil på datorn som innehåller något av de lösen fraser som stöds, till exempel "min röst är mitt Passport, verifiera mig". Du kan spela in en sådan ljudfil med en app som Windows röst inspelareeller så kan du skapa den med 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 visar att du behöver registrera två fler ljud exempel.

När du har registrerat totalt tre ljud exempel 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 ljud exempel mot röst profilen. Ljud exemplet bör innehålla samma lösen fras som de exempel som du använde för att registrera röst profilen.

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
}

AcceptInnebär att lösen frasen matchar och verifieringen lyckades. Svaret innehåller också en likhets Poäng som sträcker sig från 0,0-1.0.

Ta bort röst profilenför att avsluta.

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.

Text oberoende verifiering

I motsats till text beroende verifiering, text oberoende verifiering:

  • Kräver ingen viss lösen fras för att kunna läsas, något kan ses över
  • Kräver inte tre ljud exempel , men kräver 20 sekunders total ljud

Börja med att skapa en text oberoende verifierings profil.

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öst profilen. I stället för att skicka tre ljud exempel måste du skicka ljud exempel 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 många ljud-exempel 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 ljud exempel mot röst profilen. Detta ljud exempel behöver inte innehålla någon lösen fras. Det kan innehålla ett 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
}

AcceptInnebär att verifieringen lyckades. Svaret innehåller också en likhets Poäng som sträcker sig från 0,0-1.0.

Ta bort röst profilenför att avsluta.

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 bestämma vem som talar från en specifik grupp med registrerade röster. Processen liknar text oberoende verifiering, med den största skillnaden att kunna verifiera mot flera röst profiler samtidigt, i stället för att verifiera mot en enskild profil.

Börja med att skapa en text oberoende identifierings profil.

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

Sedan registrerar du röst profilen. Återigen måste du skicka ljud exempel som innehåller totalt 20 sekunders ljud. Dessa exempel behöver inte innehålla en lösen fras.

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 många ljud-exempel 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 ljud exempel med röst profilen. Kommandot identifiera accepterar en kommaavgränsad lista med möjliga röst profil-ID: n. I det här fallet skickar du bara det ID för röst profilen som du skapade tidigare. Men om du vill kan du skicka i flera röst profil-ID: n där varje röst profil registreras med ljud exempel 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 den röst profil som bäst matchar ljud exemplet du skickade. Den innehåller också en lista över kandidat röst profiler, rankade i likhets ordning.

Ta bort röst profilenför att avsluta.

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.