Comment effectuer la reconnaissance vocale

Documentation de référence | Package (NuGet) | Exemples supplémentaires sur GitHub

Dans ce guide pratique, vous allez apprendre à utiliser Azure AI Speech pour la reconnaissance vocale en temps réel. La reconnaissance vocale en temps réel est idéale pour les applications nécessitant une transcription immédiate, comme la dictée, l’assistance en centre d’appels et le sous-titrage pour les réunions en direct.

Pour découvrir comment configurer l’environnement pour un exemple d’application, consultez Démarrage rapide : Reconnaître et convertir la parole en texte.

Créer une instance de configuration Speech

Pour appeler le service Speech à l’aide du SDK Speech, vous devez créer une instance 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.

1. Créez une ressource Speech dans le portail Azure. Obtenez la clé de ressource et la région Speech.
2. Créez une instance SpeechConfig à l’aide du code suivant. Remplacez YourSpeechKey et YourSpeechRegion par votre clé de ressource Speech et votre région.

using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Audio;

class Program 
{
    async static Task Main(string[] args)
    {
        var speechConfig = SpeechConfig.FromSubscription("YourSpeechKey", "YourSpeechRegion");
    }
}

Vous pouvez initialiser SpeechConfig de plusieurs autres façons :

• Utilisez un point de terminaison et transmettez un point de terminaison de service Speech. Une clé ou un jeton d’autorisation est facultatif.
• Utilisez un hôte et transmettez une adresse d’hôte. Une clé ou un jeton d’autorisation est facultatif.
• Utilisez un jeton d’autorisation avec la région/l’emplacement associé.

Remarque

Quand vous procédez à une reconnaissance vocale, une synthèse vocale, une traduction ou une reconnaissance intentionnelle, vous créez toujours une configuration.

Reconnaître la voix provenant d’un micro

Pour reconnaître la voix à l’aide du microphone de votre appareil, créez une instance AudioConfig en utilisant la méthode FromDefaultMicrophoneInput(). Initialisez ensuite l’objet SpeechRecognizer en transmettant speechConfig et audioConfig.

using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Audio;

class Program 
{
    async static Task FromMic(SpeechConfig speechConfig)
    {
        using var audioConfig = AudioConfig.FromDefaultMicrophoneInput();
        using var speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);

        Console.WriteLine("Speak into your microphone.");
        var speechRecognitionResult = await speechRecognizer.RecognizeOnceAsync();
        Console.WriteLine($"RECOGNIZED: Text={speechRecognitionResult.Text}");
    }

    async static Task Main(string[] args)
    {
        var speechConfig = SpeechConfig.FromSubscription("YourSpeechKey", "YourSpeechRegion");
        await FromMic(speechConfig);
    }
}

Si vous souhaitez utiliser un périphérique d’entrée audio spécifique, vous devez spécifier son ID dans AudioConfig. Pour découvrir comment obtenir l’ID de l’appareil, consultez Sélectionner un appareil d’entrée audio avec le Kit de développement logiciel (SDK) Speech.

Utiliser la reconnaissance vocale à partir d’un fichier

Si vous souhaitez reconnaître la voix à partir d’un fichier audio au lieu d’utiliser un microphone, vous devez quand même créer une instance AudioConfig. Toutefois, vous n’appelez pas FromDefaultMicrophoneInput(). Vous appelez FromWavFileInput() et transmettez le chemin d’accès au fichier :

using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Audio;

class Program 
{
    async static Task FromFile(SpeechConfig speechConfig)
    {
        using var audioConfig = AudioConfig.FromWavFileInput("PathToFile.wav");
        using var speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);

        var speechRecognitionResult = await speechRecognizer.RecognizeOnceAsync();
        Console.WriteLine($"RECOGNIZED: Text={speechRecognitionResult.Text}");
    }

    async static Task Main(string[] args)
    {
        var speechConfig = SpeechConfig.FromSubscription("YourSpeechKey", "YourSpeechRegion");
        await FromFile(speechConfig);
    }
}

Reconnaître la parole à partir d’un flux en mémoire

Dans de nombreux cas d’usage, il est probable que vos données audio proviennent d’un Stockage Blob Azure ou qu’elles soient déjà en mémoire comme une instance byte[] ou une structure de données brutes similaire. L’exemple suivant utilise PushAudioInputStream pour reconnaître la voix, qui est essentiellement un flux en mémoire abstrait. L’exemple de code effectue les actions suivantes :

• Écrit des données audio brutes dans PushAudioInputStream à l’aide de la fonction Write(), qui accepte une instance byte[].
• Lit un fichier .wav en utilisant FileReader à des fins de démonstration. Si vous avez déjà des données audio dans une instance byte[], vous pouvez passer directement à l’écriture du contenu dans le flux d’entrée.
• Par défaut, les données sont au format modulation par impulsion et codage (PCM) mono 16 kHz 16 bits. Pour personnaliser le format, vous pouvez passer un objet AudioStreamFormat à CreatePushStream() en utilisant la fonction statique AudioStreamFormat.GetWaveFormatPCM(sampleRate, (byte)bitRate, (byte)channels).

using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Audio;

class Program 
{
    async static Task FromStream(SpeechConfig speechConfig)
    {
        var reader = new BinaryReader(File.OpenRead("PathToFile.wav"));
        using var audioConfigStream = AudioInputStream.CreatePushStream();
        using var audioConfig = AudioConfig.FromStreamInput(audioConfigStream);
        using var speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);

        byte[] readBytes;
        do
        {
            readBytes = reader.ReadBytes(1024);
            audioConfigStream.Write(readBytes, readBytes.Length);
        } while (readBytes.Length > 0);

        var speechRecognitionResult = await speechRecognizer.RecognizeOnceAsync();
        Console.WriteLine($"RECOGNIZED: Text={speechRecognitionResult.Text}");
    }

    async static Task Main(string[] args)
    {
        var speechConfig = SpeechConfig.FromSubscription("YourSpeechKey", "YourSpeechRegion");
        await FromStream(speechConfig);
    }
}

L’utilisation d’un flux push comme entrée part du principe que les données audio sont des données au format PCM brut qui ignorent les en-têtes. L’API fonctionne toujours dans certains cas si l’en-tête n’est pas ignoré. Pour obtenir les meilleurs résultats, envisagez d’implémenter une logique pour lire les en-têtes afin que byte[] commence au début des données audio.

Gérer les erreurs

Les exemples précédents récupèrent seulement le texte reconnu de la propriété speechRecognitionResult.Text. Pour gérer les erreurs et autres réponses, vous devez écrire du code pour gérer le résultat. Le code suivant évalue la propriété speechRecognitionResult.Reason et :

• Affiche le résultat de la reconnaissance : ResultReason.RecognizedSpeech.
• S’il n’existe aucune correspondance de reconnaissance, l’utilisateur est informé : ResultReason.NoMatch.
• Si une erreur se produit, un message d’erreur est affiché : ResultReason.Canceled.

switch (speechRecognitionResult.Reason)
{
    case ResultReason.RecognizedSpeech:
        Console.WriteLine($"RECOGNIZED: Text={speechRecognitionResult.Text}");
        break;
    case ResultReason.NoMatch:
        Console.WriteLine($"NOMATCH: Speech could not be recognized.");
        break;
    case ResultReason.Canceled:
        var cancellation = CancellationDetails.FromResult(speechRecognitionResult);
        Console.WriteLine($"CANCELED: Reason={cancellation.Reason}");

        if (cancellation.Reason == CancellationReason.Error)
        {
            Console.WriteLine($"CANCELED: ErrorCode={cancellation.ErrorCode}");
            Console.WriteLine($"CANCELED: ErrorDetails={cancellation.ErrorDetails}");
            Console.WriteLine($"CANCELED: Did you set the speech resource key and region values?");
        }
        break;
}

Utiliser la reconnaissance continue

Les exemples précédents utilisent la reconnaissance unique, qui reconnaît un énoncé unique. La fin d’un énoncé unique est déterminée par la détection du silence à la fin, ou après que 15 secondes d’audio ont été traitées.

En revanche, vous utilisez la reconnaissance continue quand vous souhaitez contrôler à quel moment arrêter la reconnaissance. Pour obtenir les résultats de la reconnaissance, vous devez vous abonner aux événements Recognizing, Recognized et Canceled. Pour arrêter la reconnaissance, vous devez appeler StopContinuousRecognitionAsync. Voici un exemple de reconnaissance continue sur un fichier d’entrée audio.

Commencez par définir l’entrée et initialiser SpeechRecognizer :

using var audioConfig = AudioConfig.FromWavFileInput("YourAudioFile.wav");
using var speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);

Ensuite, créez une instance TaskCompletionSource<int> pour gérer l’état de la reconnaissance vocale :

var stopRecognition = new TaskCompletionSource<int>();

Ensuite, abonnez-vous aux événements qu’envoie SpeechRecognizer :

• Recognizing : signal pour les événements contenant des résultats de reconnaissance intermédiaires.
• Recognized : signal pour les événements qui contiennent des résultats de reconnaissance finaux, ce qui indique une tentative de reconnaissance réussie.
• SessionStopped : signal pour les événements indiquant la fin d’une session (opération) de reconnaissance.
• Canceled : signal pour les événements contenant des résultats de reconnaissance annulés. Ces résultats indiquent une tentative de reconnaissance qui a été annulée à la suite d’une demande d’annulation directe. Ils peuvent également indiquer un échec de transport ou de protocole.

speechRecognizer.Recognizing += (s, e) =>
{
    Console.WriteLine($"RECOGNIZING: Text={e.Result.Text}");
};

speechRecognizer.Recognized += (s, e) =>
{
    if (e.Result.Reason == ResultReason.RecognizedSpeech)
    {
        Console.WriteLine($"RECOGNIZED: Text={e.Result.Text}");
    }
    else if (e.Result.Reason == ResultReason.NoMatch)
    {
        Console.WriteLine($"NOMATCH: Speech could not be recognized.");
    }
};

speechRecognizer.Canceled += (s, e) =>
{
    Console.WriteLine($"CANCELED: Reason={e.Reason}");

    if (e.Reason == CancellationReason.Error)
    {
        Console.WriteLine($"CANCELED: ErrorCode={e.ErrorCode}");
        Console.WriteLine($"CANCELED: ErrorDetails={e.ErrorDetails}");
        Console.WriteLine($"CANCELED: Did you set the speech resource key and region values?");
    }

    stopRecognition.TrySetResult(0);
};

speechRecognizer.SessionStopped += (s, e) =>
{
    Console.WriteLine("\n    Session stopped event.");
    stopRecognition.TrySetResult(0);
};

