Szybki start: rozpoznawanie i weryfikowanie, kto mówi

  • Artykuł

Dokumentacja referencyjna | Pakiet (NuGet) | Dodatkowe przykłady w usłudze GitHub

W tym przewodniku Szybki start poznasz podstawowe wzorce projektowania rozpoznawania osoby mówiącej przy użyciu zestawu Speech SDK, w tym:

  • Weryfikacja zależna od tekstu i niezależna od tekstu.
  • Identyfikacja osoby mówiącej w celu zidentyfikowania próbki głosu wśród grupy głosów.
  • Usuwanie profilów głosowych.

Aby zapoznać się z ogólnymi pojęciami dotyczącymi rozpoznawania osoby mówiącej, zobacz artykuł Przegląd . Aby uzyskać listę obsługiwanych platform, zobacz węzeł Odwołanie w okienku po lewej stronie.

Ważne

Firma Microsoft ogranicza dostęp do rozpoznawania osoby mówiącej. Zastosuj, aby używać go za pośrednictwem formularza przeglądu ograniczonego dostępu rozpoznawania osoby mówiącej platformy Azure . Po zatwierdzeniu możesz uzyskać dostęp do interfejsów API rozpoznawania osoby mówiącej.

Wymagania wstępne

  • Subskrypcja platformy Azure — utwórz je bezpłatnie.
  • w Azure Portal.
  • Klucz zasobu usługi Mowa i region. Po wdrożeniu zasobu usługi Mowa wybierz pozycję Przejdź do zasobu , aby wyświetlić klucze i zarządzać nimi. Aby uzyskać więcej informacji na temat zasobów usług Azure AI, zobacz Pobieranie kluczy dla zasobu.

Instalowanie zestawu SDK usługi Mowa

Przed rozpoczęciem należy zainstalować zestaw SPEECH SDK. W zależności od platformy wykonaj następujące instrukcje:

Importowanie zależności

Aby uruchomić przykłady w tym artykule, dołącz następujące using instrukcje w górnej części skryptu:

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

Tworzenie konfiguracji mowy

Aby wywołać usługę rozpoznawania mowy przy użyciu zestawu SPEECH SDK, należy utworzyć SpeechConfig wystąpienie. W tym przykładzie utworzysz SpeechConfig wystąpienie przy użyciu klucza subskrypcji i regionu. Utworzysz również podstawowy kod kociołowy do użycia w pozostałej części tego artykułu, który został zmodyfikowany dla różnych dostosowań.

Ważne

Pamiętaj, aby usunąć klucz z kodu po zakończeniu i nigdy nie publikować go publicznie. W przypadku środowiska produkcyjnego użyj bezpiecznego sposobu przechowywania i uzyskiwania dostępu do poświadczeń, takich jak Azure Key Vault. Aby uzyskać więcej informacji, zobacz artykuł Dotyczący zabezpieczeń usług Azure AI.

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

Weryfikacja zależna od tekstu

Weryfikacja osoby mówiącej jest aktem potwierdzenia, że głośnik pasuje do znanego lub zarejestrowanego głosu. Pierwszym krokiem jest zarejestrowanie profilu głosowego w taki sposób, aby usługa mogła porównać przyszłe próbki głosu. W tym przykładzie zarejestrujesz profil przy użyciu strategii zależnej od tekstu , która wymaga określonego hasła do użycia na potrzeby rejestracji i weryfikacji. Zapoznaj się z dokumentacją referencyjną , aby uzyskać listę obsługiwanych haseł.

Zacznij od utworzenia następującej funkcji w klasie, Program aby zarejestrować profil głosowy:

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

W tej funkcji jest to, await client.CreateProfileAsync() co w rzeczywistości tworzy nowy profil głosowy. Po utworzeniu określ sposób wprowadzania przykładów dźwiękowych przy użyciu AudioConfig.FromDefaultMicrophoneInput() w tym przykładzie do przechwytywania dźwięku z domyślnego urządzenia wejściowego. Następnie rejestrujesz przykłady audio w while pętli, która śledzi liczbę pozostałych próbek i które są wymagane do rejestracji. W każdej iteracji client.EnrollProfileAsync(profile, audioInput) monituje o wypowiadanie hasła do mikrofonu i dodanie przykładu do profilu głosowego.

Po zakończeniu rejestracji wywołaj metodę await SpeakerVerify(config, profile, profileMapping) , aby zweryfikować utworzony profil. Dodaj inną funkcję, aby zdefiniować SpeakerVerifyelement .

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

W tej funkcji przekazujesz VoiceProfile właśnie utworzony obiekt, aby zainicjować model w celu zweryfikowania. await speakerRecognizer.RecognizeOnceAsync(model) Następnie monituje o ponowne wypowiadanie hasła. Tym razem weryfikuje go względem profilu głosowego i zwraca wynik podobieństwa, który waha się od 0,0 do 1,0. Obiekt result zwraca Accept również wartość lub Reject, na podstawie tego, czy hasło jest zgodne.

Następnie zmodyfikuj Main() funkcję, aby wywołać utworzone nowe funkcje. Należy również pamiętać, że utworzysz element do Dictionary<string, string> przekazywania przez odwołanie za pośrednictwem wywołań funkcji. Przyczyną tego jest to, że usługa nie zezwala na przechowywanie nazwy czytelnej dla człowieka za pomocą utworzonej VoiceProfilenazwy i przechowuje tylko numer identyfikacyjny do celów prywatności. VerificationEnroll W funkcji dodasz do tego słownika wpis o nowo utworzonym identyfikatorze wraz z nazwą tekstową. W scenariuszach tworzenia aplikacji, w których musisz wyświetlić nazwę czytelną dla człowieka, musisz przechowywać to mapowanie gdzieś, ponieważ usługa nie może go przechowywać.

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

