Démarrage rapide : reconnaître et vérifier qui parle

  • Article

Documentation de référencePackage (NuGet)Exemples supplémentaires sur GitHub

Dans ce guide de démarrage rapide, vous allez découvrir les modèles de conception de base pour la reconnaissance de l’orateur à l’aide du SDK de reconnaissance vocale, notamment :

  • Vérification dépendante ou indépendante du texte.
  • Identification de l’orateur pour identifier un échantillon vocal parmi un groupe de voix.
  • Suppression de profils vocaux.

Pour obtenir une vue d’ensemble des concepts de reconnaissance de l’orateur, consultez l’article de présentation. Voir le nœud de référence dans le volet de gauche pour une liste des plateformes prises en charge.

Important

Microsoft limite l’accès à la Reconnaissance de l’orateur. Demandez à l’utiliser par le biais du formulaire Examen de l’accès limité à Reconnaissance de l’orateur Azure AI. Après approbation, vous pouvez accéder aux API de reconnaissance des locuteurs.

Prérequis

Installer le Kit de développement logiciel (SDK) Speech

Avant de commencer, vous devez installer le kit de développement logiciel (SDK) Speech. Suivez les instructions ci-dessous, en fonction de votre plateforme :

Importer les dépendances

Pour exécuter les exemples de cet article, incluez les instructions using suivantes en haut de votre script :

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

Créer une configuration Speech

Pour appeler le service Speech à l’aide du SDK Speech, vous devez créer une instance de SpeechConfig. Dans cet exemple, vous allez créer une instance de SpeechConfig à partir d’une clé d’abonnement et d’une région. Vous pouvez aussi créer un code réutilisable de base à utiliser pour le reste de cet article, que vous modifiez pour différentes personnalisations.

Important

N’oubliez pas de supprimer la clé de votre code une fois que vous avez terminé, et ne la postez jamais publiquement. Pour la production, utilisez un moyen sécurisé de stocker et d’accéder à vos informations d’identification comme Azure Key Vault. Pour plus d’informations, consultez l’article sur la sécurité d’Azure AI 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);
    }
}

Vérification dépendante du texte

La vérification de l’orateur est l’acte qui consiste à confirmer qu’un orateur correspond à une voix inscrite (connue). La première étape consiste à inscrire un profil vocal qui permet ensuite au service de comparer les futurs exemples de voix. Dans cet exemple, vous inscrivez le profil à l’aide d’une stratégie dépendante du texte, qui nécessite une phrase secrète spécifique à utiliser pour l’inscription et la vérification. Pour obtenir la liste des phrases secrètes prises en charge, consultez la documentation de référence.

Commencez par créer la fonction suivante dans votre classe Program pour inscrire un profil vocal :

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

Dans cette fonction, await client.CreateProfileAsync() est la commande qui crée le nouveau profil vocal. Une fois la fonction créée, vous spécifiez de quelle façon vous allez entrer des exemples audio, en utilisant AudioConfig.FromDefaultMicrophoneInput() dans cet exemple pour capturer l’audio de votre appareil d’entrée par défaut. Ensuite, inscrivez des exemples audio dans une boucle while qui effectue le suivi du nombre d’échantillons restants, et requis, pour l’inscription. Dans chaque itération, client.EnrollProfileAsync(profile, audioInput) vous invite à prononcer la phrase secrète dans votre microphone, puis ajoute l’échantillon au profil vocal.

Une fois l’inscription terminée, appelez await SpeakerVerify(config, profile, profileMapping) pour effectuer la vérification par rapport au profil que vous venez de créer. Ajoutez une autre fonction pour définir SpeakerVerify.

public static async Task SpeakerVerify(SpeechConfig config, VoiceProfile profile, Dictionary<string, string> profileMapping)
{
    var speakerRecognizer = new SpeakerRecognizer(config, AudioConfig.FromDefaultMicrophoneInput());
    var model = SpeakerVerificationModel.FromProfile(profile);

    Console.WriteLine("Speak the passphrase to verify: \"My voice is my passport, please verify me.\"");
    var result = await speakerRecognizer.RecognizeOnceAsync(model);
    Console.WriteLine($"Verified voice profile for speaker {profileMapping[result.ProfileId]}, score is {result.Score}");
}

Dans cette fonction, vous transmettez l’objet VoiceProfile que vous venez de créer pour initialiser un modèle à vérifier. Ensuite, await speakerRecognizer.RecognizeOnceAsync(model) vous invite à prononcer à nouveau la phrase secrète. Cette fois-ci, il la valide par rapport à votre profil vocal et retourne un score de similarité compris entre 0,0 et 1,0. L’objet result retourne également Accept ou Reject, selon que la phrase secrète correspond ou non.