Quand tout est configuré, appelez StartContinuousRecognitionAsync pour commencer la reconnaissance :

await speechRecognizer.StartContinuousRecognitionAsync();

// Waits for completion. Use Task.WaitAny to keep the task rooted.
Task.WaitAny(new[] { stopRecognition.Task });

// Make the following call at some point to stop recognition:
// await speechRecognizer.StopContinuousRecognitionAsync();

Changer la langue source

Une tâche courante pour la reconnaissance vocale consiste à spécifier la langue d’entrée (ou source). L’exemple suivant montre comment définir la langue d’entrée sur Italien. Dans votre code, recherchez votre instance SpeechConfig, puis ajoutez cette ligne directement en dessous :

speechConfig.SpeechRecognitionLanguage = "it-IT";

La propriété SpeechRecognitionLanguage attend une chaîne au format langue-paramètres régionaux. Pour obtenir une liste des paramètres régionaux pris en charge, consultez Prise en charge des langues et de la voix pour le service Speech.

Identification de la langue

Vous pouvez utiliser l’identification de la langue avec la reconnaissance vocale lorsque vous devez identifier la langue dans une source audio, puis la transcrire en texte.

Pour obtenir un exemple de code complet, consultez Identification de la langue.

Utiliser un point de terminaison personnalisé

Avec la reconnaissance vocale personnalisée, vous pouvez charger vos propres données, tester et entraîner un modèle personnalisé, comparer l’exactitude entre les modèles, et déployer un modèle sur un point de terminaison personnalisé. L’exemple suivant montre comment définir un point de terminaison personnalisé.

var speechConfig = SpeechConfig.FromSubscription("YourSubscriptionKey", "YourServiceRegion");
speechConfig.EndpointId = "YourEndpointId";
var speechRecognizer = new SpeechRecognizer(speechConfig);

Exécuter et utiliser un conteneur

Les conteneurs Speech fournissent des API de point de terminaison de requête basées sur WebSocket, accessibles via le Kit de développement logiciel (SDK) Speech et l’interface CLI Speech. Par défaut, le kit de développement logiciel (SDK) Speech et l’interface CLI Speech utilisent le service Speech public. Pour utiliser le conteneur, vous devez changer la méthode d’initialisation. Utilisez une URL d’hôte de conteneur plutôt qu’une clé et une région.

Pour plus d’informations sur les conteneurs, consultez la section URL de l’hôte dans Installer et exécuter des conteneurs Speech avec Docker.

Modifier la façon dont le silence est géré

Si un utilisateur parle plus rapidement ou plus lentement que d’habitude, les comportements par défaut pour le silence non vocal dans l’audio d’entrée peuvent ne pas entraîner le résultat attendu. Les problèmes courants liés à la gestion du silence sont les suivants :

• Parole rapide qui chaîne de nombreuses phrases en un seul résultat de reconnaissance, au lieu de séparer les phrases en résultats individuels.
• Parole lente qui sépare les parties d’une phrase en plusieurs résultats.
• Reconnaissance unique qui se termine trop rapidement en attendant que la parole commence.

Ces problèmes peuvent être résolus en définissant l’une des deux propriétés de délai d’expiration sur l’instance SpeechConfig utilisée pour créer un SpeechRecognizer :

• Le délai d’expiration du silence de segmentation ajuste la quantité d’audio non vocale autorisée dans une expression actuellement parlée avant que cette expression soit considérée comme « effectuée ».
  • Des valeurs plus élevées allongent généralement les résultats et permettent à l’orateur de faire des pauses plus longues au sein d’une phrase, mais les résultats mettent plus de temps à arriver. Elles peuvent également combiner des phrases distinctes en un résultat unique lorsqu’elles sont trop élevées.
  • Les valeurs inférieures rendent généralement les résultats plus courts et garantissent des sauts plus rapides et fréquents entre les expressions, mais peuvent également entraîner la séparation d’expressions uniques en plusieurs résultats lorsqu’ils sont définis trop bas.
  • Ce délai d’expiration peut être défini sur des valeurs entières comprises entre 100 et 5 000, en millisecondes, avec 500 comme valeur par défaut standard.
• Le délai d’expiration du silence initial ajuste la quantité d’audio non vocal autorisée avant une expression avant que la tentative de reconnaissance se termine par un résultat « aucune correspondance ».
  • Les valeurs plus élevées donnent aux orateurs plus de temps pour réagir et commencer à parler, mais peuvent également entraîner une réactivité lente lorsque rien n’est prononcé.
  • Les valeurs inférieures garantissent une invite « sans correspondance » pour une expérience utilisateur plus rapide et une gestion audio plus contrôlée, mais peuvent couper un haut-parleur trop rapidement quand il est défini trop bas.
  • Étant donné que la reconnaissance continue génère de nombreux résultats, cette valeur détermine la fréquence à laquelle les résultats « aucune correspondance » arrivent, mais n’affecte pas autrement le contenu des résultats de la reconnaissance.
  • Ce délai d’expiration peut être fixé à une valeur entière non négative, en millisecondes, ou à 0 pour le désactiver complètement. 5000 est une valeur par défaut classique pour la reconnaissance unique, tandis que 15 000 est une valeur par défaut classique pour la reconnaissance continue.

Comme il existe des compromis lors de la modification de ces délais d’expiration, vous ne devez modifier les paramètres que si vous rencontrez un problème lié à la gestion du silence. Les valeurs par défaut gèrent de manière optimale la plupart de l’audio parlé et seuls les scénarios rares devraient rencontrer des problèmes.

Exemple : les utilisateurs énonçant un numéro de série comme « ABC-123-4567 » peuvent s’interrompre entre les groupes de caractères suffisamment longtemps pour que le numéro de série soit divisé en plusieurs résultats. Dans ce cas, essayez une valeur plus élevée, comme 2000 millisecondes, pour le délai d’expiration du silence de segmentation :

speechConfig.SetProperty(PropertyId.Speech_SegmentationSilenceTimeoutMs, "2000");

Exemple : le discours d’un présentateur enregistré peut être assez rapide pour que plusieurs phrases d’une ligne soient combinées, avec des résultats de reconnaissance importants qui arrivent une ou deux fois par minute. Dans ce cas, définissez le délai d’expiration du silence de segmentation sur une valeur inférieure, comme 300 ms :

speechConfig.SetProperty(PropertyId.Speech_SegmentationSilenceTimeoutMs, "300");

Exemple : une reconnaissance unique demandant à un orateur de rechercher et de lire un numéro de série se termine trop rapidement alors que le nombre est en train d’être recherché. Dans ce cas, essayez un délai d’expiration de silence initial plus long, par exemple 10 000 ms :

speechConfig.SetProperty(PropertyId.SpeechServiceConnection_InitialSilenceTimeoutMs, "10000");

Segmentation sémantique

La segmentation sémantique est une stratégie de segmentation de reconnaissance vocale conçue pour atténuer les problèmes associés à la segmentation basée sur le silence :

• Sous-segmentation : lorsque les utilisateurs parlent pendant un long moment sans pause, ils peuvent voir une longue séquence de texte sans saut (« mur de texte »), qui dégrade fortement leur expérience de lisibilité.
• Sur-segmentation : lorsqu’un utilisateur s’interrompt pendant une courte période, le mécanisme de détection du silence peut effectuer une segmentation incorrecte.

Au lieu de compter sur les délais d’expiration du silence, effectue une segmentation sémantique et retourne les résultats finaux lorsqu’il détecte la ponctuation de fin de phrase (par exemple « . » ou « ? »). Cela améliore l’expérience utilisateur avec des segments de qualité supérieure, sémantiquement complets et empêche les résultats intermédiaires longs.

Pour utiliser la segmentation sémantique, vous devez définir la propriété suivante sur l’instance SpeechConfig utilisée pour créer un SpeechRecognizer :

speechConfig.SetProperty(PropertyId.Speech_SegmentationStrategy, "Semantic");

Voici quelques-unes des limitations de la segmentation sémantique :

• Pour utiliser la segmentation sémantique, vous avez besoin du SDK Speech version 1.41 ou ultérieure.
• La segmentation sémantique est uniquement destinée pour une utilisation dans le cadre de la reconnaissance continue. Cela inclut des scénarios tels que la transcription et le sous-titrage. Elle ne doit pas être utilisée dans le cadre de la reconnaissance unique et en mode dictée.
• La segmentation sémantique n’est pas disponible pour toutes les langues et tous les paramètres régionaux. Actuellement, la segmentation sémantique est disponible uniquement pour les paramètres régionaux anglais (en) tels que en-US, en-GB, en-IN et en-AU.
• La segmentation sémantique ne prend pas encore en charge les scores de confiance et les listes NBest. Par conséquent, nous vous déconseillons la segmentation sémantique si vous utilisez des scores de confiance ou des listes NBest.

Documentation de référence | Package (NuGet) | Exemples supplémentaires sur GitHub

Dans ce guide pratique, vous allez apprendre à utiliser Azure AI Speech pour la reconnaissance vocale en temps réel. La reconnaissance vocale en temps réel est idéale pour les applications nécessitant une transcription immédiate, comme la dictée, l’assistance en centre d’appels et le sous-titrage pour les réunions en direct.

Pour découvrir comment configurer l’environnement pour un exemple d’application, consultez Démarrage rapide : Reconnaître et convertir la parole en texte.

Créer une instance de configuration Speech

Pour appeler le service Speech avec le SDK Speech, vous devez créer une instance 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.

1. Créez une ressource Speech dans le portail Azure. Obtenez la clé de ressource et la région Speech.
2. Créez une instance SpeechConfig à l’aide du code suivant. Remplacez YourSpeechKey et YourSpeechRegion par votre clé de ressource Speech et votre région.

using namespace std;
using namespace Microsoft::CognitiveServices::Speech;

auto speechConfig = SpeechConfig::FromSubscription("YourSpeechKey", "YourSpeechRegion");

Vous pouvez initialiser SpeechConfig de plusieurs autres façons :

• Utilisez un point de terminaison et transmettez un point de terminaison de service Speech. Une clé ou un jeton d’autorisation est facultatif.
• Utilisez un hôte et transmettez une adresse d’hôte. Une clé ou un jeton d’autorisation est facultatif.
• Utilisez un jeton d’autorisation avec la région/l’emplacement associé.

Remarque

Quand vous procédez à une reconnaissance vocale, une synthèse vocale, une traduction ou une reconnaissance intentionnelle, vous créez toujours une configuration.

Reconnaître la voix provenant d’un micro

