Rövid útmutató: Annak felismerése és ellenőrzése, hogy ki beszél

Referenciadokumentáció | Csomag (NuGet) | További minták a GitHubon

Ebben a rövid útmutatóban a Beszéd SDK használatával megismerheti a beszélőfelismerés alapvető tervezési mintáit, többek között a következőket:

• Szövegfüggő és szövegfüggetlen ellenőrzés.
• Beszélőazonosítás egy hangminta azonosításához a hangcsoportok között.
• Hangprofilok törlése.

A beszélőfelismerési fogalmakat az Áttekintés című cikkben tekintheti meg. A támogatott platformok listáját a bal oldali panel Referencia csomópontjában találja.

Fontos

A Microsoft korlátozza a beszélőfelismeréshez való hozzáférést. Alkalmazza a használatát az Azure AI Speaker Recognition Limited Access Review űrlapon. A jóváhagyás után hozzáférhet a Speaker Recognition API-khoz.

Előfeltételek

• Azure-előfizetés – Hozzon létre egyet ingyen.
• Beszéderőforrás létrehozása a Azure Portal.
• A Speech erőforráskulcsa és régiója. A Speech-erőforrás üzembe helyezése után válassza az Erőforrás megnyitása lehetőséget a kulcsok megtekintéséhez és kezeléséhez. További információ az Azure AI-szolgáltatások erőforrásairól: Az erőforrás kulcsainak lekérése.

A Speech SDK telepítése

A kezdés előtt telepítenie kell a Speech SDK-t. A platformtól függően kövesse az alábbi utasításokat:

• .NET-keretrendszer
• .NET Core
• Egység
• UWP
• Xamarin

Függőségek importálása

A cikkben szereplő példák futtatásához adja meg a következő using utasításokat a szkript tetején:

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

Beszédkonfiguráció létrehozása

Ahhoz, hogy meghívja a Speech szolgáltatást a Speech SDK használatával, létre kell hoznia egy példányt SpeechConfig . Ebben a példában egy előfizetési kulcs és régió használatával hoz létre egy SpeechConfig példányt. A cikk további részében is létrehoz néhány alapszintű sablonkódot, amelyet a különböző testreszabásokhoz módosít.

Fontos

Ne felejtse el eltávolítani a kulcsot a kódból, amikor elkészült, és soha ne tegye közzé nyilvánosan. Éles környezetben biztonságos módon tárolhatja és érheti el a hitelesítő adatait, például az Azure Key Vault. További információért tekintse meg az Azure AI-szolgáltatások biztonsági cikkét.

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

Szövegfüggő ellenőrzés

A beszélő ellenőrzése annak ellenőrzésére szolgál, hogy egy beszélő egy ismert vagy regisztrált hangnak felel-e meg. Az első lépés egy hangprofil regisztrálása, hogy a szolgáltatás összehasonlíthassa a jövőbeli hangmintákat. Ebben a példában egy szövegfüggő stratégiával regisztrálja a profilt, amelyhez egy adott jelszó szükséges a regisztrációhoz és az ellenőrzéshez. A támogatott jelszókkal kapcsolatban tekintse meg a referenciadokumentumokat .

Először hozza létre a következő függvényt az Program osztályban egy hangprofil regisztrálásához:

public static async Task VerificationEnroll(SpeechConfig config, Dictionary<string, string> profileMapping)
{
    using (var client = new VoiceProfileClient(config))
    using (var profile = await client.CreateProfileAsync(VoiceProfileType.TextDependentVerification, "en-us"))
    {
        var phraseResult = await client.GetActivationPhrasesAsync(VoiceProfileType.TextDependentVerification, "en-us");
        using (var audioInput = AudioConfig.FromDefaultMicrophoneInput())
        {
            Console.WriteLine($"Enrolling profile id {profile.Id}.");
            // give the profile a human-readable display name
            profileMapping.Add(profile.Id, "Your Name");

            VoiceProfileEnrollmentResult result = null;
            while (result is null || result.RemainingEnrollmentsCount > 0)
            {
                Console.WriteLine($"Speak the passphrase, \"${phraseResult.Phrases[0]}\"");
                result = await client.EnrollProfileAsync(profile, audioInput);
                Console.WriteLine($"Remaining enrollments needed: {result.RemainingEnrollmentsCount}");
                Console.WriteLine("");
            }
            
            if (result.Reason == ResultReason.EnrolledVoiceProfile)
            {
                await SpeakerVerify(config, profile, profileMapping);
            }
            else if (result.Reason == ResultReason.Canceled)
            {
                var cancellation = VoiceProfileEnrollmentCancellationDetails.FromResult(result);
                Console.WriteLine($"CANCELED {profile.Id}: ErrorCode={cancellation.ErrorCode} ErrorDetails={cancellation.ErrorDetails}");
            }
        }
    }
}

Ebben a függvényben await client.CreateProfileAsync() valójában ez hozza létre az új hangprofilt. A létrehozás után megadhatja, hogyan fog hangmintákat AudioConfig.FromDefaultMicrophoneInput() bemenetként használni ebben a példában az alapértelmezett bemeneti eszköz hangjának rögzítéséhez. Ezután egy hurokban while regisztrálja a hangmintákat, amelyek nyomon követik a regisztrációhoz hátralévő és szükséges minták számát. Minden iterációban megkéri, hogy beszéljen a jelszóval a mikrofonba, client.EnrollProfileAsync(profile, audioInput) és adja hozzá a mintát a hangprofilhoz.

A regisztráció befejezése után hívja await SpeakerVerify(config, profile, profileMapping) meg az ellenőrzést az imént létrehozott profilon. Adjon hozzá egy másik függvényt a definiálásához 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}");
}

Ebben a függvényben az imént létrehozott objektumot adja át VoiceProfile , hogy inicializáljon egy modellt az ellenőrzéshez. Ezután megkéri, await speakerRecognizer.RecognizeOnceAsync(model) hogy beszéljen újra a jelszóval. Ezúttal a hangprofilon ellenőrzi, és 0,0 és 1,0 közötti hasonlósági pontszámot ad vissza. Az result objektum a vagy Rejectértéket is visszaadja Accept attól függően, hogy a jelszó megegyezik-e.

Ezután módosítsa a függvényt Main() úgy, hogy meghívja a létrehozott új függvényeket. Azt is vegye figyelembe, hogy a függvényhívásokon keresztül hivatkozással továbbítandó fájlt Dictionary<string, string> hoz létre. Ennek az az oka, hogy a szolgáltatás nem engedélyezi egy emberi olvasásra alkalmas név tárolását egy létrehozott VoiceProfilefájllal, és csak egy azonosítószámot tárol adatvédelmi okokból. A függvényben hozzáad ehhez a VerificationEnroll szótárhoz egy bejegyzést az újonnan létrehozott azonosítóval és egy szövegnévvel. Olyan alkalmazásfejlesztési forgatókönyvekben, ahol emberi olvasásra alkalmas nevet kell megjelenítenie, ezt a leképezést valahol el kell tárolnia, mert a szolgáltatás nem tudja tárolni.

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

Futtassa a szkriptet. A rendszer arra kéri, hogy háromszor mondja ki a "Hangom az útlevelem, igazoljon" szöveget, és még egyszer ellenőrzésre. A visszaadott eredmény a hasonlósági pontszám, amellyel saját egyéni küszöbértékeket hozhat létre az ellenőrzéshez.

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

Szövegfüggetlen ellenőrzés

A szövegfüggő ellenőrzéssel ellentétben a szövegfüggetlen ellenőrzéshez nincs szükség három hangmintára, de 20 másodpercnyi teljes hanganyagra van szükség.

Néhány egyszerű módosítást hajthat végre a VerificationEnroll függvényen, hogy szövegfüggetlen ellenőrzésre váltson. Először módosítsa az ellenőrzési típust a következőre: VoiceProfileType.TextIndependentVerification. Ezután módosítsa a hurkot while a nyomon követéshez result.RemainingEnrollmentsSpeechLength, amely továbbra is arra kéri, hogy beszéljen, amíg 20 másodpercnyi hang nem lett rögzítve.