Ensuite, modifiez votre fonction Main() pour qu’elle appelle les nouvelles fonctions que vous avez créées. Par ailleurs, notez que vous créez un Dictionary<string, string> à passer par référence via vos appels de fonction. Cela est dû au fait que le service n’autorise pas le stockage d’un nom lisible par l’utilisateur avec un VoiceProfile créé et qu’il stocke uniquement un ID à des fins de confidentialité. Dans la fonction VerificationEnroll, ajoutez à ce dictionnaire une entrée avec l’ID nouvellement créé, ainsi qu’un nom de texte. Dans les scénarios de développement d’applications où vous devez afficher un nom lisible par l’utilisateur, vous devez stocker ce mappage quelque part, car le service ne peut pas le stocker.

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

Exécutez le script. Vous êtes invité à prononcer l’expression Ma voix est mon passeport. Vérifiez-moi trois fois pour l’inscription et une autre fois pour la vérification. Le résultat retourné est le score de similarité, que vous pouvez utiliser pour créer vos propres seuils personnalisés pour la vérification.

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

Vérification indépendante du texte

Contrairement à la vérification dépendante du texte, la vérification indépendante du texte ne nécessite pas trois échantillons audio, mais elle nécessite 20 secondes de l’audio total.

Apportez quelques modifications simples à votre fonction VerificationEnroll pour basculer vers la vérification indépendante du texte. Tout d’abord, définissez le type de vérification sur VoiceProfileType.TextIndependentVerification. Ensuite, modifiez la boucle while pour suivre result.RemainingEnrollmentsSpeechLength, qui continuera à vous demander de parler jusqu’à ce que 20 secondes d’audio aient été capturées.

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

Réexécutez le programme, et le score de similarité est retourné.

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

Identification de l’orateur

L’identification de l’orateur est utilisée pour déterminer qui parle dans un groupe donné de voix inscrites. Le processus est similaire à la vérification indépendante du texte. La principale différence est la capacité à effectuer une vérification par rapport à plusieurs profils vocaux à la fois au lieu de vérifier un seul profil.

Créez une fonction IdentificationEnroll pour inscrire plusieurs profils vocaux. Le processus d’inscription pour chaque profil est le même que le processus d’inscription pour une vérification indépendante du texte. Le processus nécessite 20 secondes d’audio pour chaque profil. Cette fonction accepte une liste de chaînes profileNames et crée un profil vocal pour chaque nom de la liste. La fonction retourne une liste d’objets VoiceProfile, que vous utilisez dans la fonction suivante pour identifier un orateur.

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

Créez la fonction SpeakerIdentification suivante pour soumettre une demande d’identification. La principale différence dans cette fonction par rapport à une demande de vérification de l’orateur est l’utilisation de SpeakerIdentificationModel.FromProfiles(), qui accepte une liste d’objets VoiceProfile.

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

Remplacez votre fonction Main() par ce qui suit. Créez une liste de chaînes profileNamesque vous transmettez à votre fonction IdentificationEnroll(). Vous êtes alors invité à créer un profil vocal pour chaque nom de cette liste. Vous pouvez donc ajouter d’autres noms pour créer des profils supplémentaires pour vos amis ou vos collègues.

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

Exécutez le script. Vous êtes invité à entrer des exemples d’inscription de voix pour le premier profil. Une fois l’inscription terminée, vous êtes invité à répéter ce processus pour chaque nom figurant dans la liste profileNames. Une fois chaque inscription terminée, vous êtes invité à demander à quiconque de parler. Le service tente ensuite d’identifier cette personne parmi vos profils vocaux inscrits.

Cet exemple retourne uniquement la correspondance la plus proche et son score de similarité. Pour obtenir la réponse complète qui comprend les cinq meilleurs scores de similarité, ajoutez string json = result.Properties.GetProperty(PropertyId.SpeechServiceResponse_JsonResult) à votre fonction SpeakerIdentification.

Modifier le type d’entrée audio

Les exemples de cet article utilisent le microphone d’appareil par défaut comme entrée pour les exemples audio. Dans les scénarios où vous devez utiliser des fichiers audio à la place d’une entrée de microphone, définissez une instance de AudioConfig.FromDefaultMicrophoneInput() sur AudioConfig.FromWavFileInput(path/to/your/file.wav) pour basculer vers une entrée de fichier. Vous pouvez également avoir des entrées mixtes, à l’aide d’un microphone pour l’inscription et de fichiers pour la vérification par exemple.

Suppression des inscriptions de profil vocal

Pour supprimer un profil inscrit, utilisez la fonction DeleteProfileAsync() sur l’objet VoiceProfileClient. L’exemple de fonction suivant montre comment supprimer un profil vocal d’un ID de profil vocal connu :

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

Documentation de référencePackage (NuGet)Exemples supplémentaires sur GitHub

Dans ce guide de démarrage rapide, vous allez découvrir les modèles de conception de base pour la reconnaissance de l’orateur à l’aide du SDK de reconnaissance vocale, notamment :

  • Vérification dépendante ou indépendante du texte.
  • Identification de l’orateur pour identifier un échantillon vocal parmi un groupe de voix.
  • Suppression de profils vocaux.