Pour reconnaître la voix à l’aide du microphone de votre appareil, créez une instance AudioConfig en utilisant la fonction membre FromDefaultMicrophoneInput(). Initialisez ensuite l’objet SpeechRecognizer en transmettant audioConfig et config.

using namespace Microsoft::CognitiveServices::Speech::Audio;

auto audioConfig = AudioConfig::FromDefaultMicrophoneInput();
auto speechRecognizer = SpeechRecognizer::FromConfig(config, audioConfig);

cout << "Speak into your microphone." << std::endl;
auto result = speechRecognizer->RecognizeOnceAsync().get();
cout << "RECOGNIZED: Text=" << result->Text << std::endl;

Si vous souhaitez utiliser un périphérique d’entrée audio spécifique, vous devez spécifier son ID dans AudioConfig. Pour découvrir comment obtenir l’ID de l’appareil, consultez Sélectionner un appareil d’entrée audio avec le Kit de développement logiciel (SDK) Speech.

Utiliser la reconnaissance vocale à partir d’un fichier

Si vous souhaitez reconnaître la voix à partir d’un fichier audio au lieu d’utiliser un microphone, vous devez quand même créer une instance AudioConfig. Toutefois, vous n’appelez pas FromDefaultMicrophoneInput(). Vous appelez FromWavFileInput() et transmettez le chemin d’accès au fichier :

using namespace Microsoft::CognitiveServices::Speech::Audio;

auto audioConfig = AudioConfig::FromWavFileInput("YourAudioFile.wav");
auto speechRecognizer = SpeechRecognizer::FromConfig(config, audioConfig);

auto result = speechRecognizer->RecognizeOnceAsync().get();
cout << "RECOGNIZED: Text=" << result->Text << std::endl;

Reconnaître la parole à l’aide de la classe Recognizer

La classe SpeechRecognizer pour le SDK Speech pour C++ expose quelques méthodes que vous pouvez utiliser pour la reconnaissance vocale.

Reconnaissance unique

La reconnaissance unique reconnaît de manière asynchrone un énoncé unique. La fin d’un énoncé unique est déterminée par la détection du silence à la fin, ou après que 15 secondes d’audio ont été traitées. Voici un exemple de reconnaissance asynchrone unique via RecognizeOnceAsync :

auto result = speechRecognizer->RecognizeOnceAsync().get();

Vous devrez écrire du code pour gérer le résultat. Cet exemple évalue result->Reason et :

• Affiche le résultat de la reconnaissance : ResultReason::RecognizedSpeech.
• S’il n’existe aucune correspondance de reconnaissance, l’utilisateur est informé : ResultReason::NoMatch.
• Si une erreur se produit, un message d’erreur est affiché : ResultReason::Canceled.

switch (result->Reason)
{
    case ResultReason::RecognizedSpeech:
        cout << "We recognized: " << result->Text << std::endl;
        break;
    case ResultReason::NoMatch:
        cout << "NOMATCH: Speech could not be recognized." << std::endl;
        break;
    case ResultReason::Canceled:
        {
            auto cancellation = CancellationDetails::FromResult(result);
            cout << "CANCELED: Reason=" << (int)cancellation->Reason << std::endl;
    
            if (cancellation->Reason == CancellationReason::Error) {
                cout << "CANCELED: ErrorCode= " << (int)cancellation->ErrorCode << std::endl;
                cout << "CANCELED: ErrorDetails=" << cancellation->ErrorDetails << std::endl;
                cout << "CANCELED: Did you set the speech resource key and region values?" << std::endl;
            }
        }
        break;
    default:
        break;
}

Reconnaissance continue

La reconnaissance continue est un peu plus complexe que la reconnaissance unique. Pour obtenir les résultats de la reconnaissance, vous devez vous abonner aux événements Recognizing, Recognized et Canceled. Pour arrêter la reconnaissance, vous devez appeler StopContinuousRecognitionAsync. Voici un exemple de reconnaissance continue effectuée sur un fichier d’entrée audio.

Commencez par définir l’entrée et initialiser SpeechRecognizer :

auto audioConfig = AudioConfig::FromWavFileInput("YourAudioFile.wav");
auto speechRecognizer = SpeechRecognizer::FromConfig(config, audioConfig);

Ensuite, créez une variable pour gérer l’état de la reconnaissance vocale. Déclarez promise<void>, car au début de la reconnaissance, vous pouvez supposer sans risque qu’elle n’est pas terminée :

promise<void> recognitionEnd;

Ensuite, abonnez-vous aux événements qu’envoie SpeechRecognizer :

• Recognizing : signal pour les événements contenant des résultats de reconnaissance intermédiaires.
• Recognized : signal pour les événements qui contiennent des résultats de reconnaissance finaux, ce qui indique une tentative de reconnaissance réussie.
• SessionStopped : signal pour les événements indiquant la fin d’une session (opération) de reconnaissance.
• Canceled : signal pour les événements contenant des résultats de reconnaissance annulés. Ces résultats indiquent une tentative de reconnaissance qui a été annulée à la suite d’une demande d’annulation directe. Ils peuvent également indiquer un échec de transport ou de protocole.

speechRecognizer->Recognizing.Connect([](const SpeechRecognitionEventArgs& e)
    {
        cout << "Recognizing:" << e.Result->Text << std::endl;
    });

speechRecognizer->Recognized.Connect([](const SpeechRecognitionEventArgs& e)
    {
        if (e.Result->Reason == ResultReason::RecognizedSpeech)
        {
            cout << "RECOGNIZED: Text=" << e.Result->Text 
                 << " (text could not be translated)" << std::endl;
        }
        else if (e.Result->Reason == ResultReason::NoMatch)
        {
            cout << "NOMATCH: Speech could not be recognized." << std::endl;
        }
    });

speechRecognizer->Canceled.Connect([&recognitionEnd](const SpeechRecognitionCanceledEventArgs& e)
    {
        cout << "CANCELED: Reason=" << (int)e.Reason << std::endl;
        if (e.Reason == CancellationReason::Error)
        {
            cout << "CANCELED: ErrorCode=" << (int)e.ErrorCode << "\n"
                 << "CANCELED: ErrorDetails=" << e.ErrorDetails << "\n"
                 << "CANCELED: Did you set the speech resource key and region values?" << std::endl;

            recognitionEnd.set_value(); // Notify to stop recognition.
        }
    });

speechRecognizer->SessionStopped.Connect([&recognitionEnd](const SessionEventArgs& e)
    {
        cout << "Session stopped.";
        recognitionEnd.set_value(); // Notify to stop recognition.
    });

Quand tout est configuré, appelez StartContinuousRecognitionAsync pour commencer la reconnaissance :

// Starts continuous recognition. Uses StopContinuousRecognitionAsync() to stop recognition.
speechRecognizer->StartContinuousRecognitionAsync().get();

// Waits for recognition end.
recognitionEnd.get_future().get();

// Stops recognition.
speechRecognizer->StopContinuousRecognitionAsync().get();

Changer la langue source

Une tâche courante pour la reconnaissance vocale consiste à spécifier la langue d’entrée (ou source). L’exemple suivant montre comment définir la langue d’entrée sur Allemand. Dans votre code, recherchez votre instance SpeechConfig, puis ajoutez cette ligne directement en dessous :

speechConfig->SetSpeechRecognitionLanguage("de-DE");

SetSpeechRecognitionLanguage est un paramètre qui prend une chaîne comme argument. Pour obtenir une liste des paramètres régionaux pris en charge, consultez Prise en charge des langues et de la voix pour le service Speech.

Identification de la langue

Vous pouvez utiliser l’identification de la langue avec la reconnaissance vocale lorsque vous devez identifier la langue dans une source audio, puis la transcrire en texte.

Pour obtenir un exemple de code complet, consultez Identification de la langue.

Utiliser un point de terminaison personnalisé

Avec la reconnaissance vocale personnalisée, vous pouvez charger vos propres données, tester et entraîner un modèle personnalisé, comparer l’exactitude entre les modèles, et déployer un modèle sur un point de terminaison personnalisé. L’exemple suivant montre comment définir un point de terminaison personnalisé.

auto speechConfig = SpeechConfig::FromSubscription("YourSubscriptionKey", "YourServiceRegion");
speechConfig->SetEndpointId("YourEndpointId");
auto speechRecognizer = SpeechRecognizer::FromConfig(speechConfig);

Exécuter et utiliser un conteneur

Les conteneurs Speech fournissent des API de point de terminaison de requête basées sur WebSocket, accessibles via le Kit de développement logiciel (SDK) Speech et l’interface CLI Speech. Par défaut, le kit de développement logiciel (SDK) Speech et l’interface CLI Speech utilisent le service Speech public. Pour utiliser le conteneur, vous devez changer la méthode d’initialisation. Utilisez une URL d’hôte de conteneur plutôt qu’une clé et une région.

Pour plus d’informations sur les conteneurs, consultez la section URL de l’hôte dans Installer et exécuter des conteneurs Speech avec Docker.

Segmentation sémantique

La segmentation sémantique est une stratégie de segmentation de reconnaissance vocale conçue pour atténuer les problèmes associés à la segmentation basée sur le silence :

• Sous-segmentation : lorsque les utilisateurs parlent pendant un long moment sans pause, ils peuvent voir une longue séquence de texte sans saut (« mur de texte »), qui dégrade fortement leur expérience de lisibilité.
• Sur-segmentation : lorsqu’un utilisateur s’interrompt pendant une courte période, le mécanisme de détection du silence peut effectuer une segmentation incorrecte.

Au lieu de compter sur les délais d’expiration du silence, effectue une segmentation sémantique et retourne les résultats finaux lorsqu’il détecte la ponctuation de fin de phrase (par exemple « . » ou « ? »). Cela améliore l’expérience utilisateur avec des segments de qualité supérieure, sémantiquement complets et empêche les résultats intermédiaires longs.

Pour utiliser la segmentation sémantique, vous devez définir la propriété suivante sur l’instance SpeechConfig utilisée pour créer un SpeechRecognizer :

speechConfig->SetProperty(PropertyId::Speech_SegmentationStrategy, "Semantic");

Voici quelques-unes des limitations de la segmentation sémantique :

• Pour utiliser la segmentation sémantique, vous avez besoin du SDK Speech version 1.41 ou ultérieure.
• La segmentation sémantique est uniquement destinée pour une utilisation dans le cadre de la reconnaissance continue. Cela inclut des scénarios tels que la transcription et le sous-titrage. Elle ne doit pas être utilisée dans le cadre de la reconnaissance unique et en mode dictée.
• La segmentation sémantique n’est pas disponible pour toutes les langues et tous les paramètres régionaux. Actuellement, la segmentation sémantique est disponible uniquement pour les paramètres régionaux anglais (en) tels que en-US, en-GB, en-IN et en-AU.
• La segmentation sémantique ne prend pas encore en charge les scores de confiance et les listes NBest. Par conséquent, nous vous déconseillons la segmentation sémantique si vous utilisez des scores de confiance ou des listes NBest.