Uruchom skrypt. Zostanie wyświetlony monit o wyrażenie "Mój głos jest moim paszportem, zweryfikuj mnie" trzy razy na rejestrację i jeszcze raz na weryfikację. Zwrócony wynik to wynik podobieństwa, którego można użyć do utworzenia własnych progów niestandardowych na potrzeby weryfikacji.

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

Weryfikacja niezależna od tekstu

W przeciwieństwie do weryfikacji zależnej od tekstu weryfikacja niezależna od tekstu nie wymaga trzech próbek dźwiękowych, ale wymaga 20 sekund całkowitej ilości dźwięku.

Wprowadź kilka prostych zmian w funkcji, VerificationEnroll aby przełączyć się na weryfikację niezależną od tekstu . Najpierw należy zmienić typ weryfikacji na VoiceProfileType.TextIndependentVerification. Następnie zmień pętlę while , aby śledzić result.RemainingEnrollmentsSpeechLength, co będzie nadal monitować o mówienie do 20 sekund dźwięku zostało przechwycone.

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

Uruchom ponownie program i zwracany jest wynik podobieństwa.

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

Identyfikacja osoby mówiącej

Identyfikacja osoby mówiącej służy do określania , kto mówi z danej grupy zarejestrowanych głosów. Proces jest podobny do weryfikacji niezależnej od tekstu. Główną różnicą jest możliwość weryfikacji pod kątem wielu profilów głosowych jednocześnie, a nie weryfikacji względem jednego profilu.

Utwórz funkcję IdentificationEnroll do rejestrowania wielu profilów głosowych. Proces rejestracji dla każdego profilu jest taki sam jak proces rejestracji na potrzeby weryfikacji niezależnej od tekstu. Proces wymaga 20 sekund dźwięku dla każdego profilu. Ta funkcja akceptuje listę ciągów profileNames i utworzy nowy profil głosowy dla każdej nazwy na liście. Funkcja zwraca listę VoiceProfile obiektów, które są używane w następnej funkcji do identyfikowania osoby mówiącej.

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

Utwórz następującą funkcję SpeakerIdentification , aby przesłać żądanie identyfikacji. Główną różnicą w tej funkcji w porównaniu z żądaniem weryfikacji osoby mówiącej jest użycie SpeakerIdentificationModel.FromProfiles()metody , która akceptuje listę VoiceProfile obiektów.

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

Main() Zmień funkcję na następującą. Utworzysz listę ciągów profileNames, które są przekazywane do IdentificationEnroll() funkcji. Zostanie wyświetlony monit o utworzenie nowego profilu głosowego dla każdej nazwy na tej liście, aby dodać więcej nazw, aby utworzyć więcej profilów dla znajomych lub współpracowników.

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

Uruchom skrypt. Zostanie wyświetlony monit o rozmowę z rejestracją przykładów głosowych dla pierwszego profilu. Po zakończeniu rejestracji zostanie wyświetlony monit o powtórzenie tego procesu dla każdej nazwy na profileNames liście. Po zakończeniu każdej rejestracji zostanie wyświetlony monit o rozmowę z nikim . Następnie usługa próbuje zidentyfikować tę osobę z poziomu zarejestrowanych profilów głosowych.

Ten przykład zwraca tylko najbliższe dopasowanie i jego wynik podobieństwa. Aby uzyskać pełną odpowiedź zawierającą pięć pierwszych wyników podobieństwa, dodaj string json = result.Properties.GetProperty(PropertyId.SpeechServiceResponse_JsonResult) do SpeakerIdentification funkcji.

Zmiana typu wejścia audio

Przykłady w tym artykule używają domyślnego mikrofonu urządzenia jako danych wejściowych dla przykładów audio. W scenariuszach, w których musisz używać plików audio zamiast danych wejściowych mikrofonu, zmień dowolne wystąpienie, AudioConfig.FromDefaultMicrophoneInput() aby AudioConfig.FromWavFileInput(path/to/your/file.wav) przełączyć się na dane wejściowe pliku. Możesz również mieć mieszane dane wejściowe przy użyciu mikrofonu do rejestracji i plików na potrzeby weryfikacji, na przykład.

Usuwanie rejestracji profilów głosowych

Aby usunąć zarejestrowany profil, użyj DeleteProfileAsync() funkcji w VoiceProfileClient obiekcie . W poniższej przykładowej funkcji pokazano, jak usunąć profil głosowy ze znanego identyfikatora profilu głosowego:

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

Dokumentacja referencyjna | Pakiet (NuGet) | Dodatkowe przykłady w usłudze GitHub

W tym przewodniku Szybki start poznasz podstawowe wzorce projektowania rozpoznawania osoby mówiącej przy użyciu zestawu Speech SDK, w tym:

  • Weryfikacja zależna od tekstu i niezależna od tekstu.
  • Identyfikacja osoby mówiącej w celu zidentyfikowania próbki głosu wśród grupy głosów.
  • Usuwanie profilów głosowych.

Aby zapoznać się z ogólnymi pojęciami dotyczącymi rozpoznawania osoby mówiącej, zobacz artykuł Przegląd . Aby uzyskać listę obsługiwanych platform, zobacz węzeł Odwołanie w okienku po lewej stronie.