Pour obtenir une vue d’ensemble des concepts de reconnaissance de l’orateur, consultez l’article de présentation. Voir le nœud de référence dans le volet de gauche pour une liste des plateformes prises en charge.

Important

Microsoft limite l’accès à la Reconnaissance de l’orateur. Demandez à l’utiliser par le biais du formulaire Examen de l’accès limité à Reconnaissance de l’orateur Azure AI. Après approbation, vous pouvez accéder aux API de reconnaissance des locuteurs.

Prérequis

Installer le Kit de développement logiciel (SDK) Speech

Avant de commencer, vous devez installer le kit de développement logiciel (SDK) Speech. Suivez les instructions ci-dessous, en fonction de votre plateforme :

Importer les dépendances

Pour exécuter les exemples de cet article, ajoutez les instructions suivantes en haut de votre fichier .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;

Créer une configuration Speech

Pour appeler le service Speech à l’aide du kit de développement logiciel (SDK) Speech, créez une classe SpeechConfig. Celle-ci comprend des informations sur votre abonnement, telles que votre clé et la région, le point de terminaison, l’hôte ou le jeton d’autorisation associés.

Important

N’oubliez pas de supprimer la clé de votre code une fois que vous avez terminé, et ne la postez jamais publiquement. Pour la production, utilisez un moyen sécurisé de stocker et d’accéder à vos informations d’identification comme Azure Key Vault. Pour plus d’informations, consultez l’article sur la sécurité d’Azure AI 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;
}

Vérification dépendante du texte

La vérification de l’orateur est l’acte qui consiste à confirmer qu’un orateur correspond à une voix inscrite (connue). La première étape consiste à inscrire un profil vocal qui permet ensuite au service de comparer les futurs exemples de voix. Dans cet exemple, vous inscrivez le profil à l’aide d’une stratégie dépendante du texte, qui nécessite une phrase secrète spécifique à utiliser pour l’inscription et la vérification. Pour obtenir la liste des phrases secrètes prises en charge, consultez la documentation de référence.

Fonction TextDependentVerification

Commencez par créer la fonction TextDependentVerification :

void TextDependentVerification(shared_ptr<VoiceProfileClient> client, shared_ptr<SpeakerRecognizer> recognizer)
{
    std::cout << "Text Dependent Verification:\n\n";
    // Create the profile.
    auto profile = client->CreateProfileAsync(VoiceProfileType::TextDependentVerification, profile_locale).get();
    std::cout << "Created profile ID: " << profile->GetId() << "\n";
    AddEnrollmentsToTextDependentProfile(client, profile);
    SpeakerVerify(profile, recognizer);
    // Delete the profile.
    client->DeleteProfileAsync(profile);
}

Cette fonction crée un objet VoiceProfile à l’aide de la méthode CreateProfileAsync. Il existe trois types de VoiceProfile :

  • TextIndependentIdentification
  • TextDependentVerification
  • TextIndependentVerification

En l’occurrence, vous transmettez VoiceProfileType::TextDependentVerification à CreateProfileAsync.

Vous appelez ensuite deux fonctions d’assistance que vous allez définir ci-après, AddEnrollmentsToTextDependentProfile et SpeakerVerify. Enfin, appelez DeleteProfileAsync pour nettoyer le profil.

Fonction AddEnrollmentsToTextDependentProfile

Définissez la fonction suivante pour inscrire un profil vocal :

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

Dans cette fonction, inscrivez des échantillons audio dans une boucle while qui effectue le suivi du nombre d’échantillons restants, et requis, pour l’inscription. Dans chaque itération, EnrollProfileAsync vous invite à prononcer la phrase secrète dans votre microphone, puis ajoute l’échantillon au profil vocal.

Fonction SpeakerVerify

Définissez SpeakerVerify comme suit :

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

Dans cette fonction, vous créez un objet SpeakerVerificationModel avec la méthode SpeakerVerificationModel::FromProfile, en passant l’objet VoiceProfile que vous avez créé.

Ensuite, SpeechRecognizer::RecognizeOnceAsync vous réinvite à prononcer la phrase secrète. Cette fois-ci, il la valide par rapport à votre profil vocal et retourne un score de similarité compris entre 0,0 et 1,0. L’objet SpeakerRecognitionResult retourne également Accept ou Reject, selon que la phrase secrète correspond ou non.

Vérification indépendante du texte

Contrairement à la vérification dépendante du texte, la vérification indépendante du texte ne nécessite pas trois échantillons audio, mais elle nécessite 20 secondes de l’audio total.

Fonction TextIndependentVerification

Commencez par créer la fonction TextIndependentVerification :