public static async Task VerificationEnroll(SpeechConfig config, Dictionary<string, string> profileMapping)
{
    using (var client = new VoiceProfileClient(config))
    using (var profile = await client.CreateProfileAsync(VoiceProfileType.TextIndependentVerification, "en-us"))
    {
        var phraseResult = await client.GetActivationPhrasesAsync(VoiceProfileType.TextIndependentVerification, "en-us");
        using (var audioInput = AudioConfig.FromDefaultMicrophoneInput())
        {
            Console.WriteLine($"Enrolling profile id {profile.Id}.");
            // give the profile a human-readable display name
            profileMapping.Add(profile.Id, "Your Name");

            VoiceProfileEnrollmentResult result = null;
            while (result is null || result.RemainingEnrollmentsSpeechLength > TimeSpan.Zero)
            {
                Console.WriteLine($"Speak the activation phrase, \"${phraseResult.Phrases[0]}\"");
                result = await client.EnrollProfileAsync(profile, audioInput);
                Console.WriteLine($"Remaining enrollment audio time needed: {result.RemainingEnrollmentsSpeechLength}");
                Console.WriteLine("");
            }
            
            if (result.Reason == ResultReason.EnrolledVoiceProfile)
            {
                await SpeakerVerify(config, profile, profileMapping);
            }
            else if (result.Reason == ResultReason.Canceled)
            {
                var cancellation = VoiceProfileEnrollmentCancellationDetails.FromResult(result);
                Console.WriteLine($"CANCELED {profile.Id}: ErrorCode={cancellation.ErrorCode} ErrorDetails={cancellation.ErrorDetails}");
            }
        }
    }
}

Futtassa újra a programot, és a rendszer visszaadja a hasonlósági pontszámot.

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

Beszélőazonosítás

A beszélőazonosítással állapítható meg, hogy ki beszél egy adott regisztrált hangcsoportból. A folyamat hasonló a szövegfüggetlen ellenőrzéshez. A fő különbség az a képesség, hogy egyszerre több hangprofilon kell ellenőrizni ahelyett, hogy egyetlen profilon ellenőrizned kell.

Hozzon létre egy függvényt IdentificationEnroll több hangprofil regisztrálásához. Az egyes profilok regisztrációs folyamata megegyezik a szövegfüggetlen ellenőrzés regisztrációs folyamatával. A folyamathoz minden profilhoz 20 másodperc hang szükséges. Ez a függvény elfogadja a sztringek profileNames listáját, és létrehoz egy új hangprofilt a listában szereplő összes névhez. A függvény visszaadja az VoiceProfile objektumok listáját, amelyeket a következő függvényben használ egy beszélő azonosításához.

public static async Task<List<VoiceProfile>> IdentificationEnroll(SpeechConfig config, List<string> profileNames, Dictionary<string, string> profileMapping)
{
    List<VoiceProfile> voiceProfiles = new List<VoiceProfile>();
    using (var client = new VoiceProfileClient(config))
    {
        var phraseResult = await client.GetActivationPhrasesAsync(VoiceProfileType.TextIndependentVerification, "en-us");
        foreach (string name in profileNames)
        {
            using (var audioInput = AudioConfig.FromDefaultMicrophoneInput())
            {
                var profile = await client.CreateProfileAsync(VoiceProfileType.TextIndependentIdentification, "en-us");
                Console.WriteLine($"Creating voice profile for {name}.");
                profileMapping.Add(profile.Id, name);

                VoiceProfileEnrollmentResult result = null;
                while (result is null || result.RemainingEnrollmentsSpeechLength > TimeSpan.Zero)
                {
                    Console.WriteLine($"Speak the activation phrase, \"${phraseResult.Phrases[0]}\" to add to the profile enrollment sample for {name}.");
                    result = await client.EnrollProfileAsync(profile, audioInput);
                    Console.WriteLine($"Remaining enrollment audio time needed: {result.RemainingEnrollmentsSpeechLength}");
                    Console.WriteLine("");
                }
                voiceProfiles.Add(profile);
            }
        }
    }
    return voiceProfiles;
}

Hozza létre az alábbi függvényt SpeakerIdentification egy azonosító kérés elküldéséhez. Ennek a függvénynek a fő különbsége a beszélő-ellenőrzési kéréshez képest a használata SpeakerIdentificationModel.FromProfiles(), amely elfogadja az VoiceProfile objektumok listáját.

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

Módosítsa a Main() függvényt a következőre. Létrehoz egy sztringlistát profileNames, amelyet átad a IdentificationEnroll() függvénynek. A rendszer arra kéri, hogy hozzon létre egy új hangprofilt a listában szereplő összes névhez, így további neveket adhat hozzá, hogy több profilt hozzon létre barátainak vagy munkatársainak.

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

Futtassa a szkriptet. A rendszer arra kéri, hogy beszéljen, hogy regisztráljon hangmintákat az első profilhoz. A regisztráció befejezése után a rendszer felkéri, hogy ismételje meg ezt a folyamatot a profileNames listában szereplő összes név esetében. Miután minden regisztráció befejeződött, a rendszer kérni fogja, hogy bárki is beszéljen. A szolgáltatás ezután megpróbálja azonosítani ezt a személyt a regisztrált hangprofilok közül.

Ez a példa csak a legközelebbi egyezést és annak hasonlósági pontszámát adja vissza. Ha a teljes választ szeretné megkapni, amely tartalmazza az első öt hasonlósági pontszámot, adja hozzá string json = result.Properties.GetProperty(PropertyId.SpeechServiceResponse_JsonResult) a SpeakerIdentification függvényhez.

Hangbemenet típusának módosítása

A cikkben szereplő példák az alapértelmezett eszközmikrofont használják hangminták bemeneteként. Olyan esetekben, amikor a mikrofon bemenete helyett hangfájlokat kell használnia, módosítsa a példányokat AudioConfig.FromDefaultMicrophoneInput()AudioConfig.FromWavFileInput(path/to/your/file.wav) fájlbemenetre. Vegyes bemeneteket is használhat, ha mikrofont használ a regisztrációhoz, valamint fájlokat az ellenőrzéshez, például.

Hangprofil-regisztrációk törlése

Regisztrált profil törléséhez használja az DeleteProfileAsync() objektum függvényét VoiceProfileClient . Az alábbi példafüggvény bemutatja, hogyan törölhet hangprofilt egy ismert hangprofil-azonosítóból:

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

Referenciadokumentáció | Csomag (NuGet) | További minták a GitHubon

Ebben a rövid útmutatóban a Beszéd SDK használatával megismerheti a beszélőfelismerés alapvető tervezési mintáit, többek között a következőket:

• Szövegfüggő és szövegfüggetlen ellenőrzés.
• Beszélőazonosítás egy hangminta azonosításához a hangcsoportok között.
• Hangprofilok törlése.

A beszélőfelismerési fogalmakat az Áttekintés című cikkben tekintheti meg. A támogatott platformok listáját a bal oldali panel Referencia csomópontjában találja.

Fontos

A Microsoft korlátozza a beszélőfelismeréshez való hozzáférést. Alkalmazza a használatát az Azure AI Speaker Recognition Limited Access Review űrlapon. A jóváhagyás után hozzáférhet a Speaker Recognition API-khoz.

Előfeltételek

• Azure-előfizetés – Hozzon létre egyet ingyen.
• Beszéderőforrás létrehozása a Azure Portal.
• A Speech erőforráskulcsa és régiója. A Speech-erőforrás üzembe helyezése után válassza az Erőforrás megnyitása lehetőséget a kulcsok megtekintéséhez és kezeléséhez. További információ az Azure AI-szolgáltatások erőforrásairól: Az erőforrás kulcsainak lekérése.

A Speech SDK telepítése

A kezdés előtt telepítenie kell a Speech SDK-t. A platformtól függően kövesse az alábbi utasításokat:

• Linux
• Macos
• Windows

Függőségek importálása

A cikkben szereplő példák futtatásához adja hozzá a következő utasításokat a .cpp fájl tetején:

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

Beszédkonfiguráció létrehozása

Ha a Speech SDK használatával szeretné meghívni a Speech szolgáltatást, hozzon létre egy osztályt SpeechConfig . Ez az osztály az előfizetéssel kapcsolatos információkat tartalmazza, például a kulcsát és a hozzá tartozó régiót, végpontot, gazdagépet vagy engedélyezési jogkivonatot.

Fontos

Ne felejtse el eltávolítani a kulcsot a kódból, amikor elkészült, és soha ne tegye közzé nyilvánosan. Éles környezetben biztonságos módon tárolhatja és érheti el a hitelesítő adatait, például az Azure Key Vault. További információért tekintse meg az Azure AI-szolgáltatások biztonsági cikkét.

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

Szövegfüggő ellenőrzés