Ważne

Firma Microsoft ogranicza dostęp do rozpoznawania osoby mówiącej. Zastosuj, aby używać go za pośrednictwem formularza przeglądu ograniczonego dostępu rozpoznawania osoby mówiącej platformy Azure . Po zatwierdzeniu możesz uzyskać dostęp do interfejsów API rozpoznawania osoby mówiącej.

Wymagania wstępne

  • Subskrypcja platformy Azure — utwórz je bezpłatnie.
  • w Azure Portal.
  • Klucz zasobu usługi Mowa i region. Po wdrożeniu zasobu usługi Mowa wybierz pozycję Przejdź do zasobu , aby wyświetlić klucze i zarządzać nimi. Aby uzyskać więcej informacji na temat zasobów usług Azure AI, zobacz Pobieranie kluczy dla zasobu.

Instalowanie zestawu SDK usługi Mowa

Przed rozpoczęciem należy zainstalować zestaw SPEECH SDK. W zależności od platformy wykonaj następujące instrukcje:

Importowanie zależności

Aby uruchomić przykłady w tym artykule, dodaj następujące instrukcje w górnej części pliku cpp:

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

Tworzenie konfiguracji mowy

Aby wywołać usługę rozpoznawania mowy przy użyciu zestawu SPEECH SDK, utwórz klasę SpeechConfig . Ta klasa zawiera informacje o subskrypcji, takie jak klucz i skojarzony region, punkt końcowy, host lub token autoryzacji.

Ważne

Pamiętaj, aby usunąć klucz z kodu po zakończeniu i nigdy nie publikować go publicznie. W przypadku środowiska produkcyjnego użyj bezpiecznego sposobu przechowywania i uzyskiwania dostępu do poświadczeń, takich jak Azure Key Vault. Aby uzyskać więcej informacji, zobacz artykuł Dotyczący zabezpieczeń usług Azure AI.

shared_ptr<SpeechConfig> GetSpeechConfig()
{
    auto subscription_key = 'PASTE_YOUR_SPEECH_SUBSCRIPTION_KEY_HERE';
    auto region = 'PASTE_YOUR_SPEECH_ENDPOINT_REGION_HERE';
    auto config = SpeechConfig::FromSubscription(subscription_key, region);
    return config;
}

Weryfikacja zależna od tekstu

Weryfikacja osoby mówiącej jest aktem potwierdzenia, że głośnik pasuje do znanego lub zarejestrowanego głosu. Pierwszym krokiem jest zarejestrowanie profilu głosowego w taki sposób, aby usługa mogła porównać przyszłe próbki głosu. W tym przykładzie zarejestrujesz profil przy użyciu strategii zależnej od tekstu , która wymaga określonego hasła do użycia na potrzeby rejestracji i weryfikacji. Zapoznaj się z dokumentacją referencyjną , aby uzyskać listę obsługiwanych haseł.

TextDependentVerification, funkcja

Zacznij od utworzenia TextDependentVerification funkcji:

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

Ta funkcja tworzy obiekt VoiceProfile za pomocą metody CreateProfileAsync . Istnieją trzy typy:VoiceProfile

  • TextIndependentIdentIdentification
  • TextDependentVerification
  • TextIndependentVerification

W takim przypadku przekazujesz VoiceProfileType::TextDependentVerification do CreateProfileAsyncelementu .

Następnie wywołasz dwie funkcje pomocnicze, które zdefiniujesz w następnej kolejności, AddEnrollmentsToTextDependentProfile i SpeakerVerify. Na koniec wywołaj metodę DeleteProfileAsync , aby wyczyścić profil.

AddEnrollmentsToTextDependentProfile, funkcja

Zdefiniuj następującą funkcję, aby zarejestrować profil głosowy:

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

W tej funkcji rejestrujesz przykłady audio w while pętli, która śledzi liczbę pozostałych próbek i które są wymagane do rejestracji. W każdej iteracji funkcja EnrollProfileAsync monituje o wypowiadanie hasła do mikrofonu i dodaje przykład do profilu głosowego.

SpeakerVerify, funkcja

Zdefiniuj SpeakerVerify w następujący sposób:

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

W tej funkcji utworzysz obiekt SpeakerVerificationModel za pomocą metody SpeakerVerificationModel::FromProfile , przekazując utworzony wcześniej obiekt VoiceProfile .

Następnie speechRecognizer::RecognizeOnceAsync monituje o ponowne wypowiadanie hasła. Tym razem weryfikuje go względem profilu głosowego i zwraca wynik podobieństwa, który waha się od 0,0 do 1,0. Obiekt SpeakerRecognitionResult zwraca Accept również lub Reject na podstawie tego, czy hasło pasuje.

Weryfikacja niezależna od tekstu

W przeciwieństwie do weryfikacji zależnej od tekstu weryfikacja niezależna od tekstu nie wymaga trzech próbek dźwiękowych, ale wymaga 20 sekund całkowitej ilości dźwięku.

TextIndependentVerification, funkcja

Zacznij od utworzenia TextIndependentVerification funkcji:

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

Podobnie jak w przypadku TextDependentVerification funkcji, ta funkcja tworzy obiekt VoiceProfile za pomocą metody CreateProfileAsync .

W takim przypadku przekazujesz VoiceProfileType::TextIndependentVerification do CreateProfileAsyncelementu .