Documentation de référence | Package (Go) | Exemples supplémentaires sur GitHub

Dans ce guide pratique, vous allez apprendre à utiliser Azure AI Speech pour la reconnaissance vocale en temps réel. La reconnaissance vocale en temps réel est idéale pour les applications nécessitant une transcription immédiate, comme la dictée, l’assistance en centre d’appels et le sous-titrage pour les réunions en direct.

Pour découvrir comment configurer l’environnement pour un exemple d’application, consultez Démarrage rapide : Reconnaître et convertir la parole en texte.

Reconnaissance vocale à partir d’un micro

1. Créez une ressource Speech dans le portail Azure. Obtenez la clé de ressource et la région Speech.
2. Utilisez l’exemple de code suivant pour exécuter la reconnaissance vocale à partir de votre microphone d’appareil par défaut. Remplacez YourSpeechKey et YourSpeechRegion par votre clé de ressource Speech et votre région. L’exécution du script démarre une session de reconnaissance sur votre microphone par défaut et le texte de sortie :

package main

import (
	"bufio"
	"fmt"
	"os"

	"github.com/Microsoft/cognitive-services-speech-sdk-go/audio"
	"github.com/Microsoft/cognitive-services-speech-sdk-go/speech"
)

func sessionStartedHandler(event speech.SessionEventArgs) {
	defer event.Close()
	fmt.Println("Session Started (ID=", event.SessionID, ")")
}

func sessionStoppedHandler(event speech.SessionEventArgs) {
	defer event.Close()
	fmt.Println("Session Stopped (ID=", event.SessionID, ")")
}

func recognizingHandler(event speech.SpeechRecognitionEventArgs) {
	defer event.Close()
	fmt.Println("Recognizing:", event.Result.Text)
}

func recognizedHandler(event speech.SpeechRecognitionEventArgs) {
	defer event.Close()
	fmt.Println("Recognized:", event.Result.Text)
}

func cancelledHandler(event speech.SpeechRecognitionCanceledEventArgs) {
	defer event.Close()
	fmt.Println("Received a cancellation: ", event.ErrorDetails)
	fmt.Println("Did you set the speech resource key and region values?")
}

func main() {
    subscription :=  "YourSpeechKey"
    region := "YourSpeechRegion"

	audioConfig, err := audio.NewAudioConfigFromDefaultMicrophoneInput()
	if err != nil {
		fmt.Println("Got an error: ", err)
		return
	}
	defer audioConfig.Close()
	config, err := speech.NewSpeechConfigFromSubscription(subscription, region)
	if err != nil {
		fmt.Println("Got an error: ", err)
		return
	}
	defer config.Close()
	speechRecognizer, err := speech.NewSpeechRecognizerFromConfig(config, audioConfig)
	if err != nil {
		fmt.Println("Got an error: ", err)
		return
	}
	defer speechRecognizer.Close()
	speechRecognizer.SessionStarted(sessionStartedHandler)
	speechRecognizer.SessionStopped(sessionStoppedHandler)
	speechRecognizer.Recognizing(recognizingHandler)
	speechRecognizer.Recognized(recognizedHandler)
	speechRecognizer.Canceled(cancelledHandler)
	speechRecognizer.StartContinuousRecognitionAsync()
	defer speechRecognizer.StopContinuousRecognitionAsync()
	bufio.NewReader(os.Stdin).ReadBytes('\n')
}

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

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

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

go build
go run quickstart

Pour obtenir des informations détaillées, consultez le contenu de référence de la classe SpeechConfig et le contenu de référence de la classe SpeechRecognizer.

Reconnaissance vocale à partir d’un fichier audio

Utilisez l’exemple suivant pour exécuter la reconnaissance vocale à partir d’un fichier audio. Remplacez YourSpeechKey et YourSpeechRegion par votre clé de ressource Speech et votre région. Remplacez également la variable file par un chemin vers un fichier .wav. Lorsque vous exécutez le script, il reconnaît la voix à partir du fichier et génère le résultat sous forme de texte :

package main

import (
	"fmt"
	"time"

	"github.com/Microsoft/cognitive-services-speech-sdk-go/audio"
	"github.com/Microsoft/cognitive-services-speech-sdk-go/speech"
)

func main() {
    subscription :=  "YourSpeechKey"
    region := "YourSpeechRegion"
    file := "path/to/file.wav"

	audioConfig, err := audio.NewAudioConfigFromWavFileInput(file)
	if err != nil {
		fmt.Println("Got an error: ", err)
		return
	}
	defer audioConfig.Close()
	config, err := speech.NewSpeechConfigFromSubscription(subscription, region)
	if err != nil {
		fmt.Println("Got an error: ", err)
		return
	}
	defer config.Close()
	speechRecognizer, err := speech.NewSpeechRecognizerFromConfig(config, audioConfig)
	if err != nil {
		fmt.Println("Got an error: ", err)
		return
	}
	defer speechRecognizer.Close()
	speechRecognizer.SessionStarted(func(event speech.SessionEventArgs) {
		defer event.Close()
		fmt.Println("Session Started (ID=", event.SessionID, ")")
	})
	speechRecognizer.SessionStopped(func(event speech.SessionEventArgs) {
		defer event.Close()
		fmt.Println("Session Stopped (ID=", event.SessionID, ")")
	})

	task := speechRecognizer.RecognizeOnceAsync()
	var outcome speech.SpeechRecognitionOutcome
	select {
	case outcome = <-task:
	case <-time.After(5 * time.Second):
		fmt.Println("Timed out")
		return
	}
	defer outcome.Close()
	if outcome.Error != nil {
		fmt.Println("Got an error: ", outcome.Error)
	}
	fmt.Println("Got a recognition!")
	fmt.Println(outcome.Result.Text)
}

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

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

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

go build
go run quickstart

Pour obtenir des informations détaillées, consultez le contenu de référence de la classe SpeechConfig et le contenu de référence de la classe SpeechRecognizer.

Exécuter et utiliser un conteneur

Les conteneurs Speech fournissent des API de point de terminaison de requête basées sur WebSocket, accessibles via le Kit de développement logiciel (SDK) Speech et l’interface CLI Speech. Par défaut, le kit de développement logiciel (SDK) Speech et l’interface CLI Speech utilisent le service Speech public. Pour utiliser le conteneur, vous devez changer la méthode d’initialisation. Utilisez une URL d’hôte de conteneur plutôt qu’une clé et une région.

Pour plus d’informations sur les conteneurs, consultez la section URL de l’hôte dans Installer et exécuter des conteneurs Speech avec Docker.

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

Dans ce guide pratique, vous allez apprendre à utiliser Azure AI Speech pour la reconnaissance vocale en temps réel. La reconnaissance vocale en temps réel est idéale pour les applications nécessitant une transcription immédiate, comme la dictée, l’assistance en centre d’appels et le sous-titrage pour les réunions en direct.

Pour découvrir comment configurer l’environnement pour un exemple d’application, consultez Démarrage rapide : Reconnaître et convertir la parole en texte.

Créer une instance de configuration Speech

Pour appeler le service Speech à l’aide du SDK Speech, vous devez créer une instance 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.

1. Créez une ressource Speech dans le portail Azure. Obtenez la clé de ressource et la région Speech.
2. Créez une instance SpeechConfig à l’aide de votre clé Speech et de votre région.

import com.microsoft.cognitiveservices.speech.*;
import com.microsoft.cognitiveservices.speech.audio.AudioConfig;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

public class Program {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        SpeechConfig speechConfig = SpeechConfig.fromSubscription("<paste-your-speech-key>", "<paste-your-region>");
    }
}

Vous pouvez initialiser SpeechConfig de plusieurs autres façons :

• Utilisez un point de terminaison et transmettez un point de terminaison de service Speech. Une clé ou un jeton d’autorisation est facultatif.
• Utilisez un hôte et transmettez une adresse d’hôte. Une clé ou un jeton d’autorisation est facultatif.
• Utilisez un jeton d’autorisation avec la région/l’emplacement associé.

Remarque

Quand vous procédez à une reconnaissance vocale, une synthèse vocale, une traduction ou une reconnaissance intentionnelle, vous devez toujours créer une configuration.

Reconnaître la voix provenant d’un micro

Pour reconnaître la voix à l’aide du microphone de votre appareil, créez une instance AudioConfig en utilisant la méthode fromDefaultMicrophoneInput(). Initialisez ensuite l’objet SpeechRecognizer en transmettant audioConfig et config.

import com.microsoft.cognitiveservices.speech.*;
import com.microsoft.cognitiveservices.speech.audio.AudioConfig;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

public class Program {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        SpeechConfig speechConfig = SpeechConfig.fromSubscription("<paste-your-speech-key>", "<paste-your-region>");
        fromMic(speechConfig);
    }

    public static void fromMic(SpeechConfig speechConfig) throws InterruptedException, ExecutionException {
        AudioConfig audioConfig = AudioConfig.fromDefaultMicrophoneInput();
        SpeechRecognizer speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);

        System.out.println("Speak into your microphone.");
        Future<SpeechRecognitionResult> task = speechRecognizer.recognizeOnceAsync();
        SpeechRecognitionResult speechRecognitionResult = task.get();
        System.out.println("RECOGNIZED: Text=" + speechRecognitionResult.getText());
    }
}

Si vous souhaitez utiliser un périphérique d’entrée audio spécifique, vous devez spécifier son ID dans AudioConfig. Pour découvrir comment obtenir l’ID de l’appareil, consultez Sélectionner un appareil d’entrée audio avec le Kit de développement logiciel (SDK) Speech.

Utiliser la reconnaissance vocale à partir d’un fichier

Si vous souhaitez reconnaître la voix à partir d’un fichier audio au lieu d’utiliser un microphone, vous devez quand même créer une instance AudioConfig. Toutefois, vous n’appelez pas FromDefaultMicrophoneInput(). Vous appelez fromWavFileInput() et transmettez le chemin d’accès au fichier :

import com.microsoft.cognitiveservices.speech.*;
import com.microsoft.cognitiveservices.speech.audio.AudioConfig;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