A beszélő ellenőrzése annak ellenőrzésére szolgál, hogy egy beszélő egy ismert vagy regisztrált hangnak felel-e meg. Az első lépés egy hangprofil regisztrálása, hogy a szolgáltatás összehasonlíthassa a jövőbeli hangmintákat. Ebben a példában egy szövegfüggő stratégiával regisztrálja a profilt, amelyhez egy adott jelszó szükséges a regisztrációhoz és az ellenőrzéshez. A támogatott jelszókkal kapcsolatban tekintse meg a referenciadokumentumokat .

TextDependentVerification függvény

Először hozza létre a függvényt TextDependentVerification :

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

Ez a függvény létrehoz egy VoiceProfile objektumot a CreateProfileAsync metódussal. A következő három típus létezikVoiceProfile:

• TextIndependentIdentification
• TextDependentVerification
• TextIndependentVerification

Ebben az esetben a következőt adja meg VoiceProfileType::TextDependentVerification : CreateProfileAsync.

Ezután hívjon meg két segédfüggvényt, amelyeket a következőben definiálni fog: AddEnrollmentsToTextDependentProfile és SpeakerVerify. Végül hívja meg a DeleteProfileAsync parancsot a profil törléséhez.

AddEnrollmentsToTextDependentProfile függvény

A hangprofil regisztrálásához adja meg a következő függvényt:

void AddEnrollmentsToTextDependentProfile(shared_ptr<VoiceProfileClient> client, shared_ptr<VoiceProfile> profile)
{
    shared_ptr<VoiceProfileEnrollmentResult> enroll_result = nullptr;
    auto phraseResult = client->GetActivationPhrasesAsync(profile->GetType(), profile_locale).get();
    auto phrases = phraseResult->GetPhrases();
    while (enroll_result == nullptr || enroll_result->GetEnrollmentInfo(EnrollmentInfoType::RemainingEnrollmentsCount) > 0)
    {
        if (phrases != nullptr && phrases->size() > 0)
        {
            std::cout << "Please say the passphrase, \"" << phrases->at(0) << "\"\n";
            enroll_result = client->EnrollProfileAsync(profile, audio_config).get();
            std::cout << "Remaining enrollments needed: " << enroll_result->GetEnrollmentInfo(EnrollmentInfoType::RemainingEnrollmentsCount) << ".\n";
        }
        else
        {
            std::cout << "No passphrases received, enrollment not attempted.\n\n";
        }
    }
    std::cout << "Enrollment completed.\n\n";
}

Ebben a függvényben hangmintákat regisztrál egy while hurokba, amely nyomon követi a regisztrációhoz hátralévő és szükséges minták számát. Az EnrollProfileAsync minden iterációban megkéri, hogy beszéljen a jelszóval a mikrofonba, és hozzáadja a mintát a hangprofilhoz.

SpeakerVerify függvény

Definiálja SpeakerVerify a következőket:

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

Ebben a függvényben egy SpeakerVerificationModel objektumot hoz létre a SpeakerVerificationModel::FromProfile metódussal, amely a korábban létrehozott VoiceProfile objektumot adja át.

Ezután a SpeechRecognizer::RecognizeOnceAsync kéri, hogy beszéljen újra a jelszóval. Ezúttal a hangprofilon ellenőrzi, és 0,0 és 1,0 közötti hasonlósági pontszámot ad vissza. A SpeakerRecognitionResult objektum azt is visszaadja Accept , vagy Reject attól függ, hogy a jelszó megegyezik-e.

Szövegfüggetlen ellenőrzés

A szövegfüggő ellenőrzéssel ellentétben a szövegfüggetlen ellenőrzéshez nincs szükség három hangmintára, de 20 másodpercnyi teljes hanganyagra van szükség.

TextIndependentVerification függvény

Először hozza létre a függvényt TextIndependentVerification :

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

A függvényhez hasonlóan ez a TextDependentVerification függvény is létrehoz egy VoiceProfile objektumot a CreateProfileAsync metódussal.

Ebben az esetben a következőt adja meg VoiceProfileType::TextIndependentVerification : CreateProfileAsync.

Ezután két segédfüggvényt hívhat meg: AddEnrollmentsToTextIndependentProfile, amelyet a következőként fog definiálni, és SpeakerVerifyamelyet már definiált. Végül hívja meg a DeleteProfileAsync parancsot a profil törléséhez.

AddEnrollmentsToTextIndependentProfile

A hangprofil regisztrálásához adja meg a következő függvényt:

void AddEnrollmentsToTextIndependentProfile(shared_ptr<VoiceProfileClient> client, shared_ptr<VoiceProfile> profile)
{
    shared_ptr<VoiceProfileEnrollmentResult> enroll_result = nullptr;
    auto phraseResult = client->GetActivationPhrasesAsync(profile->GetType(), profile_locale).get();
    auto phrases = phraseResult->GetPhrases();
    while (enroll_result == nullptr || enroll_result->GetEnrollmentInfo(EnrollmentInfoType::RemainingEnrollmentsSpeechLength) > 0)
    {
        if (phrases != nullptr && phrases->size() > 0)
        {
            std::cout << "Please say the activation phrase, \"" << phrases->at(0) << "\"\n";
            enroll_result = client->EnrollProfileAsync(profile, audio_config).get();
            std::cout << "Remaining audio time needed: " << enroll_result->GetEnrollmentInfo(EnrollmentInfoType::RemainingEnrollmentsSpeechLength) / ticks_per_second << " seconds.\n";
        }
        else
        {
            std::cout << "No activation phrases received, enrollment not attempted.\n\n";
        }
    }
    std::cout << "Enrollment completed.\n\n";
}

Ebben a függvényben hangmintákat regisztrál egy while hurokba, amely nyomon követi a regisztrációhoz szükséges és a hátralévő hang másodperceinek számát. Az EnrollProfileAsync minden iterációban arra kéri, hogy beszéljen a mikrofonnal, és hozzáadja a mintát a hangprofilhoz.

Beszélőazonosítás

A beszélőazonosítással állapítható meg, hogy ki beszél egy adott regisztrált hangcsoportból. A folyamat hasonló a szövegfüggetlen ellenőrzéshez. A fő különbség az a képesség, hogy egyszerre több hangprofilon kell ellenőrizni ahelyett, hogy egyetlen profilon ellenőrizned kell.

TextIndependentIdentification függvény

Először hozza létre a függvényt TextIndependentIdentification :

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

A és TextIndependentVerification függvényekhez hasonlóan ez a TextDependentVerification függvény is létrehoz egy VoiceProfile objektumot a CreateProfileAsync metódussal.

Ebben az esetben a következőt adja meg VoiceProfileType::TextIndependentIdentification : CreateProfileAsync.

Ezután két segédfüggvényt hívhat meg: AddEnrollmentsToTextIndependentProfile, amelyet már definiált, és SpeakerIdentify, amelyet a következőként fog definiálni. Végül hívja meg a DeleteProfileAsync parancsot a profil törléséhez.

SpeakerIdentify függvény

A függvény meghatározása az SpeakerIdentify alábbiak szerint:

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

Ebben a függvényben egy SpeakerIdentificationModel objektumot hoz létre a SpeakerIdentificationModel::FromProfiles metódussal. SpeakerIdentificationModel::FromProfiles Elfogadja a VoiceProfile-objektumok listáját. Ebben az esetben a korábban létrehozott objektumot adja át VoiceProfile . Ha szeretné, több VoiceProfile objektumot is átadhat, amelyek mindegyike más hangmintákkal van regisztrálva.

Következő lépésként a SpeechRecognizer::RecognizeOnceAsync kéri, hogy beszéljen újra. Ezúttal összehasonlítja a hangját a regisztrált hangprofilokkal, és a leginkább hasonló hangprofilt adja vissza.

Fő függvény

Végül definiálja a függvényt az main alábbiak szerint:

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

Ez a függvény meghívja a korábban definiált függvényeket. Először létrehoz egy VoiceProfileClient objektumot és egy SpeakerRecognizer objektumot.

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

Az VoiceProfileClient objektum hangprofilok létrehozására, regisztrálására és törlésére szolgál. Az SpeakerRecognizer objektum a beszédminták egy vagy több regisztrált hangprofilon való ellenőrzésére szolgál.

Hangbemenet típusának módosítása

A cikkben szereplő példák az alapértelmezett eszközmikrofont használják hangminták bemeneteként. Olyan esetekben, amikor a mikrofon bemenete helyett hangfájlokat kell használnia, módosítsa a következő sort:

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

erre:

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