Następnie wywołasz dwie funkcje pomocnicze: AddEnrollmentsToTextIndependentProfile, którą zdefiniujesz w następnej kolejności, i SpeakerVerify, które zostały już zdefiniowane. Na koniec wywołaj metodę DeleteProfileAsync , aby wyczyścić profil.

AddEnrollmentsToTextIndependentProfile

Zdefiniuj następującą funkcję, aby zarejestrować profil głosowy:

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

W tej funkcji rejestrujesz przykłady audio w while pętli, która śledzi liczbę sekund pozostałych audio i które są wymagane do rejestracji. W każdej iteracji funkcja EnrollProfileAsync monituje o wypowiadanie się w mikrofonie i dodaje przykład do profilu głosowego.

Identyfikacja osoby mówiącej

Identyfikacja osoby mówiącej służy do określania , kto mówi z danej grupy zarejestrowanych głosów. Proces jest podobny do weryfikacji niezależnej od tekstu. Główną różnicą jest możliwość weryfikacji pod kątem wielu profilów głosowych jednocześnie, a nie weryfikacji względem jednego profilu.

TextIndependentIdentIdentification, funkcja

Zacznij od utworzenia TextIndependentIdentification funkcji:

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

Podobnie jak w przypadku TextDependentVerification funkcji i TextIndependentVerification , ta funkcja tworzy obiekt VoiceProfile za pomocą metody CreateProfileAsync .

W takim przypadku przekazujesz VoiceProfileType::TextIndependentIdentification do CreateProfileAsyncelementu .

Następnie wywołasz dwie funkcje pomocnicze: AddEnrollmentsToTextIndependentProfile, która została już zdefiniowana, i SpeakerIdentify, którą zdefiniujesz w następnej kolejności. Na koniec wywołaj metodę DeleteProfileAsync , aby wyczyścić profil.

SpeakerIdentify, funkcja

Zdefiniuj SpeakerIdentify funkcję w następujący sposób:

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

W tej funkcji utworzysz obiekt SpeakerIdentificationModel za pomocą metody SpeakerIdentificationModel::FromProfiles. SpeakerIdentificationModel::FromProfiles akceptuje listę obiektów VoiceProfile . W takim przypadku przekazujesz VoiceProfile utworzony wcześniej obiekt. Jeśli chcesz, możesz przekazać wiele VoiceProfile obiektów, z których każda została zarejestrowana przy użyciu przykładów dźwiękowych z innego głosu.

Następnie funkcja SpeechRecognizer::RecognizeOnceAsync monituje o ponowne wypowiadanie. Tym razem porównuje twój głos z zarejestrowanymi profilami głosowymi i zwraca najbardziej podobny profil głosowy.

Main, funkcja

Na koniec zdefiniuj main funkcję w następujący sposób:

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

Ta funkcja wywołuje zdefiniowane wcześniej funkcje. Najpierw tworzy obiekt VoiceProfileClient i obiekt SpeakerRecognizer .

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

Obiekt VoiceProfileClient służy do tworzenia, rejestrowania i usuwania profilów głosowych. Obiekt SpeakerRecognizer służy do weryfikowania przykładów mowy względem co najmniej jednego zarejestrowanego profilu głosowego.

Zmiana typu wejścia audio

Przykłady w tym artykule używają domyślnego mikrofonu urządzenia jako danych wejściowych dla przykładów audio. W scenariuszach, w których należy używać plików audio zamiast wejścia mikrofonu, zmień następujący wiersz:

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

na:

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

Ewentualnie zastąp dowolne użycie audio_config elementu Audio::AudioConfig::FromWavFileInput. Możesz również mieć mieszane dane wejściowe przy użyciu mikrofonu do rejestracji i plików na potrzeby weryfikacji, na przykład.

Dokumentacja referencyjna | Pakiet (Go) | Dodatkowe przykłady w usłudze GitHub

W tym przewodniku Szybki start poznasz podstawowe wzorce projektowania rozpoznawania osoby mówiącej przy użyciu zestawu Speech SDK, w tym:

  • Weryfikacja zależna od tekstu i niezależna od tekstu.
  • Identyfikacja osoby mówiącej w celu zidentyfikowania próbki głosu wśród grupy głosów.
  • Usuwanie profilów głosowych.

Aby zapoznać się z ogólnymi pojęciami dotyczącymi rozpoznawania osoby mówiącej, zobacz artykuł Przegląd . Aby uzyskać listę obsługiwanych platform, zobacz węzeł Odwołanie w okienku po lewej stronie.

Ważne

Firma Microsoft ogranicza dostęp do rozpoznawania osoby mówiącej. Zastosuj, aby używać go za pośrednictwem formularza przeglądu ograniczonego dostępu rozpoznawania osoby mówiącej platformy Azure . Po zatwierdzeniu możesz uzyskać dostęp do interfejsów API rozpoznawania osoby mówiącej.

Wymagania wstępne

  • Subskrypcja platformy Azure — utwórz je bezpłatnie.
  • w Azure Portal.
  • Klucz zasobu usługi Mowa i region. Po wdrożeniu zasobu usługi Mowa wybierz pozycję Przejdź do zasobu , aby wyświetlić klucze i zarządzać nimi. Aby uzyskać więcej informacji na temat zasobów usług Azure AI, zobacz Pobieranie kluczy dla zasobu.

Konfigurowanie środowiska

Zainstaluj zestaw SPEECH SDK dla języka Go. Zapoznaj się z przewodnikiem instalacji zestawu SDK , aby uzyskać więcej wymagań