public class Program {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        SpeechConfig speechConfig = SpeechConfig.fromSubscription("<paste-your-speech-key>", "<paste-your-region>");
        fromFile(speechConfig);
    }

    public static void fromFile(SpeechConfig speechConfig) throws InterruptedException, ExecutionException {
        AudioConfig audioConfig = AudioConfig.fromWavFileInput("YourAudioFile.wav");
        SpeechRecognizer speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);
        
        Future<SpeechRecognitionResult> task = speechRecognizer.recognizeOnceAsync();
        SpeechRecognitionResult speechRecognitionResult = task.get();
        System.out.println("RECOGNIZED: Text=" + speechRecognitionResult.getText());
    }
}

Gérer les erreurs

Les exemples précédents récupèrent seulement le texte reconnu en utilisant speechRecognitionResult.getText(). Pour gérer les erreurs et autres réponses, vous devez écrire du code pour gérer le résultat. L’exemple suivant évalue speechRecognitionResult.getReason() et :

• Affiche le résultat de la reconnaissance : ResultReason.RecognizedSpeech.
• S’il n’existe aucune correspondance de reconnaissance, l’utilisateur est informé : ResultReason.NoMatch.
• Si une erreur se produit, un message d’erreur est affiché : ResultReason.Canceled.

switch (speechRecognitionResult.getReason()) {
    case ResultReason.RecognizedSpeech:
        System.out.println("We recognized: " + speechRecognitionResult.getText());
        exitCode = 0;
        break;
    case ResultReason.NoMatch:
        System.out.println("NOMATCH: Speech could not be recognized.");
        break;
    case ResultReason.Canceled: {
            CancellationDetails cancellation = CancellationDetails.fromResult(speechRecognitionResult);
            System.out.println("CANCELED: Reason=" + cancellation.getReason());

            if (cancellation.getReason() == CancellationReason.Error) {
                System.out.println("CANCELED: ErrorCode=" + cancellation.getErrorCode());
                System.out.println("CANCELED: ErrorDetails=" + cancellation.getErrorDetails());
                System.out.println("CANCELED: Did you set the speech resource key and region values?");
            }
        }
        break;
}

Utiliser la reconnaissance continue

Les exemples précédents utilisent la reconnaissance unique, qui reconnaît un énoncé unique. La fin d’un énoncé unique est déterminée par la détection du silence à la fin, ou après que 15 secondes d’audio ont été traitées.

En revanche, vous utilisez la reconnaissance continue quand vous souhaitez contrôler à quel moment arrêter la reconnaissance. Pour obtenir les résultats de la reconnaissance, vous devez vous abonner aux événements recognizing, recognized et canceled. Pour arrêter la reconnaissance, vous devez appeler stopContinuousRecognitionAsync. Voici un exemple de la manière dont vous pouvez effectuer une reconnaissance continue sur un fichier d’entrée audio.

Commencez par définir l’entrée et initialiser SpeechRecognizer :

AudioConfig audioConfig = AudioConfig.fromWavFileInput("YourAudioFile.wav");
SpeechRecognizer speechRecognizer = new SpeechRecognizer(config, audioConfig);

Ensuite, créez une variable pour gérer l’état de la reconnaissance vocale. Déclarez une instance Semaphore dans l’étendue de la classe :

private static Semaphore stopTranslationWithFileSemaphore;

Ensuite, abonnez-vous aux événements qu’envoie SpeechRecognizer :

• recognizing : signal pour les événements contenant des résultats de reconnaissance intermédiaires.
• recognized : signal pour les événements qui contiennent des résultats de reconnaissance finaux, ce qui indique une tentative de reconnaissance réussie.
• sessionStopped : signal pour les événements indiquant la fin d’une session (opération) de reconnaissance.
• canceled : signal pour les événements contenant des résultats de reconnaissance annulés. Ces résultats indiquent une tentative de reconnaissance qui a été annulée à la suite d’une demande d’annulation directe. Ils peuvent également indiquer un échec de transport ou de protocole.

// First initialize the semaphore.
stopTranslationWithFileSemaphore = new Semaphore(0);

speechRecognizer.recognizing.addEventListener((s, e) -> {
    System.out.println("RECOGNIZING: Text=" + e.getResult().getText());
});

speechRecognizer.recognized.addEventListener((s, e) -> {
    if (e.getResult().getReason() == ResultReason.RecognizedSpeech) {
        System.out.println("RECOGNIZED: Text=" + e.getResult().getText());
    }
    else if (e.getResult().getReason() == ResultReason.NoMatch) {
        System.out.println("NOMATCH: Speech could not be recognized.");
    }
});

speechRecognizer.canceled.addEventListener((s, e) -> {
    System.out.println("CANCELED: Reason=" + e.getReason());

    if (e.getReason() == CancellationReason.Error) {
        System.out.println("CANCELED: ErrorCode=" + e.getErrorCode());
        System.out.println("CANCELED: ErrorDetails=" + e.getErrorDetails());
        System.out.println("CANCELED: Did you set the speech resource key and region values?");
    }

    stopTranslationWithFileSemaphore.release();
});

speechRecognizer.sessionStopped.addEventListener((s, e) -> {
    System.out.println("\n    Session stopped event.");
    stopTranslationWithFileSemaphore.release();
});

Quand tout est configuré, appelez startContinuousRecognitionAsync pour commencer la reconnaissance :

// Starts continuous recognition. Uses StopContinuousRecognitionAsync() to stop recognition.
speechRecognizer.startContinuousRecognitionAsync().get();

// Waits for completion.
stopTranslationWithFileSemaphore.acquire();

// Stops recognition.
speechRecognizer.stopContinuousRecognitionAsync().get();

Changer la langue source

Une tâche courante pour la reconnaissance vocale consiste à spécifier la langue d’entrée (ou source). L’exemple suivant montre comment définir la langue d’entrée sur Français. Dans votre code, recherchez votre instance SpeechConfig, puis ajoutez cette ligne directement en dessous :

config.setSpeechRecognitionLanguage("fr-FR");

setSpeechRecognitionLanguage est un paramètre qui prend une chaîne comme argument. Reportez-vous à la liste des paramètres régionaux de reconnaissance vocale pris en charge.

Identification de la langue

Vous pouvez utiliser l’identification de la langue avec la reconnaissance vocale lorsque vous devez identifier la langue dans une source audio, puis la transcrire en texte.

Pour obtenir un exemple de code complet, consultez Identification de la langue.

Utiliser un point de terminaison personnalisé

Avec la reconnaissance vocale personnalisée, vous pouvez charger vos propres données, tester et entraîner un modèle personnalisé, comparer l’exactitude entre les modèles, et déployer un modèle sur un point de terminaison personnalisé. L’exemple suivant montre comment définir un point de terminaison personnalisé :

SpeechConfig speechConfig = SpeechConfig.FromSubscription("YourSpeechKey", "YourServiceRegion");
speechConfig.setEndpointId("YourEndpointId");
SpeechRecognizer speechRecognizer = new SpeechRecognizer(speechConfig);

Exécuter et utiliser un conteneur

Les conteneurs Speech fournissent des API de point de terminaison de requête basées sur WebSocket, accessibles via le Kit de développement logiciel (SDK) Speech et l’interface CLI Speech. Par défaut, le kit de développement logiciel (SDK) Speech et l’interface CLI Speech utilisent le service Speech public. Pour utiliser le conteneur, vous devez changer la méthode d’initialisation. Utilisez une URL d’hôte de conteneur plutôt qu’une clé et une région.

Pour plus d’informations sur les conteneurs, consultez la section URL de l’hôte dans Installer et exécuter des conteneurs Speech avec Docker.

Segmentation sémantique

La segmentation sémantique est une stratégie de segmentation de reconnaissance vocale conçue pour atténuer les problèmes associés à la segmentation basée sur le silence :

• Sous-segmentation : lorsque les utilisateurs parlent pendant un long moment sans pause, ils peuvent voir une longue séquence de texte sans saut (« mur de texte »), qui dégrade fortement leur expérience de lisibilité.
• Sur-segmentation : lorsqu’un utilisateur s’interrompt pendant une courte période, le mécanisme de détection du silence peut effectuer une segmentation incorrecte.

Au lieu de compter sur les délais d’expiration du silence, effectue une segmentation sémantique et retourne les résultats finaux lorsqu’il détecte la ponctuation de fin de phrase (par exemple « . » ou « ? »). Cela améliore l’expérience utilisateur avec des segments de qualité supérieure, sémantiquement complets et empêche les résultats intermédiaires longs.

Pour utiliser la segmentation sémantique, vous devez définir la propriété suivante sur l’instance SpeechConfig utilisée pour créer un SpeechRecognizer :

speechConfig.SetProperty(PropertyId.Speech_SegmentationStrategy, "Semantic");

Voici quelques-unes des limitations de la segmentation sémantique :

• Pour utiliser la segmentation sémantique, vous avez besoin du SDK Speech version 1.41 ou ultérieure.
• La segmentation sémantique est uniquement destinée pour une utilisation dans le cadre de la reconnaissance continue. Cela inclut des scénarios tels que la transcription et le sous-titrage. Elle ne doit pas être utilisée dans le cadre de la reconnaissance unique et en mode dictée.
• La segmentation sémantique n’est pas disponible pour toutes les langues et tous les paramètres régionaux. Actuellement, la segmentation sémantique est disponible uniquement pour les paramètres régionaux anglais (en) tels que en-US, en-GB, en-IN et en-AU.
• La segmentation sémantique ne prend pas encore en charge les scores de confiance et les listes NBest. Par conséquent, nous vous déconseillons la segmentation sémantique si vous utilisez des scores de confiance ou des listes NBest.

Documentation de référence | Package (npm) | Exemples supplémentaires sur GitHub | Code source de la bibliothèque

Dans ce guide pratique, vous allez apprendre à utiliser Azure AI Speech pour la reconnaissance vocale en temps réel. La reconnaissance vocale en temps réel est idéale pour les applications nécessitant une transcription immédiate, comme la dictée, l’assistance en centre d’appels et le sous-titrage pour les réunions en direct.

Pour découvrir comment configurer l’environnement pour un exemple d’application, consultez Démarrage rapide : Reconnaître et convertir la parole en texte.

Créer une instance de configuration Speech

Pour appeler le service Speech à l’aide du SDK Speech, vous devez créer une instance 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.

1. Créez une ressource Speech dans le portail Azure. Obtenez la clé de ressource et la région Speech.
2. Créez une instance SpeechConfig à l’aide du code suivant. Remplacez YourSpeechKey et YourSpeechRegion par votre clé de ressource Speech et votre région.

const speechConfig = sdk.SpeechConfig.fromSubscription("YourSpeechKey", "YourSpeechRegion");