void TextIndependentVerification(shared_ptr<VoiceProfileClient> client, shared_ptr<SpeakerRecognizer> recognizer)
{
    std::cout << "Text Independent Verification:\n\n";
    // Create the profile.
    auto profile = client->CreateProfileAsync(VoiceProfileType::TextIndependentVerification, profile_locale).get();
    std::cout << "Created profile ID: " << profile->GetId() << "\n";
    AddEnrollmentsToTextIndependentProfile(client, profile);
    SpeakerVerify(profile, recognizer);
    // Delete the profile.
    client->DeleteProfileAsync(profile);
}

À l’instar de la fonction TextDependentVerification, cette fonction crée un objet VoiceProfile avec la méthode CreateProfileAsync.

En l’occurrence, vous transmettez VoiceProfileType::TextIndependentVerification à CreateProfileAsync.

Vous appelez ensuite deux fonctions d’assistance : AddEnrollmentsToTextIndependentProfile, que vous allez définir ci-après et SpeakerVerify, que vous avez déjà définie. Enfin, appelez DeleteProfileAsync pour nettoyer le profil.

AddEnrollmentsToTextIndependentProfile

Définissez la fonction suivante pour inscrire un profil vocal :

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

Dans cette fonction, inscrivez des échantillons audio dans une boucle while qui effectue le suivi du nombre de secondes d’audio restantes, et requises, pour l’inscription. Dans chaque itération, EnrollProfileAsync vous invite à parler dans votre microphone, puis ajoute l’échantillon au profil vocal.

Identification de l’orateur

L’identification de l’orateur est utilisée pour déterminer qui parle dans un groupe donné de voix inscrites. Le processus est similaire à la vérification indépendante du texte. La principale différence est la capacité à effectuer une vérification par rapport à plusieurs profils vocaux à la fois au lieu de vérifier un seul profil.

Fonction TextIndependentIdentification

Commencez par créer la fonction TextIndependentIdentification :

void TextIndependentIdentification(shared_ptr<VoiceProfileClient> client, shared_ptr<SpeakerRecognizer> recognizer)
{
    std::cout << "Speaker Identification:\n\n";
    // Create the profile.
    auto profile = client->CreateProfileAsync(VoiceProfileType::TextIndependentIdentification, profile_locale).get();
    std::cout << "Created profile ID: " << profile->GetId() << "\n";
    AddEnrollmentsToTextIndependentProfile(client, profile);
    SpeakerIdentify(profile, recognizer);
    // Delete the profile.
    client->DeleteProfileAsync(profile);
}

À l’instar de la fonction TextDependentVerification et TextIndependentVerification, cette fonction crée un objet VoiceProfile avec la méthode CreateProfileAsync.

En l’occurrence, vous transmettez VoiceProfileType::TextIndependentIdentification à CreateProfileAsync.

Vous appelez ensuite deux fonctions d’assistance : AddEnrollmentsToTextIndependentProfile, que vous avez déjà définie, et SpeakerIdentify, que vous allez définir ci-après. Enfin, appelez DeleteProfileAsync pour nettoyer le profil.

Fonction SpeakerIdentify

Définissez la fonction SpeakerIdentify comme suit :

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

Dans cette fonction, vous créez un objet SpeakerIdentificationModel avec la méthode SpeakerIdentificationModel::FromProfiles. SpeakerIdentificationModel::FromProfiles accepte une liste d’objets VoiceProfile. En l’occurrence, vous transmettez l’objet VoiceProfile que vous avez créé. Si vous le souhaitez, vous pouvez transmettre plusieurs objets VoiceProfile, chacun étant inscrit avec des échantillons audio à partir d’une voix différente.

Ensuite, SpeechRecognizer::RecognizeOnceAsync vous réinvite à parler. Cette fois-ci, elle compare votre voix aux profils vocaux inscrits et retourne le profil vocal le plus similaire.

Fonction main

Enfin, définissez la fonction main comme suit :

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

Cette fonction appelle les fonctions que vous avez définies. Elle crée d’abord un objet VoiceProfileClient et un objet SpeakerRecognizer.

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

L’objet VoiceProfileClient permet de créer, d’inscrire et de supprimer des profils vocaux. L’objet SpeakerRecognizer est utilisé pour valider des échantillons vocaux sur un ou plusieurs profils vocaux inscrits.

Modifier le type d’entrée audio

Les exemples de cet article utilisent le microphone d’appareil par défaut comme entrée pour les exemples audio. Dans les scénarios où vous devez utiliser des fichiers audio à la place d’une entrée de microphone, changez la ligne suivante :

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

à :

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

Ou remplacez toute utilisation de audio_config par Audio::AudioConfig::FromWavFileInput. Vous pouvez également avoir des entrées mixtes, à l’aide d’un microphone pour l’inscription et de fichiers pour la vérification par exemple.

Documentation de référencePackage (Go)Exemples supplémentaires sur GitHub