Wykonywanie niezależnej identyfikacji

Wykonaj następujące kroki, aby utworzyć nowy moduł GO.

  1. Otwórz wiersz polecenia, w którym chcesz utworzyć nowy moduł, a następnie utwórz nowy plik o nazwie independent-identification.go.

  2. Zastąp zawartość independent-identification.go poniższym kodem.

    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. W independent-identification.gopliku zastąp YourSubscriptionKey ciąg kluczem zasobu usługi Mowa i zastąp element YourServiceRegion regionem zasobu usługi Mowa.

    Ważne

    Pamiętaj, aby usunąć klucz z kodu po zakończeniu i nigdy nie publikować go publicznie. W przypadku środowiska produkcyjnego użyj bezpiecznego sposobu przechowywania i uzyskiwania dostępu do poświadczeń, takich jak Azure Key Vault. Aby uzyskać więcej informacji, zobacz artykuł Dotyczący zabezpieczeń usług Azure AI.

Uruchom następujące polecenia, aby utworzyć go.mod plik, który łączy się z składnikami hostowanymi w usłudze GitHub:

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

Teraz skompiluj i uruchom kod:

go build
go run independent-identification

Przeprowadzanie niezależnej weryfikacji

Wykonaj następujące kroki, aby utworzyć nowy moduł GO.

  1. Otwórz wiersz polecenia, w którym chcesz utworzyć nowy moduł, a następnie utwórz nowy plik o nazwie independent-verification.go.

  2. Zastąp zawartość independent-verification.go poniższym kodem.

    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. W independent-verification.gopliku zastąp YourSubscriptionKey ciąg kluczem zasobu usługi Mowa i zastąp element YourServiceRegion regionem zasobu usługi Mowa.

Uruchom następujące polecenia, aby utworzyć go.mod plik, który łączy się z składnikami hostowanymi w usłudze GitHub:

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

Teraz skompiluj i uruchom kod:

go build
go run independent-verification

Czyszczenie zasobów

Aby usunąć utworzony zasób usługi Mowa, możesz użyć Azure Portal interfejsu wiersza polecenia platformy Azure lub interfejsu wiersza polecenia platformy Azure.

Dokumentacja referencyjna | Dodatkowe przykłady w usłudze GitHub

Zestaw SPEECH SDK dla języka Java obsługuje rozpoznawanie osoby mówiącej, ale jeszcze nie dołączyliśmy tutaj przewodnika. Wybierz inny język programowania, aby rozpocząć pracę i poznać pojęcia, lub zapoznaj się z dokumentacją języka Java i przykładami połączonymi od początku tego artykułu.

Dokumentacja referencyjna | Pakiet (npm) | Dodatkowe przykłady w usłudze GitHub | Kod źródłowy biblioteki

W tym przewodniku Szybki start poznasz podstawowe wzorce projektowania rozpoznawania osoby mówiącej przy użyciu zestawu Speech SDK, w tym:

  • Weryfikacja zależna od tekstu i niezależna od tekstu.
  • Identyfikacja osoby mówiącej w celu zidentyfikowania próbki głosu wśród grupy głosów.
  • Usuwanie profilów głosowych.

Aby zapoznać się z ogólnymi pojęciami dotyczącymi rozpoznawania osoby mówiącej, zobacz artykuł Przegląd . Aby uzyskać listę obsługiwanych platform, zobacz węzeł Odwołanie w okienku po lewej stronie.

Ważne

Firma Microsoft ogranicza dostęp do rozpoznawania osoby mówiącej. Zastosuj, aby używać go za pośrednictwem formularza przeglądu ograniczonego dostępu rozpoznawania osoby mówiącej platformy Azure . Po zatwierdzeniu możesz uzyskać dostęp do interfejsów API rozpoznawania osoby mówiącej.

Wymagania wstępne

  • Subskrypcja platformy Azure — utwórz je bezpłatnie.
  • w Azure Portal.
  • Klucz zasobu usługi Mowa i region. Po wdrożeniu zasobu usługi Mowa wybierz pozycję Przejdź do zasobu , aby wyświetlić klucze i zarządzać nimi. Aby uzyskać więcej informacji na temat zasobów usług Azure AI, zobacz Pobieranie kluczy dla zasobu.

Instalowanie zestawu SDK usługi Mowa

Przed rozpoczęciem należy zainstalować zestaw SPEECH SDK dla języka JavaScript.

W zależności od środowiska docelowego użyj jednego z następujących elementów:

Pobierz i wyodrębnij zestaw SPEECH SDK dla języka JavaScript microsoft.cognitiveservices.speech.sdk.bundle.js pliku. Umieść go w folderze dostępnym dla pliku HTML.

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

Porada

Jeśli używasz przeglądarki internetowej i używasz tagu <script> , sdk prefiks nie jest potrzebny. Prefiks sdk jest aliasem używanym do nazywania modułu require .

Importowanie zależności

Aby uruchomić przykłady w tym artykule, dodaj następujące instrukcje w górnej części pliku .js:

"use strict";

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

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

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

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

const ticks_per_second = 10000000;

Te instrukcje importować wymagane biblioteki i pobierać klucz subskrypcji usługi Mowa i region ze zmiennych środowiskowych. Określają również ścieżki do plików audio, które będą używane w następujących zadaniach.

Ważne