Vous pouvez initialiser SpeechConfig de plusieurs autres façons :

• Utilisez un point de terminaison et transmettez un point de terminaison de service Speech. Une clé ou un jeton d’autorisation est facultatif.
• Utilisez un hôte et transmettez une adresse d’hôte. Une clé ou un jeton d’autorisation est facultatif.
• Utilisez un jeton d’autorisation avec la région/l’emplacement associé.

Remarque

Quand vous procédez à une reconnaissance vocale, une synthèse vocale, une traduction ou une reconnaissance intentionnelle, vous créez toujours une configuration.

Reconnaître la voix provenant d’un micro

La reconnaissance vocale à partir d’un microphone n’est pas prise en charge dans Node.js. Elle est prise en charge uniquement dans un environnement JavaScript basé sur un navigateur. Pour plus d’informations, consultez l’exemple React et l’implémentation de la conversion de parole en texte à partir d’un microphone sur GitHub. L’exemple React présente les modèles de conception pour l’échange et la gestion des jetons d’authentification. Il montre également la capture de l’audio à partir d’un microphone ou d’un fichier pour les conversions de parole en texte.

Notes

Si vous souhaitez utiliser un périphérique d’entrée audio spécifique, vous devez spécifier son ID dans AudioConfig. Pour découvrir comment obtenir l’ID de l’appareil, consultez Sélectionner un appareil d’entrée audio avec le Kit de développement logiciel (SDK) Speech.

Utiliser la reconnaissance vocale à partir d’un fichier

Pour reconnaître le message d’un fichier audio, créez une instance AudioConfig à l’aide de la méthode fromWavFileInput() qui accepte un objet Buffer. Initialisez ensuite SpeechRecognizer en passant audioConfig et speechConfig.

const fs = require('fs');
const sdk = require("microsoft-cognitiveservices-speech-sdk");
const speechConfig = sdk.SpeechConfig.fromSubscription("YourSpeechKey", "YourSpeechRegion");

function fromFile() {
    let audioConfig = sdk.AudioConfig.fromWavFileInput(fs.readFileSync("YourAudioFile.wav"));
    let speechRecognizer = new sdk.SpeechRecognizer(speechConfig, audioConfig);

    speechRecognizer.recognizeOnceAsync(result => {
        console.log(`RECOGNIZED: Text=${result.text}`);
        speechRecognizer.close();
    });
}
fromFile();

Reconnaître la parole à partir d’un flux en mémoire

Dans de nombreux cas d’usage, vos données audio viennent probablement d’un Stockage Blob Azure. Ou bien il est déjà en mémoire sous la forme d’un ArrayBuffer ou d’une structure de données brutes similaire. Le code suivant :

• Crée un flux push en utilisant createPushStream().
• Lit un fichier .wav en utilisant fs.createReadStream à des fins de démonstration. Si vous avez déjà des données audio dans le ArrayBuffer, vous pouvez passer directement à l’écriture du contenu dans le flux d’entrée.
• Crée une configuration audio à l’aide du flux push.

const fs = require('fs');
const sdk = require("microsoft-cognitiveservices-speech-sdk");
const speechConfig = sdk.SpeechConfig.fromSubscription("YourSpeechKey", "YourSpeechRegion");

function fromStream() {
    let pushStream = sdk.AudioInputStream.createPushStream();

    fs.createReadStream("YourAudioFile.wav").on('data', function(arrayBuffer) {
        pushStream.write(arrayBuffer.slice());
    }).on('end', function() {
        pushStream.close();
    });
 
    let audioConfig = sdk.AudioConfig.fromStreamInput(pushStream);
    let speechRecognizer = new sdk.SpeechRecognizer(speechConfig, audioConfig);
    speechRecognizer.recognizeOnceAsync(result => {
        console.log(`RECOGNIZED: Text=${result.text}`);
        speechRecognizer.close();
    });
}
fromStream();

L’utilisation d’un flux push comme entrée part du principe que les données audio sont des données au format PCM brut qui ignorent les en-têtes. L’API fonctionne toujours dans certains cas si l’en-tête n’est pas ignoré. Pour obtenir les meilleurs résultats, envisagez d’implémenter une logique pour lire les en-têtes afin que fs commence au début des données audio.

Gérer les erreurs

Les exemples précédents récupèrent seulement le texte reconnu de la propriété result.text. Pour gérer les erreurs et autres réponses, vous devez écrire du code pour gérer le résultat. Le code suivant évalue la propriété result.reason et :

• Affiche le résultat de la reconnaissance : ResultReason.RecognizedSpeech.
• S’il n’existe aucune correspondance de reconnaissance, l’utilisateur est informé : ResultReason.NoMatch.
• Si une erreur se produit, un message d’erreur est affiché : ResultReason.Canceled.

switch (result.reason) {
    case sdk.ResultReason.RecognizedSpeech:
        console.log(`RECOGNIZED: Text=${result.text}`);
        break;
    case sdk.ResultReason.NoMatch:
        console.log("NOMATCH: Speech could not be recognized.");
        break;
    case sdk.ResultReason.Canceled:
        const cancellation = sdk.CancellationDetails.fromResult(result);
        console.log(`CANCELED: Reason=${cancellation.reason}`);

        if (cancellation.reason == sdk.CancellationReason.Error) {
            console.log(`CANCELED: ErrorCode=${cancellation.ErrorCode}`);
            console.log(`CANCELED: ErrorDetails=${cancellation.errorDetails}`);
            console.log("CANCELED: Did you set the speech resource key and region values?");
        }
        break;
    }

Utiliser la reconnaissance continue

Les exemples précédents utilisent la reconnaissance unique, qui reconnaît un énoncé unique. La fin d’un énoncé unique est déterminée par la détection du silence à la fin, ou après que 15 secondes d’audio ont été traitées.