Vagy cserélje le az összes használatát az audio_configAudio::AudioConfig::FromWavFileInput parancsra. Vegyes bemeneteket is használhat, ha mikrofont használ a regisztrációhoz, valamint fájlokat az ellenőrzéshez, például.

Referenciadokumentáció | Csomag (Go) | További minták a GitHubon

Ebben a rövid útmutatóban a Beszéd SDK használatával megismerheti a beszélőfelismerés alapvető tervezési mintáit, többek között a következőket:

• Szövegfüggő és szövegfüggetlen ellenőrzés.
• Beszélőazonosítás egy hangminta azonosításához a hangcsoportok között.
• Hangprofilok törlése.

A beszélőfelismerési fogalmakat az Áttekintés című cikkben tekintheti meg. A támogatott platformok listáját a bal oldali panel Referencia csomópontjában találja.

Fontos

A Microsoft korlátozza a beszélőfelismeréshez való hozzáférést. Alkalmazza a használatát az Azure AI Speaker Recognition Limited Access Review űrlapon. A jóváhagyás után hozzáférhet a Speaker Recognition API-khoz.

Előfeltételek

• Azure-előfizetés – Hozzon létre egyet ingyen.
• Beszéderőforrás létrehozása a Azure Portal.
• A Speech erőforráskulcsa és régiója. A Speech-erőforrás üzembe helyezése után válassza az Erőforrás megnyitása lehetőséget a kulcsok megtekintéséhez és kezeléséhez. További információ az Azure AI-szolgáltatások erőforrásairól: Az erőforrás kulcsainak lekérése.

A környezet beállítása

Telepítse a Speech SDK for Go-t. További követelményekért tekintse meg az SDK telepítési útmutatóját

Független azonosítás végrehajtása

Kövesse az alábbi lépéseket egy új GO-modul létrehozásához.

1. Nyisson meg egy parancssort, ahol az új modult szeretné, és hozzon létre egy új fájlt nevű independent-identification.gonéven.

2. Cserélje le a tartalmát independent-identification.go a következő kódra.

   package main
   
   import (
       "bufio"
       "fmt"
       "os"
       "time"
   
       "github.com/Microsoft/cognitive-services-speech-sdk-go/audio"
       "github.com/Microsoft/cognitive-services-speech-sdk-go/common"
       "github.com/Microsoft/cognitive-services-speech-sdk-go/speaker"
       "github.com/Microsoft/cognitive-services-speech-sdk-go/speech"
   )
   
   func GetNewVoiceProfileFromClient(client *speaker.VoiceProfileClient, expectedType common.VoiceProfileType) *speaker.VoiceProfile {
       future := client.CreateProfileAsync(expectedType, "en-US")
       outcome := <-future
       if outcome.Failed() {
           fmt.Println("Got an error creating profile: ", outcome.Error.Error())
           return nil
       }
       profile := outcome.Profile
       _, err := profile.Id()
       if err != nil {
           fmt.Println("Unexpected error creating profile id: ", err)
           return nil
       }
       profileType, err := profile.Type();
       if err != nil {
           fmt.Println("Unexpected error getting profile type: ", err)
           return nil
       }
       if profileType != expectedType {
           fmt.Println("Profile type does not match expected type")
           return nil
       }
       return profile
   }
   
   func EnrollProfile(client *speaker.VoiceProfileClient, profile *speaker.VoiceProfile, audioConfig *audio.AudioConfig) {
       enrollmentReason, currentReason := common.EnrollingVoiceProfile, common.EnrollingVoiceProfile
       var currentResult *speaker.VoiceProfileEnrollmentResult
       expectedEnrollmentCount := 1
       for currentReason == enrollmentReason {
           fmt.Println(`Please speak the following phrase: "I'll talk for a few seconds so you can recognize my voice in the future."`)
           enrollFuture := client.EnrollProfileAsync(profile, audioConfig)
           enrollOutcome := <-enrollFuture
           if enrollOutcome.Failed() {
               fmt.Println("Got an error enrolling profile: ", enrollOutcome.Error.Error())
               return
           }
           currentResult = enrollOutcome.Result
           currentReason = currentResult.Reason
           if currentResult.EnrollmentsCount != expectedEnrollmentCount {
               fmt.Println("Unexpected enrollments for profile: ", currentResult.RemainingEnrollmentsCount)
           }
           expectedEnrollmentCount += 1
       }
       if currentReason != common.EnrolledVoiceProfile {
           fmt.Println("Unexpected result enrolling profile: ", currentResult)
       }
   }
   
   func DeleteProfile(client *speaker.VoiceProfileClient, profile *speaker.VoiceProfile) {
       deleteFuture := client.DeleteProfileAsync(profile)
       deleteOutcome := <-deleteFuture
       if deleteOutcome.Failed() {
           fmt.Println("Got an error deleting profile: ", deleteOutcome.Error.Error())
           return
       }
       result := deleteOutcome.Result
       if result.Reason != common.DeletedVoiceProfile {
           fmt.Println("Unexpected result deleting profile: ", result)
       }
   }
   
   func main() {
       subscription :=  "YourSubscriptionKey"
       region := "YourServiceRegion"
       config, err := speech.NewSpeechConfigFromSubscription(subscription, region)
       if err != nil {
           fmt.Println("Got an error: ", err)
           return
       }
       defer config.Close()
       client, err := speaker.NewVoiceProfileClientFromConfig(config)
       if err != nil {
           fmt.Println("Got an error: ", err)
           return
       }
       defer client.Close()
       audioConfig, err := audio.NewAudioConfigFromDefaultMicrophoneInput()
       if err != nil {
           fmt.Println("Got an error: ", err)
           return
       }
       defer audioConfig.Close()
       <-time.After(10 * time.Second)
       expectedType := common.VoiceProfileType(1)
   
       profile := GetNewVoiceProfileFromClient(client, expectedType)
       if profile == nil {
           fmt.Println("Error creating profile")
           return
       }
       defer profile.Close()
   
       EnrollProfile(client, profile, audioConfig)
   
       profiles := []*speaker.VoiceProfile{profile}
       model, err := speaker.NewSpeakerIdentificationModelFromProfiles(profiles)
       if err != nil {
           fmt.Println("Error creating Identification model: ", err)
       }
       if model == nil {
           fmt.Println("Error creating Identification model: nil model")
           return
       }
       identifyAudioConfig, err := audio.NewAudioConfigFromDefaultMicrophoneInput()
       if err != nil {
           fmt.Println("Got an error: ", err)
           return
       }
       defer identifyAudioConfig.Close()
       speakerRecognizer, err := speaker.NewSpeakerRecognizerFromConfig(config, identifyAudioConfig)
       if err != nil {
           fmt.Println("Got an error: ", err)
           return
       }
       identifyFuture := speakerRecognizer.IdentifyOnceAsync(model)
       identifyOutcome := <-identifyFuture
       if identifyOutcome.Failed() {
           fmt.Println("Got an error identifying profile: ", identifyOutcome.Error.Error())
           return
       }
       identifyResult := identifyOutcome.Result
       if identifyResult.Reason != common.RecognizedSpeakers {
           fmt.Println("Got an unexpected result identifying profile: ", identifyResult)
       }
       expectedID, _ := profile.Id()
       if identifyResult.ProfileID != expectedID {
           fmt.Println("Got an unexpected profile id identifying profile: ", identifyResult.ProfileID)
       }
       if identifyResult.Score < 1.0 {
           fmt.Println("Got an unexpected score identifying profile: ", identifyResult.Score)
       }
   
       DeleteProfile(client, profile)
       bufio.NewReader(os.Stdin).ReadBytes('\n')
   }
   

3. A fájlban independent-identification.gocserélje le a elemet YourSubscriptionKey a Speech erőforráskulcsra, és cserélje le a helyére YourServiceRegion a Speech erőforrás-régiót.

   Fontos

   Ne felejtse el eltávolítani a kulcsot a kódból, amikor elkészült, és soha ne tegye közzé nyilvánosan. Éles környezetben biztonságos módon tárolhatja és érheti el a hitelesítő adatait, például az Azure Key Vault. További információért tekintse meg az Azure AI-szolgáltatások biztonsági cikkét.

Az alábbi parancsok futtatásával hozzon létre egy go.mod fájlt, amely a GitHubon üzemeltetett összetevőkre hivatkozik:

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

Most hozza létre és futtassa a kódot:

go build
go run independent-identification

Független ellenőrzés végrehajtása

Kövesse az alábbi lépéseket egy új GO-modul létrehozásához.

