Schnellstart: Erkennen und Überprüfen des Sprechers

  • Artikel

ReferenzdokumentationPaket (NuGet)Zusätzliche Beispiele auf GitHub

In diesem Schnellstart lernen Sie grundlegende Entwurfsmuster für die Sprechererkennung mit dem Speech SDK kennen, einschließlich:

  • Textabhängige und textunabhängige Überprüfung
  • Sprecheridentifikation zum Identifizieren eines Sprachbeispiels unter einer Gruppe von Stimmen
  • Löschen von Stimmenprofilen

Einen Überblick über die Konzepte der Sprechererkennung finden Sie im Artikel Was ist Sprechererkennung?. Eine Liste der unterstützten Plattformen finden Sie im linken Navigationsbereich im Knoten Referenz.

Wichtig

Microsoft schränkt den Zugang zur Sprechererkennung ein. Beantragen Sie die Nutzung über das Formular zur Überprüfung des eingeschränkten Zugriffs für die Azure KI Services-Sprecher*innenerkennung. Nach der Genehmigung können Sie auf die APIs für die Sprechererkennung zugreifen.

Voraussetzungen

Installieren des Speech SDK

Bevor Sie beginnen, müssen Sie das Speech SDK installieren. Verwenden Sie dazu die folgenden plattformspezifischen Anleitungen:

Importieren von Abhängigkeiten

Um die Beispiele in diesem Artikel auszuführen, fügen Sie die folgenden using-Anweisungen oben in Ihr Skript ein:

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

Erstellen einer Sprachkonfiguration

Um den Speech-Dienst über das Speech SDK aufrufen zu können, muss eine SpeechConfig-Instanz erstellt werden. In diesem Beispiel erstellen Sie eine SpeechConfig-Instanz mit einem Abonnementschlüssel und einer Region. Sie können für den restlichen Teil dieses Artikels auch einfache Codebausteine erstellen, an denen Sie dann jeweils die entsprechenden Anpassungen vornehmen.

Wichtig

Denken Sie daran, den Schlüssel aus Ihrem Code zu entfernen, wenn Sie fertig sind, und ihn niemals zu veröffentlichen. Verwenden Sie für die Produktion eine sichere Art der Speicherung und des Zugriffs auf Ihre Anmeldeinformationen wie Azure Key Vault. Weitere Informationen finden Sie im Artikel zur Sicherheit von Azure KI Services.

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

Textabhängige Überprüfung

Mit der Sprecherüberprüfung wird bestätigt, dass ein Sprecher mit einer bekannten oder registrierten Stimme übereinstimmt. Der erste Schritt ist das Registrieren eines Stimmenprofils, damit der Dienst über etwas verfügt, mit dem zukünftige Sprachbeispiele verglichen werden können. In diesem Beispiel registrieren Sie das Profil mit einer textabhängigen Strategie, bei der eine bestimmte Passphrase erforderlich ist, die für die Registrierung und die Überprüfung verwendet wird. Eine Liste mit den unterstützten Passphrasen finden Sie in den Referenzdokumenten.

Erstellen Sie zunächst die folgende Funktion in der Program-Klasse, um ein Stimmenprofil zu registrieren:

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

In dieser Funktion erstellt await client.CreateProfileAsync() wirklich das neue Stimmenprofil. Nach der Erstellung geben Sie an, wie Sie Audiobeispiele eingeben, indem Sie in diesem Beispiel mit AudioConfig.FromDefaultMicrophoneInput() Audiodaten von Ihrem Standardeingabegerät erfassen. Als Nächstes registrieren Sie Audiobeispiele in einer while-Schleife, die die Anzahl verbleibender und für die Registrierung erforderlicher Beispiele nachverfolgt. Bei jeder Iteration werden Sie von client.EnrollProfileAsync(profile, audioInput) aufgefordert, die Passphrase in Ihr Mikrofon zu sprechen, und das Beispiel wird dann dem Stimmenprofil hinzugefügt.

Nach Abschluss der Registrierung rufen Sie await SpeakerVerify(config, profile, profileMapping) auf, um das soeben erstellte Profil zu überprüfen. Fügen Sie eine weitere Funktion hinzu, um SpeakerVerify zu definieren.

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

In dieser Funktion übergeben Sie das soeben erstellte VoiceProfile-Objekt, um ein Modell zu initialisieren, anhand dessen überprüft werden soll. Als Nächstes werden Sie von await speakerRecognizer.RecognizeOnceAsync(model) aufgefordert, die Passphrase erneut zu sprechen. Dieses Mal wird die Eingabe anhand Ihres Stimmenprofils überprüft, und es wird ein Ähnlichkeitswert zwischen 0,0 und 1,0 zurückgegeben. Das result-Objekt gibt auch Accept oder Reject zurück, je nachdem, ob die Passphrase übereinstimmt.

Ändern Sie als nächstes die Main()-Funktion, um die neuen Funktionen aufzurufen, die Sie erstellt haben. Beachten Sie außerdem, dass Sie ein Dictionary<string, string> erstellen, das durch Verweis über die Funktionsaufrufe übergeben wird. Der Grund hierfür ist, dass der Dienst aus Datenschutzgründen das Speichern eines lesbaren Namens mit einem erstellten VoiceProfile nicht zulässt und nur eine ID-Nummer speichert. In der VerificationEnroll-Funktion fügen Sie diesem Wörterbuch einen Eintrag mit der neu erstellten ID zusammen mit einem Textnamen hinzu. In Anwendungsentwicklungsszenarien, in denen Sie einen lesbaren Namen anzeigen müssen, müssen Sie diese Zuordnung irgendwo speichern, weil der Dienst sie nicht speichern kann.

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