Dans ce guide de démarrage rapide, vous allez découvrir les modèles de conception de base pour la reconnaissance de l’orateur à l’aide du SDK de reconnaissance vocale, notamment :

  • Vérification dépendante ou indépendante du texte.
  • Identification de l’orateur pour identifier un échantillon vocal parmi un groupe de voix.
  • Suppression de profils vocaux.

Pour obtenir une vue d’ensemble des concepts de reconnaissance de l’orateur, consultez l’article de présentation. Voir le nœud de référence dans le volet de gauche pour une liste des plateformes prises en charge.

Important

Microsoft limite l’accès à la Reconnaissance de l’orateur. Demandez à l’utiliser par le biais du formulaire Examen de l’accès limité à Reconnaissance de l’orateur Azure AI. Après approbation, vous pouvez accéder aux API de reconnaissance des locuteurs.

Prérequis

Configurer l’environnement

Installer le Kit SDK Speech pour Go. Vérifiez le Guide d’installation SDK pour toute information complémentaire

Effectuer une Identification indépendante

Pour créer un nouveau module GO, procédez comme suit.

  1. Ouvrez une invite de commandes à l’emplacement où vous souhaitez placer le nouveau module, puis créez un nouveau fichier nommé independent-identification.go.

  2. Remplacez le contenu de independent-identification.go par le code suivant.

    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. Dans independent-identification.go, remplacez YourSubscriptionKey par votre clé de ressource Speech et remplacez YourServiceRegion par votre région de ressource Speech.

    Important

    N’oubliez pas de supprimer la clé de votre code une fois que vous avez terminé, et ne la postez jamais publiquement. Pour la production, utilisez un moyen sécurisé de stocker et d’accéder à vos informations d’identification comme Azure Key Vault. Pour plus d’informations, consultez l’article sur la sécurité d’Azure AI services.

Exécutez les commandes suivantes pour créer un fichier go.mod lié aux composants hébergés sur GitHub :

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

Maintenant, générez et exécutez le code :

go build
go run independent-identification

Effectuer une vérification indépendante

Pour créer un nouveau module GO, procédez comme suit.

  1. Ouvrez une invite de commandes à l’emplacement où vous souhaitez placer le nouveau module, puis créez un nouveau fichier nommé independent-verification.go.

  2. Remplacez le contenu de independent-verification.go par le code suivant.

    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. Dans independent-verification.go, remplacez YourSubscriptionKey par votre clé de ressource Speech et remplacez YourServiceRegion par votre région de ressource Speech.

Exécutez les commandes suivantes pour créer un fichier go.mod lié aux composants hébergés sur GitHub :

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

Maintenant, générez et exécutez le code :

go build
go run independent-verification

Nettoyer les ressources

Vous pouvez utiliser le portail Azure ou l’interface de ligne de commande (CLI) Azure pour supprimer la ressource Speech que vous avez créée.

Documentation de référence | Exemples supplémentaires sur GitHub

Le kit de développement logiciel (SDK) Speech pour Java prend en charge la reconnaissance de l’orateur, mais nous n’avons pas encore inclus de guide ici. Sélectionnez un autre langage de programmation pour commencer et découvrir les concepts, ou consultez la référence Java et les exemples liés au début de cet article.

Documentation de référencePackage (npm)Exemples supplémentaires sur GitHubCode source de la bibliothèque

Dans ce guide de démarrage rapide, vous allez découvrir les modèles de conception de base pour la reconnaissance de l’orateur à l’aide du SDK de reconnaissance vocale, notamment :

  • Vérification dépendante ou indépendante du texte.
  • Identification de l’orateur pour identifier un échantillon vocal parmi un groupe de voix.
  • Suppression de profils vocaux.

Pour obtenir une vue d’ensemble des concepts de reconnaissance de l’orateur, consultez l’article de présentation. Voir le nœud de référence dans le volet de gauche pour une liste des plateformes prises en charge.

Important

Microsoft limite l’accès à la Reconnaissance de l’orateur. Demandez à l’utiliser par le biais du formulaire Examen de l’accès limité à Reconnaissance de l’orateur Azure AI. Après approbation, vous pouvez accéder aux API de reconnaissance des locuteurs.

Prérequis

Installer le Kit de développement logiciel (SDK) Speech

Avant de commencer, vous devez installer le Kit de développement logiciel (SDK) Speech pour JavaScript.

Selon l’environnement cible, utilisez l’un des éléments suivants :

Téléchargez et extrayez le fichier microsoft.cognitiveservices.speech.sdk.bundle.js du Kit de développement logiciel (SDK) Speech pour JavaScript. Placez-le dans un dossier accessible à votre fichier HTML.

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

Conseil

Si vous ciblez un navigateur web et que vous utilisez l’étiquette <script>, le préfixe sdk n’est pas nécessaire. Le préfixe sdk est un alias utilisé pour nommer le module require.

Importer les dépendances

Pour exécuter les exemples de cet article, ajoutez les instructions suivantes en haut de votre fichier .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;