1. Nyisson meg egy parancssort, ahol az új modult szeretné, és hozzon létre egy új fájlt nevű independent-verification.gonéven.

2. Cserélje le a tartalmát independent-verification.go a következő kódra.

   package main
   
   import (
       "bufio"
       "fmt"
       "os"
       "time"
   
       "github.com/Microsoft/cognitive-services-speech-sdk-go/audio"
       "github.com/Microsoft/cognitive-services-speech-sdk-go/common"
       "github.com/Microsoft/cognitive-services-speech-sdk-go/speaker"
       "github.com/Microsoft/cognitive-services-speech-sdk-go/speech"
   )
   
   func GetNewVoiceProfileFromClient(client *speaker.VoiceProfileClient, expectedType common.VoiceProfileType) *speaker.VoiceProfile {
       future := client.CreateProfileAsync(expectedType, "en-US")
       outcome := <-future
       if outcome.Failed() {
           fmt.Println("Got an error creating profile: ", outcome.Error.Error())
           return nil
       }
       profile := outcome.Profile
       _, err := profile.Id()
       if err != nil {
           fmt.Println("Unexpected error creating profile id: ", err)
           return nil
       }
       profileType, err := profile.Type();
       if err != nil {
           fmt.Println("Unexpected error getting profile type: ", err)
           return nil
       }
       if profileType != expectedType {
           fmt.Println("Profile type does not match expected type")
           return nil
       }
       return profile
   }
   
   func EnrollProfile(client *speaker.VoiceProfileClient, profile *speaker.VoiceProfile, audioConfig *audio.AudioConfig) {
       enrollmentReason, currentReason := common.EnrollingVoiceProfile, common.EnrollingVoiceProfile
       var currentResult *speaker.VoiceProfileEnrollmentResult
       expectedEnrollmentCount := 1
       for currentReason == enrollmentReason {
           fmt.Println(`Please speak the following phrase: "I'll talk for a few seconds so you can recognize my voice in the future."`)
           enrollFuture := client.EnrollProfileAsync(profile, audioConfig)
           enrollOutcome := <-enrollFuture
           if enrollOutcome.Failed() {
               fmt.Println("Got an error enrolling profile: ", enrollOutcome.Error.Error())
               return
           }
           currentResult = enrollOutcome.Result
           currentReason = currentResult.Reason
           if currentResult.EnrollmentsCount != expectedEnrollmentCount {
               fmt.Println("Unexpected enrollments for profile: ", currentResult.RemainingEnrollmentsCount)
           }
           expectedEnrollmentCount += 1
       }
       if currentReason != common.EnrolledVoiceProfile {
           fmt.Println("Unexpected result enrolling profile: ", currentResult)
       }
   }
   
   func DeleteProfile(client *speaker.VoiceProfileClient, profile *speaker.VoiceProfile) {
       deleteFuture := client.DeleteProfileAsync(profile)
       deleteOutcome := <-deleteFuture
       if deleteOutcome.Failed() {
           fmt.Println("Got an error deleting profile: ", deleteOutcome.Error.Error())
           return
       }
       result := deleteOutcome.Result
       if result.Reason != common.DeletedVoiceProfile {
           fmt.Println("Unexpected result deleting profile: ", result)
       }
   }
   
   func main() {
       subscription :=  "YourSubscriptionKey"
       region := "YourServiceRegion"
       config, err := speech.NewSpeechConfigFromSubscription(subscription, region)
       if err != nil {
           fmt.Println("Got an error: ", err)
           return
       }
       defer config.Close()
       client, err := speaker.NewVoiceProfileClientFromConfig(config)
       if err != nil {
           fmt.Println("Got an error: ", err)
           return
       }
       defer client.Close()
       audioConfig, err := audio.NewAudioConfigFromDefaultMicrophoneInput()
       if err != nil {
           fmt.Println("Got an error: ", err)
           return
       }
       defer audioConfig.Close()
       <-time.After(10 * time.Second)
       expectedType := common.VoiceProfileType(3)
   
       profile := GetNewVoiceProfileFromClient(client, expectedType)
       if profile == nil {
           fmt.Println("Error creating profile")
           return
       }
       defer profile.Close()
   
       EnrollProfile(client, profile, audioConfig)
   
       model, err := speaker.NewSpeakerVerificationModelFromProfile(profile)
       if err != nil {
           fmt.Println("Error creating Verification model: ", err)
       }
       if model == nil {
           fmt.Println("Error creating Verification model: nil model")
           return
       }
       verifyAudioConfig, err := audio.NewAudioConfigFromDefaultMicrophoneInput()
       if err != nil {
           fmt.Println("Got an error: ", err)
           return
       }
       defer verifyAudioConfig.Close()
       speakerRecognizer, err := speaker.NewSpeakerRecognizerFromConfig(config, verifyAudioConfig)
       if err != nil {
           fmt.Println("Got an error: ", err)
           return
       }
       verifyFuture := speakerRecognizer.VerifyOnceAsync(model)
       verifyOutcome := <-verifyFuture
       if verifyOutcome.Failed() {
           fmt.Println("Got an error verifying profile: ", verifyOutcome.Error.Error())
           return
       }
       verifyResult := verifyOutcome.Result
       if verifyResult.Reason != common.RecognizedSpeaker {
           fmt.Println("Got an unexpected result verifying profile: ", verifyResult)
       }
       expectedID, _ := profile.Id()
       if verifyResult.ProfileID != expectedID {
           fmt.Println("Got an unexpected profile id verifying profile: ", verifyResult.ProfileID)
       }
       if verifyResult.Score < 1.0 {
           fmt.Println("Got an unexpected score verifying profile: ", verifyResult.Score)
       }
   
       DeleteProfile(client, profile)
       bufio.NewReader(os.Stdin).ReadBytes('\n')
   }
   

3. A fájlban independent-verification.gocserélje le a elemet YourSubscriptionKey a Speech erőforráskulcsra, és cserélje le a helyére YourServiceRegion a Speech erőforrás-régiót.

Az alábbi parancsok futtatásával hozzon létre egy go.mod fájlt, amely a GitHubon üzemeltetett összetevőkre hivatkozik:

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

Most hozza létre és futtassa a kódot:

go build
go run independent-verification

Az erőforrások eltávolítása

A Azure Portal vagy az Azure Parancssori felület (CLI) használatával eltávolíthatja a létrehozott Speech-erőforrást.

Referenciadokumentáció | További minták a GitHubon

A Java Speech SDK támogatja a beszélőfelismerést, de itt még nem tartalmaztunk útmutatót. Válasszon egy másik programozási nyelvet az első lépésekhez és a fogalmak megismeréséhez, vagy tekintse meg a cikk elején hivatkozott Java-referenciát és -mintákat.

Referenciadokumentáció | Csomag (npm) | További minták a GitHubon | Kódtár forráskódja

Ebben a rövid útmutatóban a Beszéd SDK használatával megismerheti a beszélőfelismerés alapvető tervezési mintáit, többek között a következőket:

• Szövegfüggő és szövegfüggetlen ellenőrzés.
• Beszélőazonosítás egy hangminta azonosításához a hangcsoportok között.
• Hangprofilok törlése.

A beszélőfelismerési fogalmakat az Áttekintés című cikkben tekintheti meg. A támogatott platformok listáját a bal oldali panel Referencia csomópontjában találja.

Fontos

A Microsoft korlátozza a beszélőfelismeréshez való hozzáférést. Alkalmazza a használatát az Azure AI Speaker Recognition Limited Access Review űrlapon. A jóváhagyás után hozzáférhet a Speaker Recognition API-khoz.

Előfeltételek

• Azure-előfizetés – Hozzon létre egyet ingyen.
• Beszéderőforrás létrehozása a Azure Portal.
• A Speech erőforráskulcsa és régiója. A Speech-erőforrás üzembe helyezése után válassza az Erőforrás megnyitása lehetőséget a kulcsok megtekintéséhez és kezeléséhez. További információ az Azure AI-szolgáltatások erőforrásairól: Az erőforrás kulcsainak lekérése.

A Speech SDK telepítése

A kezdés előtt telepítenie kell a JavaScripthez készült Speech SDK-t.

A célkörnyezettől függően használja az alábbiak egyikét:

Script

Töltse le és bontsa ki a Speech SDK for JavaScript microsoft.cognitiveservices.speech.sdk.bundle.js fájlt. Helyezze a HTML-fájlhoz elérhető mappába.

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

Tipp