Führen Sie das Skript aus. Sie werden aufgefordert, die Phrase „My voice is my passport, verify me“ (Meine Stimme ist mein Pass, überprüfen Sie mich) dreimal zur Registrierung und ein weiteres Mal zur Überprüfung zu sprechen. Als Ergebnis wird das Ähnlichkeitsergebnis zurückgegeben, mit dem Sie eigene benutzerdefinierte Schwellenwerte für die Überprüfung erstellen können.

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

Textunabhängige Überprüfung

Im Gegensatz zur textabhängigen Überprüfung sind für die textunabhängige Überprüfung keine drei Audiobeispiele erforderlich, es müssen jedoch insgesamt 20 Sekunden an Audiodaten vorliegen.

Nehmen Sie einige einfache Änderungen an ihrer VerificationEnroll-Funktion vor, um zur textunabhängigen Überprüfung zu wechseln. Ändern Sie zunächst den Überprüfungstyp in VoiceProfileType.TextIndependentVerification. Ändern Sie als nächstes die while-Schleife, sodass result.RemainingEnrollmentsSpeechLength verfolgt wird und Sie kontinuierlich aufgefordert werden, zu sprechen, bis 20 Sekunden Audiodaten aufgezeichnet sind.

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

Führen Sie das Programm erneut aus. Der Ähnlichkeitswert wird zurückgegeben.

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

Sprecheridentifikation

Anhand der Sprecheridentifikation wird bestimmt, welche Stimme aus einer bestimmten Gruppe registrierter Stimmen spricht. Der Prozess ähnelt der textunabhängigen Überprüfung. Der Hauptunterschied besteht in der Möglichkeit, anstatt eines einzelnen Profils mehrere Stimmenprofile gleichzeitig zu überprüfen.

Erstellen Sie eine Funktion IdentificationEnroll, um mehrere Stimmenprofile zu registrieren. Der Registrierungsprozess für die einzelnen Profile ist mit dem für die textunabhängige Überprüfung identisch. Der Prozess erfordert 20 Sekunden Audiodaten für jedes Profil. Diese Funktion akzeptiert eine profileNames-Liste mit Zeichenfolgen und erstellt für jeden Namen in der Liste ein neues Stimmenprofil. Die Funktion gibt eine Liste von VoiceProfile-Objekten zurück, die Sie in der nächsten Funktion zum Identifizieren eines Sprechers verwenden.

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

Erstellen Sie die folgende Funktion SpeakerIdentification, um eine Identifikationsanforderung zu senden. Der Hauptunterschied zwischen dieser Funktion und einer Anforderung zur Sprecherüberprüfung ist die Verwendung von SpeakerIdentificationModel.FromProfiles(), der eine Liste von VoiceProfile-Objekten übergeben wird.

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

Ändern Sie die Main()-Funktion wie folgt. Sie erstellen eine Liste profileNames von Zeichenfolgen, die Sie Ihrer IdentificationEnroll()-Funktion übergeben. Sie werden aufgefordert, für jeden Namen in dieser Liste ein neues Stimmenprofil zu erstellen. Sie können also weitere Namen hinzufügen, um zusätzliche Profile für Freunde oder Kollegen zu erstellen.

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

Führen Sie das Skript aus. Sie werden aufgefordert, zu sprechen, um Sprachbeispiele für das erste Profil zu registrieren. Nach Abschluss der Registrierung werden Sie aufgefordert, diesen Vorgang für jeden Namen in der profileNames-Liste zu wiederholen. Nach Ende jeder Registrierung werden Sie aufgefordert, eine beliebige Person sprechen zu lassen. Der Dienst versucht dann, diese Person aus den registrierten Stimmenprofilen zu identifizieren.

In diesem Beispiel werden nur die höchste Übereinstimmung und ihr Ähnlichkeitswert zurückgegeben. Fügen Sie Ihrer SpeakerIdentification-Funktion string json = result.Properties.GetProperty(PropertyId.SpeechServiceResponse_JsonResult) hinzu, um die vollständige Antwort mit den fünf höchsten Ähnlichkeitswerten zu erhalten.

Ändern des Audioeingabetyps

In den Beispielen dieses Artikels wird das standardmäßige Gerätemikrofon zur Eingabe der Audiobeispiele verwendet. In Szenarien, in denen Sie anstelle von Audiodateien Mikrofoneingaben verwenden müssen, ändern Sie jede Instanz von AudioConfig.FromDefaultMicrophoneInput() in AudioConfig.FromWavFileInput(path/to/your/file.wav), um zu einer Dateieingabe zu wechseln. Sie können auch gemischte Eingaben verwenden, z. B. ein Mikrofon zur Registrierung und Dateien zur Überprüfung.

Löschen von Stimmenprofilregistrierungen

Um ein registriertes Profil zu löschen, verwenden Sie die DeleteProfileAsync()-Funktion des VoiceProfileClient-Objekts. Die folgende Beispielfunktion zeigt, wie Sie ein Stimmenprofil aus einer bekannten Stimmenprofil-ID löschen:

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

ReferenzdokumentationPaket (NuGet)Zusätzliche Beispiele auf GitHub

In diesem Schnellstart lernen Sie grundlegende Entwurfsmuster für die Sprechererkennung mit dem Speech SDK kennen, einschließlich:

  • Textabhängige und textunabhängige Überprüfung
  • Sprecheridentifikation zum Identifizieren eines Sprachbeispiels unter einer Gruppe von Stimmen
  • Löschen von Stimmenprofilen