Ces instructions importent les bibliothèques requises et récupèrent la clé et la région de votre abonnement au service Speech à partir de vos variables d’environnement. Elles spécifient également les chemins des fichiers audio que vous allez utiliser dans les tâches suivantes.

Important

N’oubliez pas de supprimer la clé de votre code une fois que vous avez terminé, et ne la postez jamais publiquement. Pour la production, utilisez un moyen sécurisé de stocker et d’accéder à vos informations d’identification comme Azure Key Vault. Pour plus d’informations, consultez l’article sur la sécurité d’Azure AI services.

Créer la fonction d’assistance

Ajoutez la fonction d’assistance suivante pour lire les fichiers audio dans les flux en vue d’une utilisation par le service Speech :

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

Dans cette fonction, vous utilisez les méthodes AudioInputStream.createPushStream et AudioConfig.fromStreamInput pour créer un objet AudioConfig. Cet objet AudioConfig représente un flux audio. Vous utiliserez plusieurs de ces objets AudioConfig lors des tâches suivantes.

Vérification dépendante du texte

La vérification de l’orateur est l’acte qui consiste à confirmer qu’un orateur correspond à une voix inscrite (connue). La première étape consiste à inscrire un profil vocal qui permet ensuite au service de comparer les futurs exemples de voix. Dans cet exemple, vous inscrivez le profil à l’aide d’une stratégie dépendante du texte, qui nécessite une phrase secrète spécifique à utiliser pour l’inscription et la vérification. Pour obtenir la liste des phrases secrètes prises en charge, consultez la documentation de référence.

Fonction TextDependentVerification

Commencez par créer la fonction 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);
        }
    }
}

Cette fonction crée un objet VoiceProfile à l’aide de la méthode VoiceProfileClient.createProfileAsync. Il existe trois types de VoiceProfile :

  • TextIndependentIdentification
  • TextDependentVerification
  • TextIndependentVerification

En l’occurrence, vous transmettez VoiceProfileType.TextDependentVerification à VoiceProfileClient.createProfileAsync.

Vous appelez ensuite deux fonctions d’assistance que vous allez définir ci-après, AddEnrollmentsToTextDependentProfile et SpeakerVerify. Enfin, appelez VoiceProfileClient.deleteProfileAsync pour supprimer le profil.

Fonction AddEnrollmentsToTextDependentProfile

Définissez la fonction suivante pour inscrire un profil vocal :

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

Dans cette fonction, vous appelez la fonction GetAudioConfigFromFile que vous avez définie, pour créer des objets AudioConfig à partir d’échantillons audio. Ces échantillons audio contiennent une phrase de passe telle que "Ma voix est mon passeport, vérifiez-moi". Vous enregistrez ensuite ces échantillons audio à l’aide de la méthode VoiceProfileClient.enrollProfileAsync.

Fonction SpeakerVerify

Définissez SpeakerVerify comme suit :

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

Dans cette fonction, vous créez un objet SpeakerVerificationModel avec la méthode SpeakerVerificationModel.FromProfile, en passant l’objet VoiceProfile que vous avez créé.

Ensuite, vous appelez la méthode SpeechRecognizer.recognizeOnceAsync pour valider un échantillon audio qui contient la même phrase secrète que les échantillons audio que vous avez inscrits. SpeechRecognizer.recognizeOnceAsync retourne un objet SpeakerRecognitionResult, dont la propriété score contient un score de similarité compris entre 0,0 et 1,0. L’objet SpeakerRecognitionResult contient également une propriété reason de type ResultReason. Si la vérification a réussi, la propriété reason doit avoir la valeur RecognizedSpeaker.

Vérification indépendante du texte

Contrairement à la vérification dépendante du texte, la vérification indépendante du texte :

  • Ne requiert pas de phrase secrète spécifique. Vous pouvez dire ce que vous souhaitez.
  • Ne nécessite pas trois échantillons audio, mais nécessite 20 secondes d’audio en tout.

Fonction TextIndependentVerification

Commencez par créer la fonction 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);
        }
    }
}

À l’instar de la fonction TextDependentVerification, cette fonction crée un objet VoiceProfile avec la méthode VoiceProfileClient.createProfileAsync.

En l’occurrence, vous transmettez VoiceProfileType.TextIndependentVerification à createProfileAsync.

Vous appelez ensuite deux fonctions d’assistance : AddEnrollmentsToTextIndependentProfile, que vous allez définir ci-après et SpeakerVerify, que vous avez déjà définie. Enfin, appelez VoiceProfileClient.deleteProfileAsync pour supprimer le profil.

AddEnrollmentsToTextIndependentProfile

Définissez la fonction suivante pour inscrire un profil vocal :

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

Dans cette fonction, vous appelez la fonction GetAudioConfigFromFile que vous avez définie, pour créer des objets AudioConfig à partir d’échantillons audio. Vous inscrivez ensuite ces échantillons audio à l’aide de la méthode VoiceProfileClient.enrollProfileAsync.