En revanche, vous pouvez utiliser la reconnaissance continue quand vous souhaitez contrôler à quel moment arrêter la reconnaissance. Pour obtenir les résultats de la reconnaissance, vous devez vous abonner aux événements Recognizing, Recognized et Canceled. Pour arrêter la reconnaissance, vous devez appeler [stopContinuousRecognitionAsync] (/javascript/api/microsoft-cognitiveservices-speech-sdk/speechrecognizer#microsoft-cognitiveservices-speech-sdk-speechrecognizer-stopcontinuousrecognitionasync). Voici un exemple de reconnaissance continue sur un fichier d’entrée audio.

Commencez par définir l’entrée et initialiser SpeechRecognizer :

const speechRecognizer = new sdk.SpeechRecognizer(speechConfig, audioConfig);

Ensuite, abonnez-vous aux événements envoyés depuis SpeechRecognizer :

• recognizing : signal pour les événements contenant des résultats de reconnaissance intermédiaires.
• recognized : signal pour les événements qui contiennent des résultats de reconnaissance finaux, ce qui indique une tentative de reconnaissance réussie.
• sessionStopped : signal pour les événements indiquant la fin d’une session (opération) de reconnaissance.
• canceled : signal pour les événements contenant des résultats de reconnaissance annulés. Ces résultats indiquent une tentative de reconnaissance qui a été annulée à la suite d’une demande d’annulation directe. Ils peuvent également indiquer un échec de transport ou de protocole.

speechRecognizer.recognizing = (s, e) => {
    console.log(`RECOGNIZING: Text=${e.result.text}`);
};

speechRecognizer.recognized = (s, e) => {
    if (e.result.reason == sdk.ResultReason.RecognizedSpeech) {
        console.log(`RECOGNIZED: Text=${e.result.text}`);
    }
    else if (e.result.reason == sdk.ResultReason.NoMatch) {
        console.log("NOMATCH: Speech could not be recognized.");
    }
};

speechRecognizer.canceled = (s, e) => {
    console.log(`CANCELED: Reason=${e.reason}`);

    if (e.reason == sdk.CancellationReason.Error) {
        console.log(`"CANCELED: ErrorCode=${e.errorCode}`);
        console.log(`"CANCELED: ErrorDetails=${e.errorDetails}`);
        console.log("CANCELED: Did you set the speech resource key and region values?");
    }

    speechRecognizer.stopContinuousRecognitionAsync();
};

speechRecognizer.sessionStopped = (s, e) => {
    console.log("\n    Session stopped event.");
    speechRecognizer.stopContinuousRecognitionAsync();
};

Tout étant configuré, appelez [startContinuousRecognitionAsync] (/javascript/api/microsoft-cognitiveservices-speech-sdk/speechrecognizer#microsoft-cognitiveservices-speech-sdk-speechrecognizer-startkeywordrecognitionasync) pour commencer la reconnaissance :

speechRecognizer.startContinuousRecognitionAsync();

// Make the following call at some point to stop recognition:
// speechRecognizer.stopContinuousRecognitionAsync();

Changer la langue source

Une tâche courante pour la reconnaissance vocale consiste à spécifier la langue d’entrée (ou source). L’exemple suivant montre comment définir la langue d’entrée sur Italien. Dans votre code, recherchez votre instance SpeechConfig, puis ajoutez cette ligne directement en dessous :

speechConfig.speechRecognitionLanguage = "it-IT";

La propriété speechRecognitionLanguage attend une chaîne au format langue-paramètres régionaux. Pour obtenir une liste des paramètres régionaux pris en charge, consultez Prise en charge des langues et de la voix pour le service Speech.

Identification de la langue

Vous pouvez utiliser l’identification de la langue avec la reconnaissance vocale lorsque vous devez identifier la langue dans une source audio, puis la transcrire en texte.

Pour obtenir un exemple de code complet, consultez Identification de la langue.

Utiliser un point de terminaison personnalisé

Avec la reconnaissance vocale personnalisée, vous pouvez charger vos propres données, tester et entraîner un modèle personnalisé, comparer l’exactitude entre les modèles, et déployer un modèle sur un point de terminaison personnalisé. L’exemple suivant montre comment définir un point de terminaison personnalisé.

var speechConfig = SpeechSDK.SpeechConfig.fromSubscription("YourSubscriptionKey", "YourServiceRegion");
speechConfig.endpointId = "YourEndpointId";
var speechRecognizer = new SpeechSDK.SpeechRecognizer(speechConfig);

Exécuter et utiliser un conteneur

Les conteneurs Speech fournissent des API de point de terminaison de requête basées sur WebSocket, accessibles via le Kit de développement logiciel (SDK) Speech et l’interface CLI Speech. Par défaut, le kit de développement logiciel (SDK) Speech et l’interface CLI Speech utilisent le service Speech public. Pour utiliser le conteneur, vous devez changer la méthode d’initialisation. Utilisez une URL d’hôte de conteneur plutôt qu’une clé et une région.

Pour plus d’informations sur les conteneurs, consultez la section URL de l’hôte dans Installer et exécuter des conteneurs Speech avec Docker.

Documentation de référence | Package (téléchargement) | Exemples supplémentaires sur GitHub

Dans ce guide pratique, vous allez apprendre à utiliser Azure AI Speech pour la reconnaissance vocale en temps réel. La reconnaissance vocale en temps réel est idéale pour les applications nécessitant une transcription immédiate, comme la dictée, l’assistance en centre d’appels et le sous-titrage pour les réunions en direct.

Pour découvrir comment configurer l’environnement pour un exemple d’application, consultez Démarrage rapide : Reconnaître et convertir la parole en texte.

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

Le référentiel Azure-Samples/cognitive-services-speech-sdk contient des exemples écrits en Objective-C pour iOS et Mac. Sélectionnez un lien pour afficher les instructions d’installation de chaque exemple :

• Reconnaissance vocale à partir d’un microphone en Objective-C sur macOS
• Reconnaissance vocale en Objective-C sur iOS
• Exemples supplémentaires pour Objective-C sur iOS

Pour plus d’informations, consultez la Référence du kit de développement logiciel (SDK) Speech pour Objective-C.

Utiliser un point de terminaison personnalisé

Avec la reconnaissance vocale personnalisée, vous pouvez charger vos propres données, tester et entraîner un modèle personnalisé, comparer l’exactitude entre les modèles, et déployer un modèle sur un point de terminaison personnalisé. L’exemple suivant montre comment définir un point de terminaison personnalisé :

SPXSpeechConfiguration *speechConfig = [[SPXSpeechConfiguration alloc] initWithSubscription:"YourSubscriptionKey" region:"YourServiceRegion"];
speechConfig.endpointId = "YourEndpointId";
SPXSpeechRecognizer* speechRecognizer = [[SPXSpeechRecognizer alloc] init:speechConfig];

Exécuter et utiliser un conteneur

Les conteneurs Speech fournissent des API de point de terminaison de requête basées sur WebSocket, accessibles via le Kit de développement logiciel (SDK) Speech et l’interface CLI Speech. Par défaut, le kit de développement logiciel (SDK) Speech et l’interface CLI Speech utilisent le service Speech public. Pour utiliser le conteneur, vous devez changer la méthode d’initialisation. Utilisez une URL d’hôte de conteneur plutôt qu’une clé et une région.

Pour plus d’informations sur les conteneurs, consultez la section URL de l’hôte dans Installer et exécuter des conteneurs Speech avec Docker.

Documentation de référence | Package (téléchargement) | Exemples supplémentaires sur GitHub

Dans ce guide pratique, vous allez apprendre à utiliser Azure AI Speech pour la reconnaissance vocale en temps réel. La reconnaissance vocale en temps réel est idéale pour les applications nécessitant une transcription immédiate, comme la dictée, l’assistance en centre d’appels et le sous-titrage pour les réunions en direct.

Pour découvrir comment configurer l’environnement pour un exemple d’application, consultez Démarrage rapide : Reconnaître et convertir la parole en texte.

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

Le référentiel Azure-Samples/cognitive-services-speech-sdk contient des exemples écrits en Swift pour iOS et Mac. Sélectionnez un lien pour afficher les instructions d’installation de chaque exemple :

• Reconnaissance vocale en Swift sur macOS
• Reconnaissance vocale en Swift sur iOS

Pour plus d’informations, consultez la Référence du kit de développement logiciel (SDK) Speech pour Objective-C.

Utiliser un point de terminaison personnalisé

Avec la reconnaissance vocale personnalisée, vous pouvez charger vos propres données, tester et entraîner un modèle personnalisé, comparer l’exactitude entre les modèles, et déployer un modèle sur un point de terminaison personnalisé. L’exemple suivant montre comment définir un point de terminaison personnalisé :

let speechConfig = SPXSpeechConfiguration(subscription: "YourSubscriptionKey", region: "YourServiceRegion");
speechConfig.endpointId = "YourEndpointId";
let speechRecognizer = SPXSpeechRecognizer(speechConfiguration: speechConfig);

Exécuter et utiliser un conteneur

Les conteneurs Speech fournissent des API de point de terminaison de requête basées sur WebSocket, accessibles via le Kit de développement logiciel (SDK) Speech et l’interface CLI Speech. Par défaut, le kit de développement logiciel (SDK) Speech et l’interface CLI Speech utilisent le service Speech public. Pour utiliser le conteneur, vous devez changer la méthode d’initialisation. Utilisez une URL d’hôte de conteneur plutôt qu’une clé et une région.

Pour plus d’informations sur les conteneurs, consultez la section URL de l’hôte dans Installer et exécuter des conteneurs Speech avec Docker.

Documentation de référence | Package (PyPi) | Exemples supplémentaires sur GitHub

Dans ce guide pratique, vous allez apprendre à utiliser Azure AI Speech pour la reconnaissance vocale en temps réel. La reconnaissance vocale en temps réel est idéale pour les applications nécessitant une transcription immédiate, comme la dictée, l’assistance en centre d’appels et le sous-titrage pour les réunions en direct.

Pour découvrir comment configurer l’environnement pour un exemple d’application, consultez Démarrage rapide : Reconnaître et convertir la parole en texte.

Créer une instance de configuration Speech

Pour appeler le service Speech à l’aide du SDK Speech, vous devez créer une instance SpeechConfig. Cette classe comprend des informations sur votre abonnement, telles que votre clé Speech et votre région, et le point de terminaison, l’hôte ou le jeton d’autorisation associés.

1. Créez une ressource Speech dans le portail Azure. Obtenez la clé de ressource et la région Speech.
2. Créez une instance SpeechConfig à l’aide du code suivant. Remplacez YourSpeechKey et YourSpeechRegion par votre clé de ressource Speech et votre région.

speech_config = speechsdk.SpeechConfig(subscription="YourSpeechKey", region="YourSpeechRegion")

Vous pouvez initialiser SpeechConfig de plusieurs autres façons :

• Utilisez un point de terminaison et transmettez un point de terminaison de service Speech. Une clé Speech ou un jeton d’autorisation est facultatif.
• Utilisez un hôte et transmettez une adresse d’hôte. Une clé Speech ou un jeton d’autorisation est facultatif.
• Utilisez un jeton d’autorisation avec la région/l’emplacement associé.

Remarque

Quand vous procédez à une reconnaissance vocale, une synthèse vocale, une traduction ou une reconnaissance intentionnelle, vous créez toujours une configuration.

Reconnaître la voix provenant d’un micro

Pour reconnaître la voix à l’aide du microphone de votre appareil, créez une instance SpeechRecognizer sans passer AudioConfig, puis passez speech_config :

import azure.cognitiveservices.speech as speechsdk

def from_mic():
    speech_config = speechsdk.SpeechConfig(subscription="YourSpeechKey", region="YourSpeechRegion")
    speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config)

    print("Speak into your microphone.")
    speech_recognition_result = speech_recognizer.recognize_once_async().get()
    print(speech_recognition_result.text)

from_mic()

Si vous souhaitez utiliser un périphérique d’entrée audio spécifique, vous devez spécifier son ID dans AudioConfig et le passer au paramètre audio_config du constructeur SpeechRecognizer. Pour découvrir comment obtenir l’ID de l’appareil, consultez Sélectionner un appareil d’entrée audio avec le Kit de développement logiciel (SDK) Speech.

Utiliser la reconnaissance vocale à partir d’un fichier

Si vous souhaitez reconnaître la voix à partir d’un fichier audio au lieu d’utiliser un microphone, créez une instance AudioConfig et utilisez le paramètre filename :

import azure.cognitiveservices.speech as speechsdk

def from_file():
    speech_config = speechsdk.SpeechConfig(subscription="YourSpeechKey", region="YourSpeechRegion")
    audio_config = speechsdk.AudioConfig(filename="your_file_name.wav")
    speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config, audio_config=audio_config)

    speech_recognition_result = speech_recognizer.recognize_once_async().get()
    print(speech_recognition_result.text)

from_file()

Gérer les erreurs

Les exemples précédents récupèrent seulement le texte reconnu de la propriété speech_recognition_result.text. Pour gérer les erreurs et autres réponses, vous devez écrire du code pour gérer le résultat. Le code suivant évalue la propriété speech_recognition_result.reason et :

• Affiche le résultat de la reconnaissance : speechsdk.ResultReason.RecognizedSpeech.
• S’il n’existe aucune correspondance de reconnaissance, l’utilisateur est informé : speechsdk.ResultReason.NoMatch.
• Si une erreur se produit, un message d’erreur est affiché : speechsdk.ResultReason.Canceled.

if speech_recognition_result.reason == speechsdk.ResultReason.RecognizedSpeech:
    print("Recognized: {}".format(speech_recognition_result.text))
elif speech_recognition_result.reason == speechsdk.ResultReason.NoMatch:
    print("No speech could be recognized: {}".format(speech_recognition_result.no_match_details))
elif speech_recognition_result.reason == speechsdk.ResultReason.Canceled:
    cancellation_details = speech_recognition_result.cancellation_details
    print("Speech Recognition canceled: {}".format(cancellation_details.reason))
    if cancellation_details.reason == speechsdk.CancellationReason.Error:
        print("Error details: {}".format(cancellation_details.error_details))
        print("Did you set the speech resource key and region values?")

Utiliser la reconnaissance continue

Les exemples précédents utilisent la reconnaissance unique, qui reconnaît un énoncé unique. La fin d’un énoncé unique est déterminée par la détection du silence à la fin, ou après que 15 secondes d’audio ont été traitées.

En revanche, vous utilisez la reconnaissance continue quand vous souhaitez contrôler à quel moment arrêter la reconnaissance. Pour obtenir les résultats de la reconnaissance, vous devez vous connecter à EventSignal. Pour arrêter la reconnaissance, vous devez appeler stop_continuous_recognition() ou stop_continuous_recognition_async(). Voici un exemple de reconnaissance continue sur un fichier d’entrée audio.

Commencez par définir l’entrée et initialiser SpeechRecognizer :

audio_config = speechsdk.audio.AudioConfig(filename=weatherfilename)
speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config, audio_config=audio_config)

Ensuite, créez une variable pour gérer l’état de la reconnaissance vocale. Définissez la variable sur False, car au début de la reconnaissance, vous pouvez supposer sans risque qu’elle n’est pas terminée :

done = False

Maintenant, créez un rappel pour arrêter la reconnaissance continue lors de la réception de evt. Gardez à l’esprit les points suivants :