Einen Überblick über die Konzepte der Sprechererkennung finden Sie im Artikel Was ist Sprechererkennung?. Eine Liste der unterstützten Plattformen finden Sie im linken Navigationsbereich im Knoten Referenz.

Wichtig

Microsoft schränkt den Zugang zur Sprechererkennung ein. Beantragen Sie die Nutzung über das Formular zur Überprüfung des eingeschränkten Zugriffs für die Azure KI Services-Sprecher*innenerkennung. Nach der Genehmigung können Sie auf die APIs für die Sprechererkennung zugreifen.

Voraussetzungen

Installieren des Speech SDK

Bevor Sie beginnen, müssen Sie das Speech SDK installieren. Verwenden Sie dazu die folgenden plattformspezifischen Anleitungen:

Importieren von Abhängigkeiten

Fügen Sie die folgenden Anweisungen oben in Ihrer CPP-Datei ein, um die Beispiele in diesem Artikel auszuführen:

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

Erstellen einer Sprachkonfiguration

Um den Speech-Dienst über das Speech SDK aufrufen zu können, erstellen Sie eine SpeechConfig-Klasse. Diese Klasse enthält Informationen zu Ihrem Abonnement. Hierzu zählen etwa Ihr Schlüssel und die zugeordnete Region, der Endpunkt, der Host oder das Autorisierungstoken.

Wichtig

Denken Sie daran, den Schlüssel aus Ihrem Code zu entfernen, wenn Sie fertig sind, und ihn niemals zu veröffentlichen. Verwenden Sie für die Produktion eine sichere Art der Speicherung und des Zugriffs auf Ihre Anmeldeinformationen wie Azure Key Vault. Weitere Informationen finden Sie im Artikel zur Sicherheit von Azure KI Services.

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

Textabhängige Überprüfung

Mit der Sprecherüberprüfung wird bestätigt, dass ein Sprecher mit einer bekannten oder registrierten Stimme übereinstimmt. Der erste Schritt ist das Registrieren eines Stimmenprofils, damit der Dienst über etwas verfügt, mit dem zukünftige Sprachbeispiele verglichen werden können. In diesem Beispiel registrieren Sie das Profil mit einer textabhängigen Strategie, bei der eine bestimmte Passphrase erforderlich ist, die für die Registrierung und die Überprüfung verwendet wird. Eine Liste mit den unterstützten Passphrasen finden Sie in den Referenzdokumenten.

Funktion „TextDependentVerification“

Erstellen Sie zunächst die TextDependentVerification-Funktion:

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

Mit dieser Funktion wird ein VoiceProfile-Objekt mit der CreateProfileAsync-Methode erstellt. Es gibt drei VoiceProfile-Typen:

  • TextIndependentIdentification
  • TextDependentVerification
  • TextIndependentVerification

In diesem Fall übergeben Sie VoiceProfileType::TextDependentVerification an CreateProfileAsync.

Anschließend rufen Sie zwei Hilfsfunktionen auf, die Sie als Nächstes definieren: AddEnrollmentsToTextDependentProfile und SpeakerVerify. Abschließend rufen Sie DeleteProfileAsync auf, um das Profil zu bereinigen.

Funktion „AddEnrollmentsToTextDependentProfile“

Definieren Sie die folgende Funktion, um ein Stimmenprofil zu registrieren:

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

Bei dieser Funktion registrieren Sie Audiobeispiele in einer while-Schleife, die die Anzahl von verbleibenden und für die Registrierung erforderlichen Beispielen nachverfolgt. Bei jeder Iteration werden Sie von EnrollProfileAsync aufgefordert, die Passphrase in Ihr Mikrofon zu sprechen, und das Beispiel wird dann dem Stimmenprofil hinzugefügt.

Funktion „SpeakerVerify“

Definieren Sie SpeakerVerify wie folgt:

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

In dieser Funktion erstellen Sie ein SpeakerVerificationModel-Objekt mit der SpeakerVerificationModel::FromProfile-Methode, indem Sie das zuvor erstellte VoiceProfile-Objekt übergeben.

Als Nächstes werden Sie von SpeechRecognizer::RecognizeOnceAsync aufgefordert, die Passphrase erneut zu sprechen. Dieses Mal wird die Eingabe anhand Ihres Stimmenprofils überprüft, und es wird ein Ähnlichkeitswert zwischen 0,0 und 1,0 zurückgegeben. Das SpeakerRecognitionResult-Objekt gibt auch Accept oder Reject zurück, je nachdem, ob die Passphrase übereinstimmt.

Textunabhängige Überprüfung

Im Gegensatz zur textabhängigen Überprüfung sind für die textunabhängige Überprüfung keine drei Audiobeispiele erforderlich, es müssen jedoch insgesamt 20 Sekunden an Audiodaten vorliegen.

Funktion „TextIndependentVerification“

Erstellen Sie zunächst die TextIndependentVerification-Funktion:

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

Wie auch bei der Funktion TextDependentVerification, wird mit dieser Funktion ein VoiceProfile-Objekt mit der CreateProfileAsync-Methode erstellt.

In diesem Fall übergeben Sie VoiceProfileType::TextIndependentVerification an CreateProfileAsync.

Anschließend rufen Sie zwei Hilfsfunktionen auf: AddEnrollmentsToTextIndependentProfile, die Sie als Nächstes definieren, und SpeakerVerify, die Sie bereits definiert haben. Abschließend rufen Sie DeleteProfileAsync auf, um das Profil zu bereinigen.