Ha webböngészőt céloz meg, és a <script> címkét használja, nincs szükség az sdk előtagra. Az sdk előtag egy alias, amely a modul elnevezésére require szolgál.

Importálása

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

További információ: importExportálás és importálás.

Igényel

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

Függőségek importálása

A cikkben szereplő példák futtatásához adja hozzá a következő utasításokat a .js fájl tetején:

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

Ezek az utasítások importálják a szükséges kódtárakat, és lekérik a Speech-szolgáltatás előfizetési kulcsát és régióját a környezeti változókból. Emellett megadják a hangfájlok elérési útját is, amelyeket az alábbi feladatokban fog használni.

Fontos

Ne felejtse el eltávolítani a kulcsot a kódból, amikor elkészült, és soha ne tegye közzé nyilvánosan. Éles környezetben biztonságos módon tárolhatja és érheti el a hitelesítő adatait, például az Azure Key Vault. További információért tekintse meg az Azure AI-szolgáltatások biztonsági cikkét.

Segédfüggvény létrehozása

Adja hozzá a következő segédfüggvényt a hangfájlok streamekbe való olvasásához a Speech szolgáltatás számára:

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

Ebben a függvényben az AudioInputStream.createPushStream és az AudioConfig.fromStreamInput metódusokkal hozhat létre AudioConfig objektumot. Ez az AudioConfig objektum egy hangstreamet jelöl. A következő feladatok során több objektumot AudioConfig is használni fog.

Szövegfüggő ellenőrzés

A beszélő ellenőrzése annak ellenőrzésére szolgál, hogy egy beszélő egy ismert vagy regisztrált hangnak felel-e meg. Az első lépés egy hangprofil regisztrálása, hogy a szolgáltatás összehasonlíthassa a jövőbeli hangmintákat. Ebben a példában egy szövegfüggő stratégiával regisztrálja a profilt, amelyhez egy adott jelszó szükséges a regisztrációhoz és az ellenőrzéshez. A támogatott jelszókkal kapcsolatban tekintse meg a referenciadokumentumokat .

TextDependentVerification függvény

Először hozza létre a függvényt TextDependentVerification .

async function TextDependentVerification(client, speech_config)
{
    console.log ("Text Dependent Verification:\n");
    var profile = null;
    try {
        const type = sdk.VoiceProfileType.TextDependentVerification;
        // Create the profile.
        profile = await client.createProfileAsync(type, profile_locale);
        console.log ("Created profile ID: " + profile.profileId);
        // Get the activation phrases
        await GetActivationPhrases(type, profile_locale);
        await AddEnrollmentsToTextDependentProfile(client, profile, passphrase_files);
        const audio_config = GetAudioConfigFromFile(verify_file);
        const recognizer = new sdk.SpeakerRecognizer(speech_config, audio_config);
        await SpeakerVerify(profile, recognizer);
    }
    catch (error) {
        console.log ("Error:\n" + error);
    }
    finally {
        if (profile !== null) {
            console.log ("Deleting profile ID: " + profile.profileId);
            const deleteResult = await client.deleteProfileAsync (profile);
        }
    }
}

Ez a függvény létrehoz egy VoiceProfile objektumot a VoiceProfileClient.createProfileAsync metódussal. A következő három típus létezikVoiceProfile:

• TextIndependentIdentification
• TextDependentVerification
• TextIndependentVerification

Ebben az esetben a következőt adja meg VoiceProfileType.TextDependentVerification : VoiceProfileClient.createProfileAsync.

Ezután hívjon meg két segédfüggvényt, amelyeket a következőben definiálni fog: AddEnrollmentsToTextDependentProfile és SpeakerVerify. Végül hívja meg a VoiceProfileClient.deleteProfileAsync parancsot a profil eltávolításához.

AddEnrollmentsToTextDependentProfile függvény

A hangprofil regisztrálásához adja meg a következő függvényt:

async function AddEnrollmentsToTextDependentProfile(client, profile, audio_files)
{
    try {
        for (const file of audio_files) {
            console.log ("Adding enrollment to text dependent profile...");
            const audio_config = GetAudioConfigFromFile(file);
            const result = await client.enrollProfileAsync(profile, audio_config);
            if (result.reason === sdk.ResultReason.Canceled) {
                throw(JSON.stringify(sdk.VoiceProfileEnrollmentCancellationDetails.fromResult(result)));
            }
            else {
                console.log ("Remaining enrollments needed: " + result.privDetails["remainingEnrollmentsCount"] + ".");
            }
        };
        console.log ("Enrollment completed.\n");
    } catch (error) {
        console.log ("Error adding enrollments: " + error);
    }
}

Ebben a függvényben meghívja a GetAudioConfigFromFile korábban definiált függvényt, hogy hangmintákból hozzon létre AudioConfig objektumokat. Ezek a hangminták egy jelszót tartalmaznak, például "A hangom az útlevelem, ellenőrizzen". Ezután ezeket a hangmintákat a VoiceProfileClient.enrollProfileAsync metódussal regisztrálhatja.

SpeakerVerify függvény

Definiálja SpeakerVerify a következőket:

async function SpeakerVerify(profile, recognizer)
{
    try {
        const model = sdk.SpeakerVerificationModel.fromProfile(profile);
        const result = await recognizer.recognizeOnceAsync(model);
        console.log ("Verified voice profile for speaker: " + result.profileId + ". Score is: " + result.score + ".\n");
    } catch (error) {
        console.log ("Error verifying speaker: " + error);
    }
}

Ebben a függvényben egy SpeakerVerificationModel objektumot hoz létre a SpeakerVerificationModel.FromProfile metódussal, amely a korábban létrehozott VoiceProfile objektumot adja át.

Ezután meghívja a SpeechRecognizer.recognizeOnceAsync metódust egy olyan hangminta érvényesítéséhez, amely ugyanazt a jelszót tartalmazza, mint a korábban regisztrált hangminták. SpeechRecognizer.recognizeOnceAsync Egy SpeakerRecognitionResult objektumot ad vissza, amelynek score tulajdonsága 0,0 és 1,0 közötti hasonlósági pontszámot tartalmaz. Az SpeakerRecognitionResult objektum egy reasonResultReason típusú tulajdonságot is tartalmaz. Ha az ellenőrzés sikeres volt, a reason tulajdonságnak a következő értékkel RecognizedSpeakerkell rendelkeznie: .

Szövegfüggetlen ellenőrzés

A szövegfüggő ellenőrzéssel ellentétben a szövegfüggetlen ellenőrzés:

• Nincs szükség bizonyos jelszó kimondására. Bármit el lehet mondani.
• Nincs szükség három hangmintára, de összesen 20 másodpercnyi hangra van szükség.

TextIndependentVerification függvény

Először hozza létre a függvényt TextIndependentVerification .

async function TextIndependentVerification(client, speech_config)
{
    console.log ("Text Independent Verification:\n");
    var profile = null;
    try {
        const type = sdk.VoiceProfileType.TextIndependentVerification;
        // Create the profile.
        profile = await client.createProfileAsync(type, profile_locale);
        console.log ("Created profile ID: " + profile.profileId);
        // Get the activation phrases
        await GetActivationPhrases(type, profile_locale);
        await AddEnrollmentsToTextIndependentProfile(client, profile, [identify_file]);
        const audio_config = GetAudioConfigFromFile(passphrase_files[0]);
        const recognizer = new sdk.SpeakerRecognizer(speech_config, audio_config);
        await SpeakerVerify(profile, recognizer);
    }
    catch (error) {
        console.log ("Error:\n" + error);
    }
    finally {
        if (profile !== null) {
            console.log ("Deleting profile ID: " + profile.profileId);
            const deleteResult = await client.deleteProfileAsync (profile);
        }
    }
}

A függvényhez hasonlóan ez a TextDependentVerification függvény is létrehoz egy VoiceProfile objektumot a VoiceProfileClient.createProfileAsync metódussal.

Ebben az esetben a következőt adja meg VoiceProfileType.TextIndependentVerification : createProfileAsync.

Ezután két segédfüggvényt hívhat meg: AddEnrollmentsToTextIndependentProfile, amelyet a következőként fog definiálni, és SpeakerVerifyamelyet már definiált. Végül hívja meg a VoiceProfileClient.deleteProfileAsync parancsot a profil eltávolításához.

AddEnrollmentsToTextIndependentProfile

A hangprofil regisztrálásához adja meg a következő függvényt:

async function AddEnrollmentsToTextIndependentProfile(client, profile, audio_files)
{
    try {
        for (const file of audio_files) {
            console.log ("Adding enrollment to text independent profile...");
            const audio_config = GetAudioConfigFromFile(file);
            const result = await client.enrollProfileAsync (profile, audio_config);
            if (result.reason === sdk.ResultReason.Canceled) {
                throw(JSON.stringify(sdk.VoiceProfileEnrollmentCancellationDetails.fromResult(result)));
            }
            else {
                console.log ("Remaining audio time needed: " + (result.privDetails["remainingEnrollmentsSpeechLength"] / ticks_per_second) + " seconds.");
            }
        }
        console.log ("Enrollment completed.\n");
    } catch (error) {
        console.log ("Error adding enrollments: " + error);
    }
}

Ebben a függvényben meghívja a GetAudioConfigFromFile korábban definiált függvényt, hogy hangmintákból hozzon létre AudioConfig objektumokat. Ezután ezeket a hangmintákat a VoiceProfileClient.enrollProfileAsync metódussal regisztrálhatja.

Beszélőazonosítás

A beszélőazonosítással állapítható meg, hogy ki beszél egy adott regisztrált hangcsoportból. A folyamat hasonló a szövegfüggetlen ellenőrzéshez. A fő különbség az a képesség, hogy egyszerre több hangprofilon kell ellenőrizni ahelyett, hogy egyetlen profilon ellenőrizned kell.

TextIndependentIdentification függvény

Először hozza létre a függvényt TextIndependentIdentification .

async function TextIndependentIdentification(client, speech_config)
{
    console.log ("Text Independent Identification:\n");
    var profile = null;
    try {
        const type = sdk.VoiceProfileType.TextIndependentIdentification;
        // Create the profile.
        profile = await client.createProfileAsync(type, profile_locale);
        console.log ("Created profile ID: " + profile.profileId);
        // Get the activation phrases
        await GetActivationPhrases(type, profile_locale);
        await AddEnrollmentsToTextIndependentProfile(client, profile, [identify_file]);
        const audio_config = GetAudioConfigFromFile(passphrase_files[0]);
        const recognizer = new sdk.SpeakerRecognizer(speech_config, audio_config);
        await SpeakerIdentify(profile, recognizer);
    }
    catch (error) {
        console.log ("Error:\n" + error);
    }
    finally {
        if (profile !== null) {
            console.log ("Deleting profile ID: " + profile.profileId);
            const deleteResult = await client.deleteProfileAsync (profile);
        }
    }
}

A és TextIndependentVerification függvényekhez hasonlóan ez a TextDependentVerification függvény is létrehoz egy VoiceProfile objektumot a VoiceProfileClient.createProfileAsync metódussal.

Ebben az esetben a következőt adja meg VoiceProfileType.TextIndependentIdentification : VoiceProfileClient.createProfileAsync.

Ezután két segédfüggvényt hívhat meg: AddEnrollmentsToTextIndependentProfile, amelyet már definiált, és SpeakerIdentify, amelyet a következőként fog definiálni. Végül hívja meg a VoiceProfileClient.deleteProfileAsync parancsot a profil eltávolításához.

SpeakerIdentify függvény

A függvény meghatározása az SpeakerIdentify alábbiak szerint:

async function SpeakerIdentify(profile, recognizer)
{
    try {
        const model = sdk.SpeakerIdentificationModel.fromProfiles([profile]);
        const result = await recognizer.recognizeOnceAsync(model);
        console.log ("The most similar voice profile is: " + result.profileId + " with similarity score: " + result.score + ".\n");
    } catch (error) {
        console.log ("Error identifying speaker: " + error);
    }
}

Ebben a függvényben egy SpeakerIdentificationModel objektumot hoz létre a SpeakerIdentificationModel.fromProfiles metódussal, és átadja a korábban létrehozott VoiceProfile objektumot.

Ezután meghívja a SpeechRecognizer.recognizeOnceAsync metódust, és átad egy hangmintát. SpeechRecognizer.recognizeOnceAsync megpróbálja azonosítani a hangminta hangját a VoiceProfile létrehozásához SpeakerIdentificationModelhasznált objektumok alapján. Visszaad egy SpeakerRecognitionResult objektumot, amelynek profileId tulajdonsága azonosítja az egyezőt VoiceProfile, ha van ilyen, míg a score tulajdonság egy 0,0 és 1,0 közötti hasonlósági pontszámot tartalmaz.

Fő függvény

Végül definiálja a függvényt az main alábbiak szerint:

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

Ez a függvény létrehoz egy VoiceProfileClient objektumot, amely hangprofilok létrehozására, regisztrálására és törlésére szolgál. Ezután meghívja a korábban definiált függvényeket.

Referenciadokumentáció | Csomag (letöltés) | További minták a GitHubon

Az Objective-C-hez készült Speech SDK nem támogatja a beszélőfelismerést. Válasszon egy másik programozási nyelvet vagy az Objective-C referenciát és a cikk elejéről csatolt mintákat.

Referenciadokumentáció | Csomag (letöltés) | További minták a GitHubon

A Speech SDK for Swift nem támogatja a beszélőfelismerést. Válasszon egy másik programozási nyelvet vagy a Swift-referenciát és a cikk elején hivatkozott mintákat.

Referenciadokumentáció | Csomag (PyPi) | További minták a GitHubon

A PythonHoz készült Speech SDK nem támogatja a beszélőfelismerést. Válasszon egy másik programozási nyelvet, vagy a Cikk elején hivatkozott Python-referenciát és mintákat.

Beszédfelismerés – REST API-referencia | Beszéd szöveggé REST API rövid hanghivatkozáshoz | További minták a GitHubon

Ebben a rövid útmutatóban a Beszéd SDK használatával megismerheti a beszélőfelismerés alapvető tervezési mintáit, többek között a következőket:

• Szövegfüggő és szövegfüggetlen ellenőrzés.
• Beszélőazonosítás egy hangminta azonosításához a hangcsoportok között.
• Hangprofilok törlése.

A beszélőfelismerési fogalmakat az Áttekintés című cikkben tekintheti meg. A támogatott platformok listáját a bal oldali panel Referencia csomópontjában találja.

Fontos

A Microsoft korlátozza a beszélőfelismeréshez való hozzáférést. Alkalmazza a használatát az Azure AI Speaker Recognition Limited Access Review űrlapon. A jóváhagyás után hozzáférhet a Speaker Recognition API-khoz.

Előfeltételek

• Azure-előfizetés – Hozzon létre egyet ingyen.
• Beszéderőforrás létrehozása a Azure Portal.
• A Speech erőforráskulcsa és régiója. A Speech-erőforrás üzembe helyezése után válassza az Erőforrás megnyitása lehetőséget a kulcsok megtekintéséhez és kezeléséhez. További információ az Azure AI-szolgáltatások erőforrásairól: Az erőforrás kulcsainak lekérése.

Szövegfüggő ellenőrzés

A beszélő ellenőrzése annak ellenőrzésére szolgál, hogy egy beszélő egy ismert vagy regisztrált hangnak felel-e meg. Az első lépés egy hangprofil regisztrálása, hogy a szolgáltatás összehasonlíthassa a jövőbeli hangmintákat. Ebben a példában egy szövegfüggő stratégiával regisztrálja a profilt, amelyhez egy adott jelszó szükséges a regisztrációhoz és az ellenőrzéshez. A támogatott jelszókkal kapcsolatban tekintse meg a referenciadokumentumokat .

Először hozzon létre egy hangprofilt. Be kell szúrnia a Speech szolgáltatás előfizetési kulcsát és régióját a jelen cikk összes curl-parancsába.

Fontos

Ne felejtse el eltávolítani a kulcsot a kódból, amikor elkészült, és soha ne tegye közzé nyilvánosan. Éles környezetben biztonságos módon tárolhatja és érheti el a hitelesítő adatait, például az Azure Key Vault. További információért tekintse meg az Azure AI-szolgáltatások biztonsági cikkét.

# Note Change locale if needed.
curl --location --request POST 'INSERT_ENDPOINT_HERE/speaker-recognition/verification/text-dependent/profiles?api-version=2021-09-05' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE' \
--header 'Content-Type: application/json' \
--data-raw '{
    '\''locale'\'':'\''en-us'\''
}'

A hangprofilnak három típusa van:

• Szövegfüggő ellenőrzés
• Szövegfüggetlen ellenőrzés
• Szövegfüggetlen azonosítás

Ebben az esetben létre kell hoznia egy szövegfüggő ellenőrző hangprofilt. A következő választ kell kapnia:

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