• Lors de la réception de evt, le message evt s’affiche.
• Après la réception de evt, stop_continuous_recognition() est appelé pour arrêter la reconnaissance.
• L’état de la reconnaissance devient True.

def stop_cb(evt):
    print('CLOSING on {}'.format(evt))
    speech_recognizer.stop_continuous_recognition()
    nonlocal done
    done = True

L’exemple de code suivant montre comment connecter des rappels aux événements envoyés depuis SpeechRecognizer. Les événements sont :

• recognizing : signal pour les événements contenant des résultats de reconnaissance intermédiaires.
• recognized : signal pour les événements qui contiennent des résultats de reconnaissance finaux, ce qui indique une tentative de reconnaissance réussie.
• session_started : signal pour les événements indiquant le début d’une session (opération) de reconnaissance.
• session_stopped : signal pour les événements indiquant la fin d’une session (opération) de reconnaissance.
• canceled : signal pour les événements contenant des résultats de reconnaissance annulés. Ces résultats indiquent une tentative de reconnaissance qui a été annulée à la suite d’une demande d’annulation directe. Ils peuvent également indiquer un échec de transport ou de protocole.

speech_recognizer.recognizing.connect(lambda evt: print('RECOGNIZING: {}'.format(evt)))
speech_recognizer.recognized.connect(lambda evt: print('RECOGNIZED: {}'.format(evt)))
speech_recognizer.session_started.connect(lambda evt: print('SESSION STARTED: {}'.format(evt)))
speech_recognizer.session_stopped.connect(lambda evt: print('SESSION STOPPED {}'.format(evt)))
speech_recognizer.canceled.connect(lambda evt: print('CANCELED {}'.format(evt)))

speech_recognizer.session_stopped.connect(stop_cb)
speech_recognizer.canceled.connect(stop_cb)

Tout étant configuré, vous pouvez maintenant appeler start_continuous_recognition() :

speech_recognizer.start_continuous_recognition()
while not done:
    time.sleep(.5)

Changer la langue source

Une tâche courante pour la reconnaissance vocale consiste à spécifier la langue d’entrée (ou source). L’exemple suivant montre comment définir la langue d’entrée sur Allemand. Dans votre code, recherchez votre instance SpeechConfig, puis ajoutez cette ligne directement en dessous :

speech_config.speech_recognition_language="de-DE"

speech_recognition_language est un paramètre qui prend une chaîne comme argument. Pour obtenir une liste des paramètres régionaux pris en charge, consultez Prise en charge des langues et de la voix pour le service Speech.

Identification de la langue

Vous pouvez utiliser l’identification de la langue avec la reconnaissance vocale lorsque vous devez identifier la langue dans une source audio, puis la transcrire en texte.

Pour obtenir un exemple de code complet, consultez Identification de la langue.

Utiliser un point de terminaison personnalisé

Avec la reconnaissance vocale personnalisée, vous pouvez charger vos propres données, tester et entraîner un modèle personnalisé, comparer l’exactitude entre les modèles, et déployer un modèle sur un point de terminaison personnalisé. L’exemple suivant montre comment définir un point de terminaison personnalisé.

speech_config = speechsdk.SpeechConfig(subscription="YourSubscriptionKey", region="YourServiceRegion")
speech_config.endpoint_id = "YourEndpointId"
speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config)

Exécuter et utiliser un conteneur

Les conteneurs Speech fournissent des API de point de terminaison de requête basées sur WebSocket, accessibles via le Kit de développement logiciel (SDK) Speech et l’interface CLI Speech. Par défaut, le kit de développement logiciel (SDK) Speech et l’interface CLI Speech utilisent le service Speech public. Pour utiliser le conteneur, vous devez changer la méthode d’initialisation. Utilisez une URL d’hôte de conteneur plutôt qu’une clé et une région.

Pour plus d’informations sur les conteneurs, consultez la section URL de l’hôte dans Installer et exécuter des conteneurs Speech avec Docker.

Segmentation sémantique

La segmentation sémantique est une stratégie de segmentation de reconnaissance vocale conçue pour atténuer les problèmes associés à la segmentation basée sur le silence :

• Sous-segmentation : lorsque les utilisateurs parlent pendant un long moment sans pause, ils peuvent voir une longue séquence de texte sans saut (« mur de texte »), qui dégrade fortement leur expérience de lisibilité.
• Sur-segmentation : lorsqu’un utilisateur s’interrompt pendant une courte période, le mécanisme de détection du silence peut effectuer une segmentation incorrecte.

Au lieu de compter sur les délais d’expiration du silence, effectue une segmentation sémantique et retourne les résultats finaux lorsqu’il détecte la ponctuation de fin de phrase (par exemple « . » ou « ? »). Cela améliore l’expérience utilisateur avec des segments de qualité supérieure, sémantiquement complets et empêche les résultats intermédiaires longs.

Pour utiliser la segmentation sémantique, vous devez définir la propriété suivante sur l’instance SpeechConfig utilisée pour créer un SpeechRecognizer :

speech_config.set_property(speechsdk.PropertyId.Speech_SegmentationStrategy, "Semantic") 

Voici quelques-unes des limitations de la segmentation sémantique :

• Pour utiliser la segmentation sémantique, vous avez besoin du SDK Speech version 1.41 ou ultérieure.
• La segmentation sémantique est uniquement destinée pour une utilisation dans le cadre de la reconnaissance continue. Cela inclut des scénarios tels que la transcription et le sous-titrage. Elle ne doit pas être utilisée dans le cadre de la reconnaissance unique et en mode dictée.
• La segmentation sémantique n’est pas disponible pour toutes les langues et tous les paramètres régionaux. Actuellement, la segmentation sémantique est disponible uniquement pour les paramètres régionaux anglais (en) tels que en-US, en-GB, en-IN et en-AU.
• La segmentation sémantique ne prend pas encore en charge les scores de confiance et les listes NBest. Par conséquent, nous vous déconseillons la segmentation sémantique si vous utilisez des scores de confiance ou des listes NBest.

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

Dans ce guide pratique, vous allez apprendre à utiliser Azure AI Speech pour la reconnaissance vocale en temps réel. La reconnaissance vocale en temps réel est idéale pour les applications nécessitant une transcription immédiate, comme la dictée, l’assistance en centre d’appels et le sous-titrage pour les réunions en direct.

Pour découvrir comment configurer l’environnement pour un exemple d’application, consultez Démarrage rapide : Reconnaître et convertir la parole en texte.

Convertir la parole en texte

Depuis une invite de commandes, exécutez la commande suivante. Insérez les valeurs suivantes dans la commande :

• Votre clé d’abonnement pour la ressource Speech
• Votre région du service Speech
• Le chemin du fichier audio d’entrée

curl --location --request POST 'https://INSERT_REGION_HERE.stt.speech.microsoft.com/speech/recognition/conversation/cognitiveservices/v1?language=en-US' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE' \
--header 'Content-Type: audio/wav' \
--data-binary @'INSERT_AUDIO_FILE_PATH_HERE'

Vous devez recevoir une réponse semblable à l’exemple suivant :

{
    "RecognitionStatus": "Success",
    "DisplayText": "My voice is my passport, verify me.",
    "Offset": 6600000,
    "Duration": 32100000
}

Pour plus d’informations, consultez les informations de référence sur l’API REST de reconnaissance vocale.

Dans ce guide pratique, vous allez apprendre à utiliser Azure AI Speech pour la reconnaissance vocale en temps réel. La reconnaissance vocale en temps réel est idéale pour les applications nécessitant une transcription immédiate, comme la dictée, l’assistance en centre d’appels et le sous-titrage pour les réunions en direct.

Pour découvrir comment configurer l’environnement pour un exemple d’application, consultez Démarrage rapide : Reconnaître et convertir la parole en texte.

Reconnaître la voix provenant d’un micro

Branchez et allumez le microphone de votre PC. Désactivez toutes les applications susceptibles d’utiliser aussi le microphone. Certains ordinateurs disposent d’un microphone intégré, tandis que d’autres nécessitent la configuration d’un appareil Bluetooth.

Vous êtes maintenant prêt à exécuter l’interface CLI Speech pour reconnaître la voix à partir de votre microphone. À partir de la ligne de commande, accédez au répertoire qui contient le fichier binaire de l'interface CLI Speech. Exécutez ensuite la commande suivante :

spx recognize --microphone

Notes

La valeur par défaut de l’interface CLI Speech est Anglais. Vous pouvez choisir une autre langue dans la table Reconnaissance vocale. Par exemple, ajoutez --source de-DE pour reconnaître de la voix en allemand.

Parlez dans le microphone, et vous pourrez voir la transcription de vos mots en texte en temps réel. L’interface CLI Speech s’arrête après une période de silence, ou lorsque vous sélectionnez Ctrl+C.

Utiliser la reconnaissance vocale à partir d’un fichier

L’interface CLI Speech peut reconnaître la voix dans de nombreux formats de fichier et dans des langages naturels. Dans cet exemple, vous pouvez utiliser un fichier .wav (16 kHz ou 8 kHz, 16 bits et PCM mono) qui contient des paroles en anglais. Autrement, si vous souhaitez un exemple rapide, téléchargez le fichier whatstheweatherlike.wav et copiez-le dans le même répertoire que le fichier binaire de l’interface CLI Speech.

Utilisez la commande suivante pour exécuter l’interface CLI Speech afin de reconnaître la voix trouvée dans le fichier audio :

spx recognize --file whatstheweatherlike.wav

Notes

La valeur par défaut de l’interface CLI Speech est Anglais. Vous pouvez choisir une autre langue dans la table Reconnaissance vocale. Par exemple, ajoutez --source de-DE pour reconnaître de la voix en allemand.

L’interface CLI Speech montre une transcription textuelle de la voix à l’écran.

Exécuter et utiliser un conteneur

Les conteneurs Speech fournissent des API de point de terminaison de requête basées sur WebSocket, accessibles via le Kit de développement logiciel (SDK) Speech et l’interface CLI Speech. Par défaut, le kit de développement logiciel (SDK) Speech et l’interface CLI Speech utilisent le service Speech public. Pour utiliser le conteneur, vous devez changer la méthode d’initialisation. Utilisez une URL d’hôte de conteneur plutôt qu’une clé et une région.

Pour plus d’informations sur les conteneurs, consultez la section URL de l’hôte dans Installer et exécuter des conteneurs Speech avec Docker.

Contenu connexe

• Essayer le guide de démarrage rapide sur la reconnaissance vocale
• Améliorer la précision de la reconnaissance avec Custom Speech
• Utiliser la transcription Batch