AddEnrollmentsToTextIndependentProfile

Definieren Sie die folgende Funktion, um ein Stimmenprofil zu registrieren:

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

In dieser Funktion registrieren Sie Audiobeispiele in einer while-Schleife, die die Anzahl von Sekunden nachverfolgt, die verbleiben bzw. für die Registrierung erforderlich sind. Bei jeder Iteration werden Sie von EnrollProfileAsync aufgefordert, in Ihr Mikrofon zu sprechen, und das Beispiel wird dann dem Stimmenprofil hinzugefügt.

Sprecheridentifikation

Anhand der Sprecheridentifikation wird bestimmt, welche Stimme aus einer bestimmten Gruppe registrierter Stimmen spricht. Der Prozess ähnelt der textunabhängigen Überprüfung. Der Hauptunterschied besteht in der Möglichkeit, anstatt eines einzelnen Profils mehrere Stimmenprofile gleichzeitig zu überprüfen.

Funktion „TextIndependentIdentification“

Erstellen Sie zunächst die TextIndependentIdentification-Funktion:

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

Wie auch bei den Funktionen TextDependentVerification und TextIndependentVerification, wird mit dieser Funktion ein VoiceProfile-Objekt mit der CreateProfileAsync-Methode erstellt.

In diesem Fall übergeben Sie VoiceProfileType::TextIndependentIdentification an CreateProfileAsync.

Anschließend rufen Sie zwei Hilfsfunktionen auf: AddEnrollmentsToTextIndependentProfile, die Sie bereits definiert haben, und SpeakerIdentify, die Sie als Nächstes definieren. Abschließend rufen Sie DeleteProfileAsync auf, um das Profil zu bereinigen.

Funktion „SpeakerIdentify“

Definieren Sie die SpeakerIdentify-Funktion wie folgt:

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

In dieser Funktion erstellen Sie ein SpeakerIdentificationModel-Objekt mit der SpeakerIdentificationModel::FromProfiles-Methode. SpeakerIdentificationModel::FromProfiles akzeptiert eine Liste mit VoiceProfile-Objekten. In diesem Fall übergeben Sie das zuvor erstellte VoiceProfile-Objekt. Wenn Sie möchten, können Sie auch mehrere VoiceProfile-Objekte übergeben, die jeweils mit Audiobeispielen einer anderen Stimme registriert werden.

Als Nächstes werden Sie von SpeechRecognizer::RecognizeOnceAsync aufgefordert, erneut zu sprechen. Dieses Mal wird Ihre Stimme mit den registrierten Stimmenprofilen verglichen und das Stimmenprofil mit der größten Ähnlichkeit zurückgegeben.

main-Funktion

Definieren Sie zum Schluss die main-Funktion wie folgt:

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

Diese Funktion ruft die zuvor definierten Funktionen auf. Zunächst erstellt sie ein VoiceProfileClient- und ein SpeakerRecognizer-Objekt.

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

Das VoiceProfileClient-Objekt wird verwendet, um Stimmenprofile zu erstellen, zu registrieren und zu löschen. Das SpeakerRecognizer-Objekt wird verwendet, um Sprachbeispiele anhand von mindestens einem registrierten Stimmenprofil zu überprüfen.

Ändern des Audioeingabetyps

In den Beispielen dieses Artikels wird das standardmäßige Gerätemikrofon zur Eingabe der Audiobeispiele verwendet. In Szenarien, in denen Sie anstelle der Eingabe per Mikrofon Audiodateien verwenden müssen, ändern Sie die folgende Zeile:

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

in:

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

Alternativ können Sie alle Vorkommen von audio_config durch Audio::AudioConfig::FromWavFileInput ersetzen. Sie können auch gemischte Eingaben verwenden, z. B. ein Mikrofon zur Registrierung und Dateien zur Überprüfung.

ReferenzdokumentationPaket (Go)Zusätzliche Beispiele auf GitHub

In diesem Schnellstart lernen Sie grundlegende Entwurfsmuster für die Sprechererkennung mit dem Speech SDK kennen, einschließlich:

  • Textabhängige und textunabhängige Überprüfung
  • Sprecheridentifikation zum Identifizieren eines Sprachbeispiels unter einer Gruppe von Stimmen
  • Löschen von Stimmenprofilen

Einen Überblick über die Konzepte der Sprechererkennung finden Sie im Artikel Was ist Sprechererkennung?. Eine Liste der unterstützten Plattformen finden Sie im linken Navigationsbereich im Knoten Referenz.

Wichtig

Microsoft schränkt den Zugang zur Sprechererkennung ein. Beantragen Sie die Nutzung über das Formular zur Überprüfung des eingeschränkten Zugriffs für die Azure KI Services-Sprecher*innenerkennung. Nach der Genehmigung können Sie auf die APIs für die Sprechererkennung zugreifen.

Voraussetzungen

Einrichten der Umgebung

Installieren Sie das Speech SDK für Go. Im SDK-Installationshandbuch finden Sie weitere Anforderungen

Durchführen einer unabhängigen Identifizierung