Ezután regisztrálja a hangprofilt. --data-binary A paraméterértékhez adjon meg egy hangfájlt a számítógépen, amely tartalmazza a támogatott jelszavak egyikét, például: "A hangom az útlevelem, ellenőrizzen". Hangfájlokat rögzíthet egy alkalmazással, például Windows Diktafon. Vagy létrehozhatja szövegfelolvasással is.

curl --location --request POST 'INSERT_ENDPOINT_HERE/speaker-recognition/verification/text-dependent/profiles/INSERT_PROFILE_ID_HERE/enrollments?api-version=2021-09-05' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE' \
--header 'Content-Type: audio/wav' \
--data-binary @'INSERT_FILE_PATH_HERE'

A következő választ kell kapnia:

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

Ez a válasz azt jelzi, hogy további két hangmintát kell regisztrálnia.

Miután összesen három hangmintát regisztrált, a következő választ kell kapnia:

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

Most már készen áll arra, hogy ellenőrizze a hangmintát a hangprofilon. Ennek a hangmintának ugyanazt a jelszót kell tartalmaznia, mint a hangprofil regisztrálásához használt mintáknak.

curl --location --request POST 'INSERT_ENDPOINT_HERE/speaker-recognition/verification/text-dependent/profiles/INSERT_PROFILE_ID_HERE:verify?api-version=2021-09-05' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE' \
--header 'Content-Type: audio/wav' \
--data-binary @'INSERT_FILE_PATH_HERE'

A következő választ kell kapnia:

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

Accept azt jelenti, hogy a jelszó megfelelt, és az ellenőrzés sikeres volt. A válasz egy 0,0 és 1,0 közötti hasonlósági pontszámot is tartalmaz.

A befejezéshez törölje a hangprofilt.

curl --location --request DELETE \
'INSERT_ENDPOINT_HERE/speaker-recognition/verification/text-dependent/profiles/INSERT_PROFILE_ID_HERE?api-version=2021-09-05' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE'

Nincs válasz.

Szövegfüggetlen ellenőrzés

A szövegfüggő ellenőrzéssel ellentétben a szövegfüggetlen ellenőrzés:

• Nincs szükség bizonyos jelszó kimondására. Bármit el lehet mondani.
• Nincs szükség három hangmintára, de összesen 20 másodpercnyi hangra van szükség.

Először hozzon létre egy szövegfüggetlen ellenőrzési profilt.

curl --location --request POST 'INSERT_ENDPOINT_HERE/speaker-recognition/verification/text-independent/profiles?api-version=2021-09-05' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE' \
--header 'Content-Type: application/json' \
--data-raw '{
    '\''locale'\'':'\''en-us'\''
}'

A következő választ kell kapnia:

{
    "profileStatus": "Inactive",
    "remainingEnrollmentsSpeechLength": 20.0,
    "profileId": "3f85dca9-ffc9-4011-bf21-37fad2beb4d2",
    "locale": "en-us",
    "enrollmentStatus": "Enrolling",
    "createdDateTime": "2020-09-29T16:08:52.409Z",
    "lastUpdatedDateTime": null,
    "enrollmentsCount": 0,
    "enrollmentsLength": 0.0,
    "enrollmentSpeechLength": 0.0
    "modelVersion": null,
}

Ezután regisztrálja a hangprofilt. Ismét három hangminta beküldése helyett olyan hangmintákat kell beküldenie, amelyek összesen 20 másodpercnyi hanganyagot tartalmaznak.

curl --location --request POST 'INSERT_ENDPOINT_HERE/speaker-recognition/verification/text-independent/profiles/INSERT_PROFILE_ID_HERE/enrollments?api-version=2021-09-05' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE' \
--header 'Content-Type: audio/wav' \
--data-binary @'INSERT_FILE_PATH_HERE'

Miután elegendő hangmintát küldött be, a következő választ kell kapnia:

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

Most már készen áll arra, hogy ellenőrizze a hangmintát a hangprofilon. Ennek a hangmintának ismét nem kell jelszót tartalmaznia. Bármilyen beszédet tartalmazhat, de összesen legalább négy másodpercnyi hanganyagot kell tartalmaznia.

curl --location --request POST 'INSERT_ENDPOINT_HERE/speaker-recognition/verification/text-independent/profiles/INSERT_PROFILE_ID_HERE:verify?api-version=2021-09-05' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE' \
--header 'Content-Type: audio/wav' \
--data-binary @'INSERT_FILE_PATH_HERE'

A következő választ kell kapnia:

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

Accept azt jelenti, hogy az ellenőrzés sikeres volt. A válasz egy 0,0 és 1,0 közötti hasonlósági pontszámot is tartalmaz.

A befejezéshez törölje a hangprofilt.

curl --location --request DELETE 'INSERT_ENDPOINT_HERE/speaker-recognition/verification/text-independent/profiles/INSERT_PROFILE_ID_HERE?api-version=2021-09-05' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE'

Nincs válasz.

Beszélőazonosítás

A beszélőazonosítással állapítható meg, hogy ki beszél egy adott regisztrált hangcsoportból. A folyamat hasonló a szövegfüggetlen ellenőrzéshez. A fő különbség az a képesség, hogy egyszerre több hangprofilon kell ellenőrizni ahelyett, hogy egyetlen profilon ellenőrizned kell.

Először hozzon létre egy szövegfüggetlen azonosítási profilt.

# Note Change locale if needed.
curl --location --request POST 'INSERT_ENDPOINT_HERE/speaker-recognition/identification/text-independent/profiles?api-version=2021-09-05' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE' \
--header 'Content-Type: application/json' \
--data-raw '{
    '\''locale'\'':'\''en-us'\''
}'

A következő választ kell kapnia:

{
    "profileStatus": "Inactive",
    "remainingEnrollmentsSpeechLengthInSec": 20.0,
    "profileId": "de99ab38-36c8-4b82-b137-510907c61fe8",
    "locale": "en-us",
    "enrollmentStatus": "Enrolling",
    "createdDateTime": "2020-09-22T17:25:48.642Z",
    "lastUpdatedDateTime": null,
    "enrollmentsCount": 0,
    "enrollmentsLengthInSec": 0.0,
    "enrollmentsSpeechLengthInSec": 0.0,
    "modelVersion": null
}

Ezután regisztrálja a hangprofilt. Ismét el kell küldenie a hangmintákat, amelyek összesen 20 másodpercnyi hangot tartalmaznak. Ezeknek a mintáknak nem kell jelszót tartalmazniuk.

curl --location --request POST 'INSERT_ENDPOINT_HERE/speaker-recognition/identification/text-independent/profiles/INSERT_PROFILE_ID_HERE/enrollments?api-version=2021-09-05' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE' \
--header 'Content-Type: audio/wav' \
--data-binary @'INSERT_FILE_PATH_HERE'

Miután elegendő hangmintát küldött be, a következő választ kell kapnia:

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

Most már készen áll egy hangminta azonosítására a hangprofil használatával. Az azonosító parancs elfogadja a lehetséges hangprofil-azonosítók vesszővel tagolt listáját. Ebben az esetben a korábban létrehozott hangprofil azonosítóját adja meg. Ha szeretné, több hangprofil-azonosítót is megadhat, ahol minden hangprofilt más hangmintákkal regisztrálnak.

# Profile ids comma seperated list
curl --location --request POST 'INSERT_ENDPOINT_HERE/speaker-recognition/identification/text-independent/profiles:identifySingleSpeaker?api-version=2021-09-05&profileIds=INSERT_PROFILE_ID_HERE' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE' \
--header 'Content-Type: audio/wav' \
--data-binary @'INSERT_FILE_PATH_HERE'

A következő választ kell kapnia:

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

A válasz tartalmazza annak a hangprofilnak az azonosítóját, amely a leginkább megfelel a beküldött hangmintának. Emellett tartalmazza a jelölt hangprofilok listáját is, a hasonlóság sorrendjében rangsorolva.

A befejezéshez törölje a hangprofilt.

curl --location --request DELETE \
'INSERT_ENDPOINT_HERE/speaker-recognition/identification/text-independent/profiles/INSERT_PROFILE_ID_HERE?api-version=2021-09-05' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE'

Nincs válasz.

A Speech CLI támogatja a beszélőfelismerést, de itt még nem tartalmaztunk útmutatót. Válasszon egy másik programozási nyelvet az első lépésekhez és a fogalmak megismeréséhez.

Következő lépések

Tekintse meg a GitHub gyorsútmutató-mintáit