Pamiętaj, aby usunąć klucz z kodu po zakończeniu i nigdy nie publikować go publicznie. W przypadku środowiska produkcyjnego użyj bezpiecznego sposobu przechowywania i uzyskiwania dostępu do poświadczeń, takich jak Azure Key Vault. Aby uzyskać więcej informacji, zobacz artykuł Dotyczący zabezpieczeń usług Azure AI.

Tworzenie funkcji pomocnika

Dodaj następującą funkcję pomocnika, aby odczytywać pliki audio do strumieni do użycia przez usługę Mowa:

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

W tej funkcji użyjesz metod AudioInputStream.createPushStream i AudioConfig.fromStreamInput w celu utworzenia obiektu AudioConfig . Ten AudioConfig obiekt reprezentuje strumień audio. Podczas następujących zadań użyjesz kilku z tych AudioConfig obiektów.

Weryfikacja zależna od tekstu

Weryfikacja osoby mówiącej jest aktem potwierdzenia, że głośnik pasuje do znanego lub zarejestrowanego głosu. Pierwszym krokiem jest zarejestrowanie profilu głosowego w taki sposób, aby usługa mogła porównać przyszłe próbki głosu. W tym przykładzie zarejestrujesz profil przy użyciu strategii zależnej od tekstu , która wymaga określonego hasła do użycia na potrzeby rejestracji i weryfikacji. Zapoznaj się z dokumentacją referencyjną , aby uzyskać listę obsługiwanych haseł.

TextDependentVerification, funkcja

Zacznij od utworzenia TextDependentVerification funkcji.

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

Ta funkcja tworzy obiekt VoiceProfile z metodą VoiceProfileClient.createProfileAsync . Istnieją trzy typy:VoiceProfile

  • TextIndependentIdentIdentification
  • TextDependentVerification
  • TextIndependentVerification

W takim przypadku przekazujesz VoiceProfileType.TextDependentVerification do VoiceProfileClient.createProfileAsyncelementu .

Następnie wywołasz dwie funkcje pomocnicze, które zdefiniujesz w następnej kolejności, AddEnrollmentsToTextDependentProfile i SpeakerVerify. Na koniec wywołaj metodę VoiceProfileClient.deleteProfileAsync , aby usunąć profil.

AddEnrollmentsToTextDependentProfile, funkcja

Zdefiniuj następującą funkcję, aby zarejestrować profil głosowy:

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

W tej funkcji wywołasz funkcję zdefiniowaną GetAudioConfigFromFile wcześniej, aby utworzyć AudioConfig obiekty na podstawie przykładów dźwiękowych. Te przykłady audio zawierają hasło, takie jak "Mój głos jest moim paszportem, zweryfikuj mnie". Następnie zarejestrujesz te przykłady audio przy użyciu metody VoiceProfileClient.enrollProfileAsync .

SpeakerVerify, funkcja

Zdefiniuj SpeakerVerify w następujący sposób:

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

W tej funkcji utworzysz obiekt SpeakerVerificationModel za pomocą metody SpeakerVerificationModel.FromProfile, przekazując utworzony wcześniej obiekt VoiceProfile.

Następnie wywołaj metodę SpeechRecognizer.recognizeOnceAsync , aby sprawdzić poprawność przykładu audio zawierającego to samo hasło co zarejestrowane wcześniej próbki audio. SpeechRecognizer.recognizeOnceAsync Zwraca obiekt SpeakerRecognitionResult , którego score właściwość zawiera wynik podobieństwa, który waha się od 0,0 do 1,0. Obiekt SpeakerRecognitionResult zawiera reason również właściwość typu ResultReason. Jeśli weryfikacja zakończyła się pomyślnie, reason właściwość powinna mieć wartość RecognizedSpeaker.

Weryfikacja niezależna od tekstu

W przeciwieństwie do weryfikacji opartej na tekście weryfikacja niezależna od tekstu :

  • Nie wymaga podania określonego hasła. Wszystko może być mówione.
  • Nie wymaga trzech próbek dźwiękowych , ale wymaga 20 sekund całkowitej ilości dźwięku.

TextIndependentVerification, funkcja

Zacznij od utworzenia TextIndependentVerification funkcji.

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

TextDependentVerification Podobnie jak funkcja, ta funkcja tworzy obiekt VoiceProfile za pomocą metody VoiceProfileClient.createProfileAsync.

W takim przypadku przekazujesz VoiceProfileType.TextIndependentVerification wartość do .createProfileAsync

Następnie wywołasz dwie funkcje pomocnicze: AddEnrollmentsToTextIndependentProfile, które zdefiniujesz w następnej kolejności, i SpeakerVerify, które zostały już zdefiniowane. Na koniec wywołaj metodę VoiceProfileClient.deleteProfileAsync , aby usunąć profil.

AddEnrollmentsToTextIndependentProfile

Zdefiniuj następującą funkcję, aby zarejestrować profil głosowy:

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

W tej funkcji wywołasz zdefiniowaną GetAudioConfigFromFile wcześniej funkcję, aby utworzyć AudioConfig obiekty na podstawie przykładów dźwiękowych. Następnie zarejestrujesz te przykłady audio przy użyciu metody VoiceProfileClient.enrollProfileAsync .

Identyfikacja osoby mówiącej

Identyfikacja osoby mówiącej służy do określania , kto mówi z danej grupy zarejestrowanych głosów. Proces jest podobny do weryfikacji niezależnej od tekstu. Główną różnicą jest możliwość weryfikowania wielu profilów głosowych jednocześnie, a nie weryfikowania pod kątem pojedynczego profilu.

TextIndependentIdentIfication, funkcja