Führen Sie die folgenden Schritte aus, um ein neues GO-Modul zu erstellen.

  1. Öffnen Sie am gewünschten Speicherort für das neue Modul eine Eingabeaufforderung, und erstellen Sie eine neue Datei mit dem Namen independent-identification.go.

  2. Ersetzen Sie den Inhalt von independent-identification.go durch den folgenden Code.

    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. Ersetzen Sie in independent-identification.goYourSubscriptionKey durch den Schlüssel Ihrer Speech-Ressource und YourServiceRegion durch die Region Ihrer Speech-Ressource.

    Wichtig

    Denken Sie daran, den Schlüssel aus Ihrem Code zu entfernen, wenn Sie fertig sind, und ihn niemals zu veröffentlichen. Verwenden Sie für die Produktion eine sichere Art der Speicherung und des Zugriffs auf Ihre Anmeldeinformationen wie Azure Key Vault. Weitere Informationen finden Sie im Artikel zur Sicherheit von Azure KI Services.

Führen Sie die folgenden Befehle aus, um eine Datei namens go.mod zu erstellen, die mit auf GitHub gehosteten Komponenten verknüpft ist:

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

Erstellen Sie als Nächstes den Code, und führen Sie ihn aus:

go build
go run independent-identification

Durchführen einer unabhängigen Überprüfung

Führen Sie die folgenden Schritte aus, um ein neues GO-Modul zu erstellen.

  1. Öffnen Sie am gewünschten Speicherort für das neue Modul eine Eingabeaufforderung, und erstellen Sie eine neue Datei mit dem Namen independent-verification.go.

  2. Ersetzen Sie den Inhalt von independent-verification.go durch den folgenden Code.

    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. Ersetzen Sie in independent-verification.goYourSubscriptionKey durch den Schlüssel Ihrer Speech-Ressource und YourServiceRegion durch die Region Ihrer Speech-Ressource.

Führen Sie die folgenden Befehle aus, um eine Datei namens go.mod zu erstellen, die mit auf GitHub gehosteten Komponenten verknüpft ist:

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

Erstellen Sie als Nächstes den Code, und führen Sie ihn aus:

go build
go run independent-verification

Bereinigen von Ressourcen

Sie können das Azure-Portal oder die Azure-Befehlszeilenschnittstelle (CLI) verwenden, um die erstellte Speech-Ressource zu entfernen.

Referenzdokumentation | Zusätzliche Beispiele auf GitHub

Das Speech SDK für Java unterstützt die Sprechererkennung, wir haben hier jedoch noch keinen Leitfaden bereitgestellt. Wählen Sie eine andere Programmiersprache aus, um loszulegen und sich über die Konzepte zu informieren, oder verwenden Sie die Java-Referenz und -Beispiele unter dem entsprechenden Link am Anfang dieses Artikels.

ReferenzdokumentationPaket (npm)Zusätzliche Beispiele auf GitHubQuellcode der Bibliothek

In diesem Schnellstart lernen Sie grundlegende Entwurfsmuster für die Sprechererkennung mit dem Speech SDK kennen, einschließlich:

  • Textabhängige und textunabhängige Überprüfung
  • Sprecheridentifikation zum Identifizieren eines Sprachbeispiels unter einer Gruppe von Stimmen
  • Löschen von Stimmenprofilen

Einen Überblick über die Konzepte der Sprechererkennung finden Sie im Artikel Was ist Sprechererkennung?. Eine Liste der unterstützten Plattformen finden Sie im linken Navigationsbereich im Knoten Referenz.

Wichtig

Microsoft schränkt den Zugang zur Sprechererkennung ein. Beantragen Sie die Nutzung über das Formular zur Überprüfung des eingeschränkten Zugriffs für die Azure KI Services-Sprecher*innenerkennung. Nach der Genehmigung können Sie auf die APIs für die Sprechererkennung zugreifen.

Voraussetzungen

Installieren des Speech SDK

Bevor Sie beginnen, müssen Sie das Speech SDK für JavaScript installieren.

Verwenden Sie je nach Zielumgebung eine der folgenden Funktionen:

Laden Sie die Datei Speech SDK für JavaScript microsoft.cognitiveservices.speech.sdk.bundle.js herunter, und extrahieren Sie sie. Speichern Sie sie in einem Ordner, auf den Ihre HTML-Datei zugreifen kann.

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

Tipp

Verwenden Sie für einen Webbrowser das Tag <script>. Das Präfix sdk ist nicht erforderlich. Das Präfix sdk ist ein Alias, mit dem das Modul require benannt wird.

Importieren von Abhängigkeiten

Fügen Sie die folgenden Anweisungen oben in Ihrer JS-Datei hinzu, um die Beispiele in diesem Artikel auszuführen:

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

Mit diesen Anweisungen werden die erforderlichen Bibliotheken importiert und Ihr Schlüssel und die Region des Speech-Diensts aus Ihren Umgebungsvariablen abgerufen. Darüber hinaus geben sie die Pfade zu Audiodateien an, die Sie bei den folgenden Aufgaben verwenden.

Wichtig

Denken Sie daran, den Schlüssel aus Ihrem Code zu entfernen, wenn Sie fertig sind, und ihn niemals zu veröffentlichen. Verwenden Sie für die Produktion eine sichere Art der Speicherung und des Zugriffs auf Ihre Anmeldeinformationen wie Azure Key Vault. Weitere Informationen finden Sie im Artikel zur Sicherheit von Azure KI Services.

Erstellen einer Hilfsfunktion

Fügen Sie die folgende Hilfsfunktion zum Einlesen von Audiodateien in Datenströme zur Verwendung durch den Speech-Dienst hinzu:

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

In dieser Funktion verwenden Sie die Methoden AudioInputStream.createPushStream und AudioConfig.fromStreamInput, um ein AudioConfig-Objekt zu erstellen. Dieses AudioConfig-Objekt stellt einen Audiodatenstrom dar. In den folgenden Aufgaben verwenden Sie mehrere dieser AudioConfig-Objekte.