Identification de l’orateur

L’identification de l’orateur est utilisée pour déterminer qui parle dans un groupe donné de voix inscrites. Le processus est similaire à la vérification indépendante du texte. La principale différence est la capacité à effectuer une vérification par rapport à plusieurs profils vocaux à la fois au lieu de vérifier un seul profil.

Fonction TextIndependentIdentification

Commencez par créer la fonction 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);
        }
    }
}

À l’instar des fonctions TextDependentVerification et TextIndependentVerification, cette fonction crée un objet VoiceProfile avec la méthode VoiceProfileClient.createProfileAsync.

En l’occurrence, vous transmettez VoiceProfileType.TextIndependentIdentification à VoiceProfileClient.createProfileAsync.

Vous appelez ensuite deux fonctions d’assistance : AddEnrollmentsToTextIndependentProfile, que vous avez déjà définie, et SpeakerIdentify, que vous allez définir ci-après. Enfin, appelez VoiceProfileClient.deleteProfileAsync pour supprimer le profil.

Fonction SpeakerIdentify

Définissez la fonction SpeakerIdentify comme suit :

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

Dans cette fonction, vous créez un objet SpeakerIdentificationModel avec la méthode SpeakerIdentificationModel.fromProfiles, en passant l’objet VoiceProfile que vous avez créé.

Ensuite, vous appelez la méthode SpeechRecognizer.recognizeOnceAsync et transmettez un échantillon audio. SpeechRecognizer.recognizeOnceAsync tente d’identifier la voix pour cet échantillon audio en fonction des objets VoiceProfile que vous avez utilisés pour créer le SpeakerIdentificationModel. Elle retourne un objet SpeakerRecognitionResult, dont la propriété profileId identifie le VoiceProfile correspondant éventuel, tandis que la propriété score contient un score de similarité compris entre 0,0 et 1,0.

Fonction main

Enfin, définissez la fonction main comme suit :

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

Cette fonction crée un objet VoiceProfileClient, qui permet de créer, d’inscrire et de supprimer des profils vocaux. Elle appelle ensuite les fonctions que vous avez définies.

Documentation de référencePackage (Télécharger)Exemples supplémentaires sur GitHub

Le SDK Speech pour Objective-C ne prend pas en charge la reconnaissance de l’orateur. Sélectionnez un autre langage de programmation, ou la référence Objective-C et des exemples liés au début de cet article.

Documentation de référencePackage (Télécharger)Exemples supplémentaires sur GitHub

Le SDK Speech pour Swift ne prend pas en charge la reconnaissance de l’orateur. Sélectionnez un autre langage de programmation, ou la référence Swift et des exemples liés au début de cet article.

Documentation de référencePackage (PyPi)Exemples supplémentaires sur GitHub

Le SDK Speech pour Python ne prend pas en charge la reconnaissance de l’orateur. Sélectionnez un autre langage de programmation, ou la référence Python et des exemples liés au début de cet article.

Informations de référence sur l’API REST de reconnaissance vocale | Informations de référence sur l’API REST de reconnaissance vocale pour audio court | Exemples supplémentaires sur GitHub

Dans ce guide de démarrage rapide, vous allez découvrir les modèles de conception de base pour la reconnaissance de l’orateur à l’aide du SDK de reconnaissance vocale, notamment :

  • Vérification dépendante ou indépendante du texte.
  • Identification de l’orateur pour identifier un échantillon vocal parmi un groupe de voix.
  • Suppression de profils vocaux.

Pour obtenir une vue d’ensemble des concepts de reconnaissance de l’orateur, consultez l’article de présentation. Voir le nœud de référence dans le volet de gauche pour une liste des plateformes prises en charge.

Important

Microsoft limite l’accès à la Reconnaissance de l’orateur. Demandez à l’utiliser par le biais du formulaire Examen de l’accès limité à Reconnaissance de l’orateur Azure AI. Après approbation, vous pouvez accéder aux API de reconnaissance des locuteurs.

Prérequis

Vérification dépendante du texte

La vérification de l’orateur est l’acte qui consiste à confirmer qu’un orateur correspond à une voix inscrite (connue). La première étape consiste à inscrire un profil vocal qui permet ensuite au service de comparer les futurs exemples de voix. Dans cet exemple, vous inscrivez le profil à l’aide d’une stratégie dépendante du texte, qui nécessite une phrase secrète spécifique à utiliser pour l’inscription et la vérification. Pour obtenir la liste des phrases secrètes prises en charge, consultez la documentation de référence.

Commencez par créer un profil vocal. Vous devrez insérer la clé et la région de votre abonnement au service Speech dans chacune des commandes curl de cet article.

Important