Zacznij od utworzenia TextIndependentIdentification funkcji.

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

Podobnie jak funkcje TextDependentVerification i TextIndependentVerification , ta funkcja tworzy obiekt VoiceProfile za pomocą metody VoiceProfileClient.createProfileAsync .

W takim przypadku przekazujesz VoiceProfileType.TextIndependentIdentification wartość do .VoiceProfileClient.createProfileAsync

Następnie wywołasz dwie funkcje pomocnicze: AddEnrollmentsToTextIndependentProfile, które zostały już zdefiniowane, i SpeakerIdentify, które zdefiniujesz w następnej kolejności. Na koniec wywołaj metodę VoiceProfileClient.deleteProfileAsync , aby usunąć profil.

SpeakerIdentify, funkcja

Zdefiniuj SpeakerIdentify funkcję w następujący sposób:

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

W tej funkcji utworzysz obiekt SpeakerIdentificationModel za pomocą metody SpeakerIdentificationModel.fromProfiles , przekazując utworzony wcześniej obiekt VoiceProfile .

Następnie wywołaj metodę SpeechRecognizer.recognizeOnceAsync i przekaż przykład audio. SpeechRecognizer.recognizeOnceAsync próbuje zidentyfikować głos dla tego przykładu audio na VoiceProfile podstawie obiektów użytych do utworzenia obiektu SpeakerIdentificationModel. Zwraca obiekt SpeakerRecognitionResult , którego profileId właściwość identyfikuje pasujący VoiceProfileobiekt , jeśli istnieje, podczas gdy score właściwość zawiera wynik podobieństwa, który waha się od 0,0 do 1,0.

Funkcja main

Na koniec zdefiniuj main funkcję w następujący sposób:

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

Ta funkcja tworzy obiekt VoiceProfileClient , który służy do tworzenia, rejestrowania i usuwania profilów głosowych. Następnie wywołuje zdefiniowane wcześniej funkcje.

Dokumentacja referencyjna | Pakiet (pobierz) | Dodatkowe przykłady w usłudze GitHub

Zestaw SPEECH SDK dla języka Objective-C nie obsługuje rozpoznawania osoby mówiącej. Wybierz inny język programowania lub odwołanie do języka Objective-C i przykłady połączone od początku tego artykułu.

Dokumentacja referencyjna | Pakiet (pobierz) | Dodatkowe przykłady w usłudze GitHub

Zestaw SDK rozpoznawania mowy dla języka Swift nie obsługuje rozpoznawania osoby mówiącej. Wybierz inny język programowania lub odwołanie do języka Swift i przykłady połączone na początku tego artykułu.

Dokumentacja referencyjna | Pakiet (PyPi) | Dodatkowe przykłady w usłudze GitHub

Zestaw SPEECH SDK dla języka Python nie obsługuje rozpoznawania osoby mówiącej. Wybierz inny język programowania lub odwołanie do języka Python i przykłady połączone od początku tego artykułu.

Dokumentacja | interfejsu API REST zamiany mowy na tekstInterfejs API REST zamiany mowy na tekst w celu uzyskania krótkiej dokumentacji | audioDodatkowe przykłady w usłudze GitHub

W tym przewodniku Szybki start poznasz podstawowe wzorce projektowe rozpoznawania osoby mówiącej przy użyciu zestawu SPEECH SDK, w tym:

  • Weryfikacja zależna od tekstu i niezależna od tekstu.
  • Identyfikacja osoby mówiącej w celu zidentyfikowania próbki głosu wśród grupy głosów.
  • Usuwanie profilów głosowych.

Aby zapoznać się z ogólnymi pojęciami dotyczącymi rozpoznawania osoby mówiącej, zobacz artykuł Omówienie . Aby uzyskać listę obsługiwanych platform, zobacz węzeł Odwołanie w okienku po lewej stronie.

Ważne

Firma Microsoft ogranicza dostęp do rozpoznawania osoby mówiącej. Zastosuj, aby używać go za pomocą formularza przeglądu ograniczonego dostępu rozpoznawania osoby mówiącej platformy Azure . Po zatwierdzeniu możesz uzyskać dostęp do interfejsów API rozpoznawania osoby mówiącej.

Wymagania wstępne

  • Subskrypcja platformy Azure — utwórz bezpłatnie.
  • w Azure Portal.
  • Klucz zasobu usługi Mowa i region. Po wdrożeniu zasobu usługi Mowa wybierz pozycję Przejdź do zasobu, aby wyświetlić klucze i zarządzać nimi. Aby uzyskać więcej informacji na temat zasobów usług Azure AI, zobacz Uzyskiwanie kluczy dla zasobu.

Weryfikacja zależna od tekstu

Weryfikacja osoby mówiącej to czynność potwierdzenia, że głośnik pasuje do znanego lub zarejestrowanego głosu. Pierwszym krokiem jest zarejestrowanie profilu głosowego, aby usługa mogła porównać przyszłe próbki głosu z. W tym przykładzie profil zostanie zarejestrowany przy użyciu strategii zależnej od tekstu , która wymaga użycia określonego hasła na potrzeby rejestracji i weryfikacji. Zapoznaj się z dokumentacją referencyjną , aby uzyskać listę obsługiwanych haseł.

Zacznij od utworzenia profilu głosowego. Musisz wstawić klucz subskrypcji usługi Rozpoznawanie mowy i region do każdego z poleceń curl w tym artykule.

Ważne