Textabhängige Überprüfung

Mit der Sprecherüberprüfung wird bestätigt, dass ein Sprecher mit einer bekannten oder registrierten Stimme übereinstimmt. Der erste Schritt ist das Registrieren eines Stimmenprofils, damit der Dienst über etwas verfügt, mit dem zukünftige Sprachbeispiele verglichen werden können. In diesem Beispiel registrieren Sie das Profil mit einer textabhängigen Strategie, bei der eine bestimmte Passphrase erforderlich ist, die für die Registrierung und die Überprüfung verwendet wird. Eine Liste mit den unterstützten Passphrasen finden Sie in den Referenzdokumenten.

Funktion „TextDependentVerification“

Erstellen Sie zunächst die Funktion 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);
        }
    }
}

Mit dieser Funktion wird mit der VoiceProfileClient.createProfileAsync-Methode ein VoiceProfile-Objekt erstellt. Es gibt drei VoiceProfile-Typen:

  • TextIndependentIdentification
  • TextDependentVerification
  • TextIndependentVerification

In diesem Fall übergeben Sie VoiceProfileType.TextDependentVerification an VoiceProfileClient.createProfileAsync.

Anschließend rufen Sie zwei Hilfsfunktionen auf, die Sie als Nächstes definieren: AddEnrollmentsToTextDependentProfile und SpeakerVerify. Rufen Sie abschließend VoiceProfileClient.deleteProfileAsync auf, um das Profil zu entfernen.

Funktion „AddEnrollmentsToTextDependentProfile“

Definieren Sie die folgende Funktion, um ein Stimmenprofil zu registrieren:

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

In dieser Funktion rufen Sie die Funktion GetAudioConfigFromFile auf, die Sie weiter oben definiert haben, um AudioConfig-Objekte aus Audiobeispielen zu erstellen. Diese Audiobeispiele enthalten eine Passphrase wie „My voice is my passport, verify me“ (Meine Stimme ist mein Pass, überprüfen Sie mich). Anschließend registrieren Sie diese Audiobeispiele mithilfe der VoiceProfileClient.enrollProfileAsync-Methode.

Funktion „SpeakerVerify“

Definieren Sie SpeakerVerify wie folgt:

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

In dieser Funktion erstellen Sie ein SpeakerVerificationModel-Objekt mit der SpeakerVerificationModel.FromProfile-Methode, indem Sie das zuvor erstellte VoiceProfile-Objekt übergeben.

Als Nächstes rufen Sie die SpeechRecognizer.recognizeOnceAsync-Methode auf, um ein Audiobeispiel zu überprüfen, das die gleiche Passphrase wie die zuvor registrierten Audiobeispiele enthält. SpeechRecognizer.recognizeOnceAsync gibt ein SpeakerRecognitionResult-Objekt zurück, dessen score-Eigenschaft einen Ähnlichkeitswert zwischen 0,0 und 1,0 enthält. Das SpeakerRecognitionResult-Objekt enthält auch eine reason-Eigenschaft vom Typ ResultReason. Wenn die Überprüfung erfolgreich war, sollte die reason-Eigenschaft den Wert RecognizedSpeaker aufweisen.

Textunabhängige Überprüfung

Dies unterscheidet die textabhängige Überprüfung von der textunabhängigen Überprüfung:

  • Sie erfordert nicht, dass eine bestimmte Passphrase gesprochen wird. Es können beliebige Wörter gesprochen werden.
  • Es sind nicht drei Audiobeispiele erforderlich, aber es müssen insgesamt 20 Sekunden an Audiodaten vorliegen.

Funktion „TextIndependentVerification“

Erstellen Sie zunächst die Funktion 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);
        }
    }
}

Wie auch bei der Funktion TextDependentVerification, wird mit dieser Funktion mit der VoiceProfileClient.createProfileAsync-Methode ein VoiceProfile-Objekt erstellt.

In diesem Fall übergeben Sie VoiceProfileType.TextIndependentVerification an createProfileAsync.

Anschließend rufen Sie zwei Hilfsfunktionen auf: AddEnrollmentsToTextIndependentProfile, die Sie als Nächstes definieren, und SpeakerVerify, die Sie bereits definiert haben. Rufen Sie abschließend VoiceProfileClient.deleteProfileAsync auf, um das Profil zu entfernen.

AddEnrollmentsToTextIndependentProfile

Definieren Sie die folgende Funktion, um ein Stimmenprofil zu registrieren:

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

In dieser Funktion rufen Sie die Funktion GetAudioConfigFromFile auf, die Sie weiter oben definiert haben, um AudioConfig-Objekte aus Audiobeispielen zu erstellen. Anschließend registrieren Sie diese Audiobeispiele mithilfe der VoiceProfileClient.enrollProfileAsync-Methode.

Sprecheridentifikation

Anhand der Sprecheridentifikation wird bestimmt, welche Stimme aus einer bestimmten Gruppe registrierter Stimmen spricht. Der Prozess ähnelt der textunabhängigen Überprüfung. Der Hauptunterschied besteht in der Möglichkeit, anstatt eines einzelnen Profils mehrere Stimmenprofile gleichzeitig zu überprüfen.

Funktion „TextIndependentIdentification“

Erstellen Sie zunächst die Funktion 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);
        }
    }
}