N’oubliez pas de supprimer la clé de votre code une fois que vous avez terminé, et ne la postez jamais publiquement. Pour la production, utilisez un moyen sécurisé de stocker et d’accéder à vos informations d’identification comme Azure Key Vault. Pour plus d’informations, consultez l’article sur la sécurité d’Azure AI 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'\''
}'

Il existe trois types de profils vocaux :

  • Vérification dépendante du texte
  • Vérification indépendante du texte
  • Identification indépendante du texte

En l’occurrence, vous créez un profil vocal de vérification dépendante du texte. Vous devez recevoir la réponse suivante :

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

Ensuite, vous inscrivez le profil vocal. Pour la --data-binary valeur du paramètre, spécifiez un fichier audio sur votre ordinateur qui contient l’une des phrases secrètes prises en charge, par exemple « ma voix est mon passeport, vérifiez-moi ». Vous pouvez enregistrer un tel fichier audio à l’aide d’une application telle que Windows Voice Recorder. Vous pouvez également le générer à l’aide de la conversion de texte par synthèse vocale.

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'

Vous devez recevoir la réponse suivante :

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

Cette réponse vous indique que vous devez inscrire deux échantillons audio supplémentaires.

Une fois que vous avez inscrit un total de trois échantillons audio, vous devez recevoir la réponse suivante :

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

Vous êtes maintenant prêt à vérifier un échantillon audio par rapport au profil vocal. Cet échantillon audio doit contenir la même phrase secrète que les échantillons que vous avez utilisés pour inscrire le profil vocal.

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'

Vous devez recevoir la réponse suivante :

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

Accept signifie que la phrase secrète a correspondu et que la vérification a réussi. La réponse contient également un score de similarité compris entre 0,0 et 1,0.

Pour terminer, supprimez le profil vocal.

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'

Il n’y a pas de réponse.

Vérification indépendante du texte

Contrairement à la vérification dépendante du texte, la vérification indépendante du texte :

  • Ne requiert pas de phrase secrète spécifique. Vous pouvez dire ce que vous souhaitez.
  • Ne nécessite pas trois échantillons audio, mais nécessite 20 secondes d’audio en tout.

Commencez par créer un profil de vérification indépendante du texte.

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

Vous devez recevoir la réponse suivante :

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

Ensuite, inscrivez le profil vocal. Là encore, au lieu de soumettre trois échantillons audio, vous devez soumettre des échantillons audio qui contiennent un total de 20 secondes d’audio.

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'

Une fois que vous avez soumis suffisamment d’échantillons audio, vous devez recevoir la réponse suivante :

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

Vous êtes maintenant prêt à vérifier un échantillon audio par rapport au profil vocal. Là encore, cet échantillon audio n’a pas besoin de contenir de phrase secrète. Il peut contenir n’importe quelles données vocales, à condition qu’elles représentent au moins quatre secondes d’audio.

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'

Vous devez recevoir la réponse suivante :

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

Accept signifie que la vérification a réussi. La réponse contient également un score de similarité compris entre 0,0 et 1,0.

Pour terminer, supprimez le profil vocal.

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'

Il n’y a pas de réponse.

Identification de l’orateur

L’identification de l’orateur est utilisée pour déterminer qui parle dans un groupe donné de voix inscrites. Le processus est similaire à la vérification indépendante du texte. La principale différence est la capacité à effectuer une vérification par rapport à plusieurs profils vocaux à la fois au lieu de vérifier un seul profil.

Commencez par créer un profil d’identification indépendante du texte.

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

Vous devez recevoir la réponse suivante :

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

Ensuite, vous inscrivez le profil vocal. Là encore, vous devez soumettre des échantillons audio qui contiennent un total de 20 secondes d’audio. Ces échantillons n’ont pas besoin de contenir de phrase secrète.

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'

Une fois que vous avez soumis suffisamment d’échantillons audio, vous devez recevoir la réponse suivante :

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

Vous êtes maintenant prêt à identifier un échantillon audio à l’aide du profil vocal. La commande d’identification accepte une liste d’ID de profils vocaux possibles séparés par des virgules. En l’occurrence, vous transmettez l’ID du profil vocal que vous avez créé. Si vous le souhaitez, vous pouvez transmettre plusieurs ID de profils vocaux, chaque profil étant inscrit avec des échantillons audio à partir d’une voix différente.

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

Vous devez recevoir la réponse suivante :

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

La réponse contient l’ID du profil vocal qui correspond le plus à l’échantillon audio que vous avez soumis. Elle contient également une liste des profils vocaux candidats, classés par ordre de similarité.

Pour terminer, supprimez le profil vocal.

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'

Il n’y a pas de réponse.

L’interface CLI Speech pour Java prend en charge la reconnaissance de l’orateur, mais nous n’avons pas encore inclus de guide ici. Sélectionnez un autre langage de programmation pour commencer et découvrir les concepts.

Étapes suivantes

Voir les exemples de démarrage rapide sur GitHub