Pamiętaj, aby usunąć klucz z kodu po zakończeniu i nigdy nie publikować go publicznie. W przypadku środowiska produkcyjnego użyj bezpiecznego sposobu przechowywania i uzyskiwania dostępu do poświadczeń, takich jak azure Key Vault. Aby uzyskać więcej informacji, zobacz artykuł Dotyczący zabezpieczeń usług Azure AI.

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

Istnieją trzy typy profilów głosowych:

  • Weryfikacja zależna od tekstu
  • Weryfikacja niezależna od tekstu
  • Identyfikacja niezależna od tekstu

W takim przypadku utworzysz profil głosowy weryfikacji zależny od tekstu. Powinna zostać wyświetlona następująca odpowiedź:

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

Następnie zarejestrujesz profil głosowy. Dla wartości parametru --data-binary określ plik audio na komputerze, który zawiera jedno z obsługiwanych haseł, takich jak "Mój głos jest moim paszportem, sprawdź mnie". Plik dźwiękowy można zarejestrować za pomocą aplikacji, takiej jak Rejestrator głosu Windows. Możesz też wygenerować go przy użyciu tekstu na mowę.

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'

Powinna zostać wyświetlona następująca odpowiedź:

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

Ta odpowiedź informuje o konieczności zarejestrowania dwóch dodatkowych przykładów dźwiękowych.

Po zarejestrowaniu w sumie trzech przykładów dźwiękowych powinna zostać wyświetlona następująca odpowiedź:

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

Teraz możesz zweryfikować przykładowy dźwięk w profilu głosowym. Ten przykład dźwiękowy powinien zawierać takie samo hasło, jak przykłady użyte do zarejestrowania profilu głosowego.

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'

Powinna zostać wyświetlona następująca odpowiedź:

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

Accept oznacza, że hasło jest dopasowane, a weryfikacja zakończyła się pomyślnie. Odpowiedź zawiera również wynik podobieństwa, który waha się od 0,0 do 1,0.

Aby zakończyć, usuń profil głosowy.

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'

Nie ma odpowiedzi.

Weryfikacja niezależna od tekstu

W przeciwieństwie do weryfikacji zależnej od tekstuweryfikacja niezależna od tekstu :

  • Nie wymaga podania określonego hasła. Wszystko może być mówione.
  • Nie wymaga trzech próbek dźwiękowych, ale wymaga 20 sekund całkowitego dźwięku.

Zacznij od utworzenia profilu weryfikacji niezależnego od tekstu.

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

Powinna zostać wyświetlona następująca odpowiedź:

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

Następnie zarejestruj profil głosowy. Ponownie, zamiast przesyłać trzy przykłady audio, należy przesłać próbki audio, które zawierają łącznie 20 sekund dźwięku.

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

Po przesłaniu wystarczającej liczby przykładów dźwiękowych powinna zostać wyświetlona następująca odpowiedź:

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

Teraz możesz zweryfikować przykład audio w profilu głosowym. Ponownie ten przykład dźwiękowy nie musi zawierać hasła. Może zawierać dowolną mowę, ale musi zawierać łącznie co najmniej cztery sekundy dźwięku.

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'

Powinna zostać wyświetlona następująca odpowiedź:

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

Accept oznacza, że weryfikacja zakończyła się pomyślnie. Odpowiedź zawiera również wynik podobieństwa, który waha się od 0,0 do 1,0.

Aby zakończyć, usuń profil głosowy.

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'

Nie ma odpowiedzi.

Identyfikacja osoby mówiącej

Identyfikacja osoby mówiącej służy do określania , kto mówi z danej grupy zarejestrowanych głosów. Proces jest podobny do weryfikacji niezależnej od tekstu. Główną różnicą jest możliwość weryfikacji pod kątem wielu profilów głosowych jednocześnie, a nie weryfikacji względem jednego profilu.

Zacznij od utworzenia profilu identyfikacji niezależnego od tekstu.

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

Powinna zostać wyświetlona następująca odpowiedź:

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

Następnie zarejestruj profil głosowy. Ponownie należy przesłać próbki audio zawierające łącznie 20 sekund dźwięku. Te przykłady nie muszą zawierać hasła.

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

Po przesłaniu wystarczającej liczby przykładów dźwiękowych powinna zostać wyświetlona następująca odpowiedź:

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

Teraz możesz zidentyfikować przykład audio przy użyciu profilu głosowego. Polecenie identify akceptuje rozdzielaną przecinkami listę możliwych identyfikatorów profilów głosowych. W takim przypadku przekażesz identyfikator utworzonego wcześniej profilu głosowego. Jeśli chcesz, możesz przekazać wiele identyfikatorów profilów głosowych, w których każdy profil głosowy jest zarejestrowany przy użyciu przykładów dźwiękowych z innego głosu.

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

Powinna zostać wyświetlona następująca odpowiedź:

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

Odpowiedź zawiera identyfikator profilu głosowego, który najlepiej pasuje do przesłanego przykładu audio. Zawiera również listę profilów głosowych kandydatów w kolejności podobieństwa.

Aby zakończyć, usuń profil głosowy.

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'

Nie ma odpowiedzi.

Interfejs wiersza polecenia usługi Mowa obsługuje rozpoznawanie osoby mówiącej, ale jeszcze nie dołączyliśmy tutaj przewodnika. Wybierz inny język programowania, aby rozpocząć pracę i dowiedzieć się więcej o pojęciach.

Następne kroki

Zobacz przykłady szybkiego startu w usłudze GitHub