Wie auch bei den Funktionen TextDependentVerification und TextIndependentVerification, wird mit dieser Funktion mit der VoiceProfileClient.createProfileAsync-Methode ein VoiceProfile-Objekt erstellt.

In diesem Fall übergeben Sie VoiceProfileType.TextIndependentIdentification an VoiceProfileClient.createProfileAsync.

Anschließend rufen Sie zwei Hilfsfunktionen auf: AddEnrollmentsToTextIndependentProfile, die Sie bereits definiert haben, und SpeakerIdentify, die Sie als Nächstes definieren. Rufen Sie abschließend VoiceProfileClient.deleteProfileAsync auf, um das Profil zu entfernen.

Funktion „SpeakerIdentify“

Definieren Sie die SpeakerIdentify-Funktion wie folgt:

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

In dieser Funktion erstellen Sie ein SpeakerIdentificationModel-Objekt mit der SpeakerIdentificationModel.fromProfiles-Methode, indem Sie das zuvor erstellte VoiceProfile-Objekt übergeben.

Als Nächstes rufen Sie die SpeechRecognizer.recognizeOnceAsync-Methode auf und übergeben ein Audiobeispiel. Über SpeechRecognizer.recognizeOnceAsync wird versucht, die Stimme für dieses Audiobeispiel basierend auf den VoiceProfile-Objekten zu identifizieren, die Sie zum Erstellen von SpeakerIdentificationModel verwendet haben. Die Methode gibt ein SpeakerRecognitionResult-Objekt zurück, dessen profileId-Eigenschaft das übereinstimmende VoiceProfile identifiziert (falls vorhanden). Die score-Eigenschaft enthält einen Ähnlichkeitswert zwischen 0,0 und 1,0.

main-Funktion

Definieren Sie zum Schluss die main-Funktion wie folgt:

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

Mit dieser Funktion wird ein VoiceProfileClient-Objekt erstellt, das zum Erstellen, Registrieren und Löschen von Stimmenprofilen verwendet wird. Anschließend werden die Funktionen aufgerufen, die Sie zuvor definiert haben.

ReferenzdokumentationPaket (Download)Zusätzliche Beispiele auf GitHub

Das Speech SDK für Objective-C unterstützt die Sprecher*innenerkennung nicht. Wählen Sie eine andere Programmiersprache aus, oder verwenden Sie die Objective-C-Referenz und -Beispiele unter dem entsprechenden Link am Anfang dieses Artikels.

ReferenzdokumentationPaket (Download)Zusätzliche Beispiele auf GitHub

Das Speech SDK für Swift unterstützt die Sprecher*innenerkennung nicht. Wählen Sie eine andere Programmiersprache aus, oder verwenden Sie die Swift-Referenz und -Beispiele unter dem entsprechenden Link am Anfang dieses Artikels.

ReferenzdokumentationPaket (PyPi)Zusätzliche Beispiele auf GitHub

Das Speech SDK für Python unterstützt die Sprecher*innenerkennung nicht. Wählen Sie eine andere Programmiersprache aus, oder verwenden Sie die Python-Referenz und -Beispiele unter dem entsprechenden Link am Anfang dieses Artikels.

REST-API-Referenz zur Spracherkennung | REST-API-Referenz zur Spracherkennung für kurze Audiodaten | Zusätzliche Beispiele auf GitHub

In diesem Schnellstart lernen Sie grundlegende Entwurfsmuster für die Sprechererkennung mit dem Speech SDK kennen, einschließlich:

  • Textabhängige und textunabhängige Überprüfung
  • Sprecheridentifikation zum Identifizieren eines Sprachbeispiels unter einer Gruppe von Stimmen
  • Löschen von Stimmenprofilen

Einen Überblick über die Konzepte der Sprechererkennung finden Sie im Artikel Was ist Sprechererkennung?. Eine Liste der unterstützten Plattformen finden Sie im linken Navigationsbereich im Knoten Referenz.

Wichtig

Microsoft schränkt den Zugang zur Sprechererkennung ein. Beantragen Sie die Nutzung über das Formular zur Überprüfung des eingeschränkten Zugriffs für die Azure KI Services-Sprecher*innenerkennung. Nach der Genehmigung können Sie auf die APIs für die Sprechererkennung zugreifen.

Voraussetzungen

Textabhängige Überprüfung

Mit der Sprecherüberprüfung wird bestätigt, dass ein Sprecher mit einer bekannten oder registrierten Stimme übereinstimmt. Der erste Schritt ist das Registrieren eines Stimmenprofils, damit der Dienst über etwas verfügt, mit dem zukünftige Sprachbeispiele verglichen werden können. In diesem Beispiel registrieren Sie das Profil mit einer textabhängigen Strategie, bei der eine bestimmte Passphrase erforderlich ist, die für die Registrierung und die Überprüfung verwendet wird. Eine Liste mit den unterstützten Passphrasen finden Sie in den Referenzdokumenten.

Erstellen Sie zunächst ein Stimmenprofil. Sie müssen den Abonnementschlüssel und die Region Ihres Speech-Diensts in jeden cURL-Befehl in diesem Artikel einfügen.

Wichtig

Denken Sie daran, den Schlüssel aus Ihrem Code zu entfernen, wenn Sie fertig sind, und ihn niemals zu veröffentlichen. Verwenden Sie für die Produktion eine sichere Art der Speicherung und des Zugriffs auf Ihre Anmeldeinformationen wie Azure Key Vault. Weitere Informationen finden Sie im Artikel zur Sicherheit von Azure KI Services.

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

Es gibt drei Stimmenprofiltypen:

  • Textabhängige Überprüfung
  • Textunabhängige Überprüfung
  • Textunabhängige Identifikation

In diesem Fall erstellen Sie ein textabhängiges Stimmenprofil. Sie sollten folgende Antwort erhalten:

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

Als Nächstes registrieren Sie das Stimmenprofil. Geben Sie für den Parameterwert --data-binary eine Audiodatei auf Ihrem Computer an, die eine der unterstützten Passphrasen enthält, z. B. „My voice is my passport, verify me“ (Meine Stimme ist mein Pass, überprüfen Sie mich). Sie können eine Audiodatei mit einer App wie dem Windows-Sprachrekorder aufnehmen. Alternativ können Sie die Datei mithilfe der Sprachsynthese generieren.

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'

Sie sollten folgende Antwort erhalten:

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

Mit dieser Antwort wird Ihnen mitgeteilt, dass Sie zwei weitere Audiobeispiele registrieren müssen.

Nachdem Sie insgesamt drei Audiobeispiele registriert haben, sollten Sie die folgende Antwort erhalten:

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

Jetzt können Sie ein Audiobeispiel anhand des Stimmenprofils überprüfen. Dieses Audiobeispiel sollte die gleiche Passphrase wie die Beispiele enthalten, die Sie zum Registrieren des Stimmenprofils verwendet haben.

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'

Sie sollten folgende Antwort erhalten:

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

Accept bedeutet, dass die Passphrase übereinstimmt und die Überprüfung erfolgreich war. Die Antwort enthält auch einen Ähnlichkeitswert zwischen 0,0 und 1,0.

Löschen Sie abschließend das Stimmenprofil.

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'

Es wird keine Antwort zurückgegeben.

Textunabhängige Überprüfung

Dies unterscheidet die textabhängige Überprüfung von der textunabhängigen Überprüfung:

  • Sie erfordert nicht, dass eine bestimmte Passphrase gesprochen wird. Es können beliebige Wörter gesprochen werden.
  • Es sind nicht drei Audiobeispiele erforderlich, aber es müssen insgesamt 20 Sekunden an Audiodaten vorliegen.

Erstellen Sie zunächst ein textunabhängiges Verifizierungsprofil.

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

Sie sollten folgende Antwort erhalten:

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

Registrieren Sie als Nächstes das Stimmenprofil. Anstelle von drei Audiobeispielen müssen Sie auch hier Audiobeispiele mit insgesamt 20 Sekunden Audiodaten übermitteln.

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'

Sobald Sie genügend Audiobeispiele übermittelt haben, sollten Sie die folgende Antwort erhalten:

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

Jetzt können Sie ein Audiobeispiel anhand des Stimmenprofils überprüfen. Auch dieses Audiobeispiel muss keine Passphrase enthalten. Es kann beliebige Sprachdaten enthalten, solange insgesamt vier Sekunden Audiodaten vorhanden sind.

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'

Sie sollten folgende Antwort erhalten:

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

Accept bedeutet, dass die Überprüfung erfolgreich war. Die Antwort enthält auch einen Ähnlichkeitswert zwischen 0,0 und 1,0.

Löschen Sie abschließend das Stimmenprofil.

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'

Es wird keine Antwort zurückgegeben.

Sprecheridentifikation

Anhand der Sprecheridentifikation wird bestimmt, welche Stimme aus einer bestimmten Gruppe registrierter Stimmen spricht. Der Prozess ähnelt der textunabhängigen Überprüfung. Der Hauptunterschied besteht in der Möglichkeit, anstatt eines einzelnen Profils mehrere Stimmenprofile gleichzeitig zu überprüfen.

Erstellen Sie zunächst ein Profil für die textunabhängige Identifikation.

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

Sie sollten folgende Antwort erhalten:

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

Als Nächstes registrieren Sie das Stimmenprofil. Auch hier müssen Sie Audiobeispiele übermitteln, die insgesamt 20 Sekunden an Audiodaten enthalten. Diese Beispiele müssen keine Passphrase enthalten.

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'

Sobald Sie genügend Audiobeispiele übermittelt haben, sollten Sie die folgende Antwort erhalten:

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

Nun können Sie ein Audiobeispiel anhand des Stimmenprofils identifizieren. Der Identifizierungsbefehl akzeptiert eine Liste mit Kommas als Trennzeichen, die die möglichen Stimmenprofil-IDs enthält. In diesem Fall übergeben Sie die ID des Stimmenprofils, das Sie zuvor erstellt haben. Wenn Sie möchten, können Sie auch mehrere Stimmenprofil-IDs übergeben, wobei jedes Stimmenprofil mit Audiobeispielen einer anderen Stimme registriert wird.

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

Sie sollten folgende Antwort erhalten:

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

Die Antwort enthält die ID des Stimmenprofils, das die größte Übereinstimmung mit dem von Ihnen übermittelten Audiobeispiel aufweist. Darüber hinaus enthält sie eine Liste mit Kandidaten für Stimmenprofile, die nach Ähnlichkeit sortiert sind.

Löschen Sie abschließend das Stimmenprofil.

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'

Es wird keine Antwort zurückgegeben.

Die Speech-Befehlszeilenschnittstelle unterstützt die Sprechererkennung, wir haben hier jedoch noch keinen Leitfaden bereitgestellt. Wählen Sie eine andere Programmiersprache aus, um loszulegen und sich über die Konzepte zu informieren.

Nächste Schritte

Sehen Sie sich die Schnellstartbeispiele auf GitHub an.