Cet article a fait l'objet d'une traduction automatique.
Reconnaissance de la parole grâce aux applications .NET Desktop
Avec l'introduction de Windows Phone Cortana, l'assistante personnelle de la parole-activé (ainsi que le she-who-must-not-be-named similaire de la société de fruits), applications de reconnaissance vocale ont pris une place de plus en plus importante dans le développement de logiciels. Dans cet article, je vais vous montrer comment débuter avec reconnaissance vocale et la synthèse vocale dans les applications de console Windows, applications Windows Forms et applications Windows Presentation Foundation (WPF).
Notez que vous pouvez également ajouter des fonctionnalités vocales à Windows Phone apps, ASP.NET Web apps, Windows Store apps, apps RT Windows et Xbox Kinect, mais les techniques ne sont différents de ceux présentés dans cet article.
Un bon moyen de voir ce que cet article va expliquer consiste à regarder les captures d'écran de deux programmes différents de démo en Figure 1 et Figure 2. Après l'application de console dans Figure 1 a été lancé, l'app immédiatement parlé la phrase « Je suis éveillé. » Bien sûr, vous n'entendez la démo en lisant cet article, et le texte de ce que dit l'ordinateur affiche alors le programme de démonstration. Ensuite, l'utilisateur a parlé de la commande « Discours sur ». La démo fait écho au texte qui a été reconnu, et puis, dans les coulisses, a permis l'application d'écouter et de répondre aux demandes d'ajouter deux nombres.
.png "la reconnaissance vocale et synthèse dans une Application Console")
Figure 1 la reconnaissance vocale et synthèse dans une Application Console
.png "la reconnaissance vocale Windows fait Application")
Figure 2 la reconnaissance vocale Windows fait Application
L'utilisateur a demandé l'application pour ajouter un plus deux, puis deux plus trois. L'application reconnaît ces commandes vocales et a donné les réponses à haute voix. Je vais décrire des façons plus utile d'utiliser la reconnaissance vocale plus tard.
L'utilisateur a alors émis la commande « Discours off » qui a désactivé l'écoute des commandes pour ajouter des numéros, mais n'a pas complètement désactiver la reconnaissance vocale. Discours au large, la prochaine commande parlée d'ajouter un plus deux a été ignorée. Enfin, l'utilisateur tourné le discours dos et a parlé de la commande de non-sens, « Klatu barada nikto, » dont l'application a reconnu que la commande pour complètement désactiver la reconnaissance vocale et quitter l'application.
La figure 2 montre une application Windows Forms discours factice. L'application reconnaît les commandes vocales, mais ne répond pas avec sortie vocale. Lorsque l'application a été lancée tout d'abord, le discours sur case à cocher contrôle n'a pas été vérifié, indiquant la reconnaissance vocale n'est pas active. L'utilisateur vérifié le discours sur le contrôle et ensuite parlé, « Bonjour ». L'application a fait écho le texte reconnu parlé dans le contrôle ListBox au bas de l'application.
L'utilisateur a alors dit: « Valeur texte encadré 1 rouge ». L'application reconnue, « Set text box 1 rouge, » qui est presque, mais pas tout à fait — exactement ce que l'utilisateur a parlé. Bien que non visible dans Figure 2, en effet, le texte dans le contrôle TextBox en haut de l'application a été mis au « rouge ».
Ensuite, le parle de l'utilisateur, « S'il vous plaît set 1 boîte de texte blanc. » L'application reconnue « set texte encadré 1 blanc » et ne vient que. L'utilisateur a conclu en parlant, « Au revoir, » et l'application fait écho à la commande, mais n'a pas manipuler les formulaires Windows, même s'il pourrait, par exemple, en désactivant le contrôle vocale sur checkbox.
Dans les sections qui suivent, je vais vous guider le processus de création de deux programmes de démonstration, y compris l'installation des bibliothèques .NET speech requis. Cet article suppose que vous avez au moins intermédiaire de compétences en programmation, mais ne suppose que vous savez quelque chose sur la reconnaissance vocale ou la synthèse vocale.
Pour créer la démo montrée Figure 1, j'ai lancé Visual Studio et créé une nouvelle application de console c# nommée ConsoleSpeech. J'ai utilisé avec succès les discours avec Visual Studio 2010 et 2012, mais toute version récente devrait fonctionner. Après que le code du modèle chargé dans l'éditeur, dans la fenêtre de l'Explorateur de solutions j'ai renommé le fichier Program.cs pour le ConsoleSpeechProgram.cs plus descriptif et puis Visual Studio renommé classe programme pour moi.
Ensuite, j'ai ajouté une référence au fichier Microsoft.Speech.dll, qui se trouvait à C:\ProgramFiles (x 86) \Microsoft SDKs\Speech\v11.0\Assembly. Cette DLL n'était pas sur ma machine hôte et devait être téléchargé. Installer les fichiers nécessaires pour ajouter la reconnaissance vocale et la synthèse d'une application n'est pas aussi insignifiant. Je vais expliquer le processus d'installation en détail dans la section suivante de cet article, mais pour l'instant, supposons que Microsoft.Speech.dll existe sur votre ordinateur.
Après avoir ajouté la référence à la DLL du discours, en haut du code source que j'ai supprimé tout à l'aide des déclarations à l'exception de celui qui pointe vers l'espace de noms System niveau supérieur. Ensuite, j'ai ajouté à l'aide des déclarations d'espaces de noms Microsoft.Speech.Recognition, Microsoft.Speech.Synthesis et System.Globalization. Les deux premiers espaces de noms sont associés avec le discours DLL. Remarque : Un peu confusément, il y a aussi des espaces de noms System.Speech.Recognition et System.Speech.Synthesis. Je vais vous expliquer la différence sous peu. L'espace de noms Globalization est disponible par défaut et n'a pas besoin d'ajouter une nouvelle référence au projet.
Le code source entier pour la démo d'application console apparaît en Figure 3 et est également disponible dans le téléchargement de code qui accompagne cet article. J'ai enlevé la vérification pour garder les idées principales et aussi clair que possible d'erreur normal tous.
Figure 3 démo Console Application Source Code
using System;
using Microsoft.Speech.Recognition;
using Microsoft.Speech.Synthesis;
using System.Globalization;
namespace ConsoleSpeech
{
class ConsoleSpeechProgram
{
static SpeechSynthesizer ss = new SpeechSynthesizer();
static SpeechRecognitionEngine sre;
static bool done = false;
static bool speechOn = true;
static void Main(string[] args)
{
try
{
ss.SetOutputToDefaultAudioDevice();
Console.WriteLine("\n(Speaking: I am awake)");
ss.Speak("I am awake");
CultureInfo ci = new CultureInfo("en-us");
sre = new SpeechRecognitionEngine(ci);
sre.SetInputToDefaultAudioDevice();
sre.SpeechRecognized += sre_SpeechRecognized;
Choices ch_StartStopCommands = new Choices();
ch_StartStopCommands.Add("speech on");
ch_StartStopCommands.Add("speech off");
ch_StartStopCommands.Add("klatu barada nikto");
GrammarBuilder gb_StartStop = new GrammarBuilder();
gb_StartStop.Append(ch_StartStopCommands);
Grammar g_StartStop = new Grammar(gb_StartStop);
Choices ch_Numbers = new Choices();
ch_Numbers.Add("1");
ch_Numbers.Add("2");
ch_Numbers.Add("3");
ch_Numbers.Add("4");
GrammarBuilder gb_WhatIsXplusY = new GrammarBuilder();
gb_WhatIsXplusY.Append("What is");
gb_WhatIsXplusY.Append(ch_Numbers);
gb_WhatIsXplusY.Append("plus");
gb_WhatIsXplusY.Append(ch_Numbers);
Grammar g_WhatIsXplusY = new Grammar(gb_WhatIsXplusY);
sre.LoadGrammarAsync(g_StartStop);
sre.LoadGrammarAsync(g_WhatIsXplusY);
sre.RecognizeAsync(RecognizeMode.Multiple);
while (done == false) { ; }
Console.WriteLine("\nHit <enter> to close shell\n");
Console.ReadLine();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.ReadLine();
}
} // Main
static void sre_SpeechRecognized(object sender,
SpeechRecognizedEventArgs e)
{
string txt = e.Result.Text;
float confidence = e.Result.Confidence;
Console.WriteLine("\nRecognized: " + txt);
if (confidence < 0.60) return;
if (txt.IndexOf("speech on") >= 0)
{
Console.WriteLine("Speech is now ON");
speechOn = true;
}
if (txt.IndexOf("speech off") >= 0)
{
Console.WriteLine("Speech is now OFF");
speechOn = false;
}
if (speechOn == false) return;
if (txt.IndexOf("klatu") >= 0 && txt.IndexOf("barada") >= 0)
{
((SpeechRecognitionEngine)sender).RecognizeAsyncCancel();
done = true;
Console.WriteLine("(Speaking: Farewell)");
ss.Speak("Farewell");
}
if (txt.IndexOf("What") >= 0 && txt.IndexOf("plus") >= 0)
{
string[] words = txt.Split(' ');
int num1 = int.Parse(words[2]);
int num2 = int.Parse(words[4]);
int sum = num1 + num2;
Console.WriteLine("(Speaking: " + words[2] + " plus " +
words[4] + " equals " + sum + ")");
ss.SpeakAsync(words[2] + " plus " + words[4] +
" equals " + sum);
}
} // sre_SpeechRecognized
} // Program
} // ns
Après l'utilisation de déclarations, le code de démo commence comme ainsi :
namespace ConsoleSpeech
{
class ConsoleSpeechProgram
{
static SpeechSynthesizer ss = new SpeechSynthesizer();
static SpeechRecognitionEngine sre;
static bool done = false;
static bool speechOn = true;
static void Main(string[] args)
{
...
L'objet de la classe-portée SpeechSynthesizer donne à l'application la capacité de parler. L'objet SpeechRecognitionEngine permet à l'application écouter et reconnaître des mots ou des phrases. La variable booléenne « faite » détermine quand l'ensemble de l'application est terminé. SpeechOn variable booléenne détermine si l'application est à l'écoute pour toutes les commandes autre qu'une commande pour quitter le programme.
L'idée ici est que l'application de console n'accepte pas typé d'entrée au clavier, afin que l'application est toujours à l'écoute des commandes. Toutefois, si speechOn a la valeur false, seule la commande pour quitter le programme est reconnue et ont agi sur ; autres commandes seront reconnus mais ignorés.
La méthode Main commence :
try
{
ss.SetOutputToDefaultAudioDevice();
Console.WriteLine("\n(Speaking: I am awake)");
ss.Speak("I am awake");
L'objet SpeechSynthesizer a été instancié lorsqu'elle a été déclarée. À l'aide d'un objet de synthétiseur est assez simple. Le SetOutputToDefaultAudioDevice méthode envoie la sortie vers les haut-parleurs de votre machine (sortie peut également être envoyé vers un fichier). La méthode Speak accepte une chaîne et puis, bien, parle. C'est aussi simple que ça.
La reconnaissance vocale est beaucoup plus difficile que la synthèse vocale. La méthode Main continue en créant l'objet recognizer :
CultureInfo ci = new CultureInfo("en-us");
sre = new SpeechRecognitionEngine(ci);
sre.SetInputToDefaultAudioDevice();
sre.SpeechRecognized += sre_SpeechRecognized;
Tout d'abord, la langue de reconnaître est spécifié, l'anglais des États-Unis dans ce cas, dans un objet CultureInfo. L'objet CultureInfo est situé dans l'espace de noms Globalization référencée avec un énoncé. Ensuite, après avoir appelé le constructeur SpeechRecognitionEngine, entrée de voix est sur le périphérique audio par défaut, un micro dans la plupart des situations. Notez que la plupart des ordinateurs portables ont un microphone intégré, mais plupart des machines de bureau aurez besoin d'un microphone externe (souvent combiné avec un casque d'écoute ces jours-ci).
La principale méthode de l'objet recognizer est le gestionnaire d'événements SpeechRecognized. Lorsque vous utilisez Visual Studio, si vous tapez « sre.Discours+= a reconnu "et attendre qu'une fraction de seconde, l' IntelliSense caractéristique volonté semi-automatique votre déclaration avec"sre_SpeechRecognized"pour le nom du gestionnaire d'événements. Je recommande de frapper la touche de tabulation pour accepter et utiliser ce nom par défaut.
Ensuite, la démonstration met en place la capacité de reconnaître des commandes pour additionner deux nombres :
Choices ch_Numbers = new Choices();
ch_Numbers.Add("1");
ch_Numbers.Add("2");
ch_Numbers.Add("3");
ch_Numbers.Add("4"); // Technically Add(new string[] { "4" });
GrammarBuilder gb_WhatIsXplusY = new GrammarBuilder();
gb_WhatIsXplusY.Append("What is");
gb_WhatIsXplusY.Append(ch_Numbers);
gb_WhatIsXplusY.Append("plus");
gb_WhatIsXplusY.Append(ch_Numbers);
Grammar g_WhatIsXplusY = new Grammar(gb_WhatIsXplusY);
Les trois objets principaux ici sont une collection de choix, un modèle GrammarBuilder et la contrôle de grammaire. Lorsque je conçois reconnaissance grammaire, je commence en listant quelques exemples précis de ce que je veux reconnaître. Par exemple, "ce qui est un plus deux?" et, "ce qui est trois plus quatre?"
Puis, j'ai déterminer le modèle général correspondant, par exemple, "ce qui est plus ?" Le modèle est un GrammarBuilder et les valeurs spécifiques qui entrent dans le modèle sont les choix. L'objet de la grammaire encapsule le modèle et le choix.
Dans la démo, j'ai restreindre les nombres à ajouter aux 1 à 4 et les ajouter sous forme de chaînes à la collection de choix. Une meilleure approche consiste :
string[] numbers = new string[] { "1", "2", "3", "4" };
Choices ch_Numbers = new Choices(numbers);
Je vous présente l'approche plus faible pour créer une collection de choix pour deux raisons. Tout d'abord, ajoutant une corde à la fois était la seule approche que j'ai vu dans d'autres exemples de discours. Deuxièmement, vous pourriez penser qu'ajouter une corde à la fois ne devrait pas même travailler ; le temps réel de Visual Studio IntelliSense montre qu'une des surcharges Add accepte un paramètre de type "params string [] phrases." Si vous n'a pas remarqué le mot clé params vous pourriez penser que la méthode Add accepte uniquement un tableau de chaînes, plutôt qu'un tableau de type string ou une chaîne unique. Je recommande de passer un tableau.
Création d'une collection de choix de numéros consécutifs est un peu un cas particulier et permet une approche programmatique comme ceci :
string[] numbers = new string[100];
for (int i = 0; i < 100; ++i)
numbers[i] = i.ToString();
Choices ch_Numbers = new Choices(numbers);
Après avoir créé le choix de remplir les fentes de la GrammarBuilder, la démo crée la GrammarBuilder, puis la commande grammaire, comme suit :
GrammarBuilder gb_WhatIsXplusY = new GrammarBuilder();
gb_WhatIsXplusY.Append("What is");
gb_WhatIsXplusY.Append(ch_Numbers);
gb_WhatIsXplusY.Append("plus");
gb_WhatIsXplusY.Append(ch_Numbers);
Grammar g_WhatIsXplusY = new Grammar(gb_WhatIsXplusY);
La démo utilise un modèle similaire pour créer une grammaire pour démarrage et arrêt-commandes liées aux :
Choices ch_StartStopCommands = new Choices();
ch_StartStopCommands.Add("speech on");
ch_StartStopCommands.Add("speech off");
ch_StartStopCommands.Add("klatu barada nikto");
GrammarBuilder gb_StartStop = new GrammarBuilder();
gb_StartStop.Append(ch_StartStopCommands);
Grammar g_StartStop = new Grammar(gb_StartStop);
Vous avez une grande flexibilité lors de la définition de grammaires. Ici, les commandes « discours sur », "voix off" et « klatu barada nikto » sont tous placés dans la même grammaire, parce qu'elles sont liées de manière logique. Les trois commandes pourraient été définies dans trois grammaires distincts, ou vous pouvez mettre le « discours sur » et de « discours sur » commandes dans une grammaire et de la commande « klatu barada nikto » dans une deuxième grammaire.
Après ont créé tous les objets de la grammaire, ils sont passés à la reconnaissance vocale et la reconnaissance vocale est activée :
sre.LoadGrammarAsync(g_StartStop);
sre.LoadGrammarAsync(g_WhatIsXplusY);
sre.RecognizeAsync(RecognizeMode.Multiple);
L'argument RecognizeMode.Multiple est requis lorsque vous avez plus d'une grammaire, qui sera le cas dans l'ensemble mais les programmes plus simples. Les finitions de méthode Main comme suit :
...
while (done == false) { ; }
Console.WriteLine("\nHit <enter> to close shell\n");
Console.ReadLine();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.ReadLine();
}
} // Main
La curieuse apparence vide boucle while permet à la console shell demande rester en vie. La boucle ne se terminera lorsque la variable booléenne-portée de la classe « fait » est définie sur true par le gestionnaire d'événements de module de reconnaissance vocale.
Le code du gestionnaire d'événements reconnus discours commence comme ceci :
static void sre_SpeechRecognized(object sender,
SpeechRecognizedEventArgs e)
{
string txt = e.Result.Text;
float confidence = e.Result.Confidence;
Console.WriteLine("\nRecognized: " + txt);
if (confidence < 0.60) return;
...
Le texte reconnu est stocké dans le SpeechRecognizedEventArgs Result.Text propriété. Vous pouvez également utiliser la collection Result.Words. La propriété Result.Confidence conserve une valeur comprise entre 0,0 et 1,0 qui est une mesure approximative de quelle est la probabilité le texte parlé correspond à toutes les grammaires associées avec le module de reconnaissance. La démo indique au gestionnaire d'événements d'ignorer tout texte faible-confiance-reconnu.
Les valeurs de confiance peuvent varier énormément selon la complexité de vos grammaires, la qualité de votre microphone et ainsi de suite. Par exemple, si le programme de démonstration doit reconnaître seulement 1 à 4, les valeurs de confiance sur ma machine sont généralement environ 0,75. Cependant, si la grammaire doit reconnaître 1 à 100, les valeurs de confiance chute à environ 0,25. En bref, vous devez généralement expérimenter avec des valeurs de confiance pour obtenir des résultats de bonne reconnaissance vocale.
Ensuite, le gestionnaire d'événements de système de reconnaissance vocale active/désactive la reconnaissance sur et en dehors :
if (txt.IndexOf("speech on") >= 0)
{
Console.WriteLine("Speech is now ON");
speechOn = true;
}
if (txt.IndexOf("speech off") >= 0)
{
Console.WriteLine("Speech is now OFF");
speechOn = false;
}
if (speechOn == false) return;
Bien que peut-être pas tout à fait évident dans un premier temps, la logique devrait faire sens si vous examinez pour un moment. Ensuite, la commande de sortie secrète est traitée :
if (txt.IndexOf("klatu") >= 0 && txt.IndexOf("barada") >= 0)
{
((SpeechRecognitionEngine)sender).RecognizeAsyncCancel();
done = true;
Console.WriteLine("(Speaking: Farewell)");
ss.Speak("Farewell");
}
Notez que le moteur de reconnaissance vocale peut reconnaître en fait les mots de non-sens. Si un objet grammaire contient des mots qui ne sont pas dans le dictionnaire intégré de l'objet, la grammaire tente d'identifier les mots autant que possible en utilisant des heuristiques sémantique et est habituellement assez bien réussie. C'est pourquoi j'ai utilisé « klatu » plutôt que de la bonne « klaatu"(d'un vieux film de science fiction).
Notez également que vous n'avez pas à traiter le texte entier de la grammaire reconnu ("klatu barada nikto"), vous devez seulement avoir suffisamment d'informations pour identifier de manière unique une phrase de grammaire (« klatu » et « barada »).
Ensuite, pour additionner deux nombres, les commandes sont traitées et finir du gestionnaire d'événements, la classe Program et l'espace de noms :
...
if (txt.IndexOf("What") >= 0 && txt.IndexOf("plus") >= 0)
{
string[] words = txt.Split(' ');
int num1 = int.Parse(words[2]);
int num2 = int.Parse(words[4]);
int sum = num1 + num2;
Console.WriteLine("(Speaking: " + words[2] +
" plus " + words[4] + " equals " + sum + ")");
ss.SpeakAsync(words[2] + " plus " + words[4] +
" equals " + sum);
}
} // sre_SpeechRecognized
} // Program
} // ns
Notez que le texte dans Results.Text est sensible à la casse (« Quoi » vs. « quoi »). Une fois que vous avez reconnu une phrase, vous pouvez analyser les mots spécifiques. Dans ce cas, le texte reconnu a forme, "ce qui est x et y," si le « quoi » est dans les mots [0] et les deux nombres à ajouter (sous forme de chaînes) sont dans les mots [2] et [4].
L'explication du programme démo suppose que vous avez toutes les bibliothèques nécessaire discours installés sur votre machine. Pour créer et exécuter les programmes de démonstration, vous devez installer quatre paquets : un SDK pour pouvoir créer des démos en Visual Studio, un runtime pour pouvoir exécuter les démos après que qu'ils ont été créé, une langue de reconnaissance et une langue (langue) de synthèse.
Pour installer le SDK, faites une recherche d'Internet pour "plateforme de reconnaissance vocale 11 SDK." Ceci vous amènera vers la bonne page Microsoft Download Center, comme le montre Figure 4. Après avoir cliqué sur le bouton de téléchargement, vous verrez les options affichées dans Figure 5. Le SDK est disponible en versions 32 bits et 64 bits. Je recommande vivement à l'aide de la version 32-bit indépendamment de ce qui est votre machine hôte. La version 64 bits n'est pas interagir avec certaines applications.
.png "Page la principale Installation de SDK-au centre de téléchargement Microsoft")
Figure 4 Page la principale Installation de SDK-au centre de téléchargement Microsoft
.png "installation le Speech SDK")
Figure 5 installation le Speech SDK
Vous n'avez pas besoin de rien, sauf le single x 86 (32 bits) fichier.msi. Après avoir sélectionné ce fichier et en cliquant sur le bouton suivant, vous pouvez exécuter le programme d'installation directement. Les bibliothèques de discours ne vous donnent pas beaucoup vos commentaires sur quand l'installation est terminée, alors ne cherchez pas une sorte de message de réussite.
Ensuite, vous voulez installer le runtime de discours. Après avoir trouver la page d'accueil et en cliquant sur le bouton suivant, vous verrez les options affichées dans Figure 6.
.png "installer le Runtime de discours")
Figure 6 installer le Runtime de discours
Il est essentiel que vous choisissez la même version de la plate-forme (11 dans la démo) et la version de bits (32 [x 86] ou 64 [x64]) as le SDK. Encore une fois, je recommande fortement la version 32 bits, même si vous travaillez sur un ordinateur 64 bits.
Ensuite, vous pouvez installer la langue de reconnaissance. La page de téléchargement s'affiche dans Figure 7. Le fichier de démonstration utilisé MSSpeech_SR_en-us_TELE.msi (Anglais-États-Unis). Le SR est synonyme de reconnaissance vocale et la télé est synonyme de téléphonie, ce qui signifie que la langue de reconnaissance est conçue pour fonctionner avec entrée, telle que celle d'un téléphone ou microphone de bureau de faible qualité audio.
.png "installation de la langue de reconnaissance")
Figure 7 installation de la langue de reconnaissance
Enfin, vous pouvez installer le langage de synthèse vocale et la voix. La page de téléchargement s'affiche dans Figure 8. La démonstration utilise le fichier MSSpeech_TTS_en-us_Helen.msi. Le TTS est synonyme de synthèse vocale, qui est essentiellement une expression synonyme pour la synthèse vocale. Avis il sont deux anglais, États-Unis voix disponibles. Il y a autres anglais, non-u sa voix, trop. Il est assez difficile de créer des fichiers de synthèse. Il est possible d'acheter et puis installez les autres voix d'une poignée d'entreprises.
.png "installer le langage de synthèse et de la voix")
La figure 8, installer le langage de synthèse et de la voix
Fait intéressant, même si une langue de reconnaissance vocale et une synthèse vocale/orthophonie sont vraiment deux choses totalement différentes, les téléchargements sont des options sur une page de téléchargement unique. L'interface utilisateur du centre de téléchargement vous permet de vérifier une langue de reconnaissance et une langue de synthèse, mais essayer de les installer en même temps fut désastreuse pour moi, donc je vous recommande les installer un à la fois.
Si vous débutez en reconnaissance vocale et de synthèse pour les applications Windows, vous pouvez facilement se confondre par la documentation car il existe plusieurs plates-formes de discours. En particulier, en plus de la bibliothèque de Microsoft.Speech.dll utilisée par les démos dans cet article, il y a une bibliothèque System.Speech.dll qui fait partie du système d'exploitation Windows. Les deux bibliothèques sont semblables en ce sens que les API sont presque, mais pas tout à fait, la même chose. Donc, si vous recherchez en ligne des exemples de discours et vous voyez un extrait de code, et non un programme complet, il n'est pas toujours évident si l'exemple fait référence à System.Speech ou Microsoft.Speech.
Bout de ligne, si vous êtes débutant avec la parole, pour l'ajout de discours à une application .NET, utilisez la bibliothèque de Microsoft.Speech, pas la bibliothèque de System.Speech.
Bien que les deux bibliothèques partagent le même code de base de base et ont API similaires, ils sont certainement différents. Certaines des principales différences sont résumées dans le tableau de Figure 9.
Figure 9 Microsoft.Speech vs System.Speech
| Microsoft.Speech.dll | System.Speech.dll |
| Devez installer séparément | Partie du système d'exploitation (Windows Vista+) |
| Pouvez empaqueter avec apps | Ne pouvez pas redistribuer |
| Construisez des grammaires | Utilise des grammaires ou dictée gratuite |
| Aucune formation de l'utilisateur | Formation pour utilisateur spécifique |
| Code managé API (c#) | Code natif API (C++) |
La DLL de System.Speech fait partie du système d'exploitation, donc il est installé sur toutes les machines Windows. La DLL Microsoft.Speech (et un runtime associé et langues) doivent être téléchargés puis installés sur une machine. System.Speech reconnaissance nécessite généralement la formation des utilisateurs, où l'utilisateur lit un texte et le système apprend à comprendre la prononciation de cet utilisateur particulier. Microsoft.Speech reconnaissance fonctionne immédiatement pour n'importe quel utilisateur. System.Speech peut reconnaître pratiquement n'importe quel mot (appelé dictée gratuite). Microsoft.Speech reconnaîtra uniquement des mots et des phrases qui se trouvent dans une grammaire définie par programme.
Le processus d'ajout de la reconnaissance vocale et la synthèse d'une application Windows Forms ou WPF est similaire à celle de l'ajout de discours à une application de console. Pour créer le programme de démonstration factice montré Figure 2, j'ai lancé Visual Studio et créé une nouvelle application Windows Forms c# et baptisa WinFormSpeech.
Une fois le code du modèle chargé dans l'éditeur de Visual Studio , dans la fenêtre de l'Explorateur de solutions, j'ai ajouté une référence au fichier Microsoft.Speech.dll, tout comme je l'ai fait avec la démo d'application console. En haut du code source, j'ai supprimé inutiles à l'aide de déclarations, laissant quelques références aux espaces de noms System, de données, de dessin et de formes. J'ai ajouté deux instructions using pour intégrer les espaces de noms Microsoft.Speech.Recognition et System.Globalization portée.
La démo de Windows Forms n'utilise pas la synthèse vocale, donc je n'utilise pas une référence à la bibliothèque de Microsoft.Speech.Synthesis. Ajout de la synthèse vocale à un Windows Forms app est exactement comme l'ajout de synthèse à une application de console.
En mode design Visual Studio , j'ai fait glisser un contrôle TextBox, un contrôle CheckBox et un contrôle ListBox vers le formulaire. J'ai double-cliqué sur le contrôle CheckBox et Visual Studio a automatiquement créé un squelette de la méthode de gestionnaire d'événements CheckChanged.
Rappelons que la démo de app console a commencé immédiatement à l'écoute des commandes vocales et écouté en permanence jusqu'à ce que vous quittez l'application. Cette approche peut être utilisée pour une application Windows Forms, mais au lieu de cela, j'ai décidé de permettre à l'utilisateur d'activer et désactiver la reconnaissance vocale en utilisant le contrôle CheckBox.
Le code source pour le fichier Form1.cs du programme de la démo, qui définit une classe partielle, est présenté en Figure 10. Un objet de moteur de reconnaissance vocale est déclaré et instancié en tant que membre de la forme. À l'intérieur du constructeur du formulaire, j'ai raccorder le gestionnaire d'événements SpeechRecognized et créer et charger deux grammaires :
public Form1()
{
InitializeComponent();
sre.SetInputToDefaultAudioDevice();
sre.SpeechRecognized += sre_SpeechRecognized;
Grammar g_HelloGoodbye = GetHelloGoodbyeGrammar();
Grammar g_SetTextBox = GetTextBox1TextGrammar();
sre.LoadGrammarAsync(g_HelloGoodbye);
sre.LoadGrammarAsync(g_SetTextBox);
// sre.RecognizeAsync() is in CheckBox event
}
Forme de la figure 10 ajout de la reconnaissance vocale à un Windows
using System;
using System.Data;
using System.Drawing;
using System.Windows.Forms;
using Microsoft.Speech.Recognition;
using System.Globalization;
namespace WinFormSpeech
{
public partial class Form1 : Form
{
static CultureInfo ci = new CultureInfo("en-us");
static SpeechRecognitionEngine sre =
new SpeechRecognitionEngine(ci);
public Form1()
{
InitializeComponent();
sre.SetInputToDefaultAudioDevice();
sre.SpeechRecognized += sre_SpeechRecognized;
Grammar g_HelloGoodbye = GetHelloGoodbyeGrammar();
Grammar g_SetTextBox = GetTextBox1TextGrammar();
sre.LoadGrammarAsync(g_HelloGoodbye);
sre.LoadGrammarAsync(g_SetTextBox);
// sre.RecognizeAsync() is in CheckBox event
}
static Grammar GetHelloGoodbyeGrammar()
{
Choices ch_HelloGoodbye = new Choices();
ch_HelloGoodbye.Add("hello");
ch_HelloGoodbye.Add("goodbye");
GrammarBuilder gb_result =
new GrammarBuilder(ch_HelloGoodbye);
Grammar g_result = new Grammar(gb_result);
return g_result;
}
static Grammar GetTextBox1TextGrammar()
{
Choices ch_Colors = new Choices();
ch_Colors.Add(new string[] { "red", "white", "blue" });
GrammarBuilder gb_result = new GrammarBuilder();
gb_result.Append("set text box 1");
gb_result.Append(ch_Colors);
Grammar g_result = new Grammar(gb_result);
return g_result;
}
private void checkBox1_CheckedChanged(object sender,
EventArgs e)
{
if (checkBox1.Checked == true)
sre.RecognizeAsync(RecognizeMode.Multiple);
else if (checkBox1.Checked == false) // Turn off
sre.RecognizeAsyncCancel();
}
void sre_SpeechRecognized(object sender,
SpeechRecognizedEventArgs e)
{
string txt = e.Result.Text;
float conf = e.Result.Confidence;
if (conf < 0.65) return;
this.Invoke(new MethodInvoker(() =>
{ listBox1.Items.Add("I heard you say: "
+ txt); })); // WinForm specific
if (txt.IndexOf("text") >= 0 && txt.IndexOf("box") >=
0 && txt.IndexOf("1")>= 0)
{
string[] words = txt.Split(' ');
this.Invoke(new MethodInvoker(() =>
{ textBox1.Text = words[4]; })); // WinForm specific
}
}
} // Form
} // ns
Je pourrais avoir créé les deux objets de grammaire directement comme je le faisais dans la console application démo, mais plutôt de garder les choses un peu plus propre, j'ai défini deux méthodes d'assistance, GetHelloGoodbyeGrammar et GetTextBox1TextGrammar, pour faire ce travail.
Notez que le constructeur de formulaire n'appelle pas la méthode RecognizeAsync, ce qui signifie que la reconnaissance vocale ne sera immédiatement active lorsque l'application est lancée.
Méthode d'assistance que gethellogoodbyegrammar suit le même modèle que décrit précédemment dans cet article :
static Grammar GetHelloGoodbyeGrammar()
{
Choices ch_HelloGoodbye = new Choices();
ch_HelloGoodbye.Add("hello"); // Should be an array!
ch_HelloGoodbye.Add("goodbye");
GrammarBuilder gb_result =
new GrammarBuilder(ch_HelloGoodbye);
Grammar g_result = new Grammar(gb_result);
return g_result;
}
De même, la méthode d'assistance qui crée un objet de grammaire pour définir le texte dans le contrôle Windows Forms TextBox ne présente pas de surprises :
static Grammar GetTextBox1TextGrammar()
{
Choices ch_Colors = new Choices();
ch_Colors.Add(new string[] { "red", "white", "blue" });
GrammarBuilder gb_result = new GrammarBuilder();
gb_result.Append("set text box 1");
gb_result.Append(ch_Colors);
Grammar g_result = new Grammar(gb_result);
return g_result;
}
Le helper va reconnaître l'expression, « set rouge 1 boîte de texte. » Toutefois, l'utilisateur ne doit pas parler de cette phrase exactement. Par exemple, un utilisateur peut dire, "S'il vous plaît définir le texte dans la case de texte 1 au rouge", et le moteur de reconnaissance vocale reconnaîtrait encore l'expression « texte boîte 1 rouge, » mais avec une valeur inférieure de la confiance que si l'utilisateur avait comparé le patron de grammaire exactement. Autrement dit, lorsque vous créiez des grammaires, vous n'avez pas à prendre en compte toutes les variations d'une phrase. Cela simplifie considérablement l'utilisation de la reconnaissance vocale.
La case à cocher Gestionnaire d'événements est défini comme suit :
private void checkBox1_CheckedChanged(object sender, EventArgs e)
{
if (checkBox1.Checked == true)
sre.RecognizeAsync(RecognizeMode.Multiple);
else if (checkBox1.Checked == false) // Turn off
sre.RecognizeAsyncCancel();
}
L'objet de moteur de reconnaissance vocale, sre, reste toujours en existence pendant la durée de vie de l'application Windows Forms. L'objet est activé et désactivé à l'aide de méthodes RecognizeAsync et RecognizeAsyncannuler lorsque l'utilisateur active ou désactive le contrôle CheckBox.
La définition du gestionnaire d'événements reconnus discours commence par :
void sre_SpeechRecognized(object sender, SpeechRecognizedEventArgs e)
{
string txt = e.Result.Text;
float conf = e.Result.Confidence;
if (conf < 0.65) return;
...
Outre les propriétés Result.Text et Result.Confidence plus ou moins toujours utilisé, l'objet de résultat a plusieurs autres utiles, mais plus avancé, les propriétés que vous pourriez souhaiter examiner, telles que les Homophones et ReplacementWordUnits. En outre, le moteur de reconnaissance vocale a plusieurs événements utiles tel SpeechHypothesized.
Le code du gestionnaire d'événement se termine par :
...
this.Invoke(new MethodInvoker(() =>
{ listBox1.Items.Add("I heard you say: " + txt); }));
if (txt.IndexOf("text") >= 0 &&
txt.IndexOf("box") >= 0 && txt.IndexOf("1")>= 0)
{
string[] words = txt.Split(' ');
this.Invoke(new MethodInvoker(() =>
{ textBox1.Text = words[4]; }));
}
}
Le texte reconnu est repris dans le contrôle ListBox à l'aide du délégué MethodInvoker. Parce que le système de reconnaissance vocale s'exécute dans un thread différent du thread d'interface utilisateur de Windows Forms, un direct tentent d'accéder le contrôle ListBox, tels que :
listBox1.Items.Add("I heard you say: " + txt);
échoue et lève une exception. Une alternative à la méthodeInvoker est d'utiliser le délégué Action comme ceci :
this.Invoke( (Action)( () =>
listBox1.Items.Add("I heard you say: " + txt)));
En théorie, dans ce cas, l'utilisation du délégué MethodInvoker est légèrement plus efficace que l'utilisation du délégué Action car MethodInvoker fait partie de l'espace de noms Windows.Forms et, par conséquent, spécifiques aux applications Windows Forms. Le délégué de l'Action est plus général. Cet exemple montre que vous pouvez manipuler complètement une application Windows Forms à l'aide de la reconnaissance vocale — incroyablement puissant et utile.
Les informations présentées dans cet article devraient obtenir vous place et en cours d'exécution si vous souhaitez explorer la reconnaissance vocale et la synthèse vocale avec les applications .NET. Maîtrise de la technologie elle-même n'est pas trop difficile une fois que vous obtenez au cours de l'installation initiale et d'apprentissage des haies. Le vrai problème avec la reconnaissance vocale et la synthèse est de déterminer quand ils sont utiles.
Avec les applications de console, vous pouvez créer intéressants arrière-et-vient des boîtes de dialogue lorsque l'utilisateur demande une question et les réponses de l'application, résultant dans un environnement de type Cortana. Il faut être un peu prudent parce que quand votre ordinateur parle, que le discours va être capté par le microphone et peut être reconnu. Je me suis trouvé dans certaines situations amusantes où poser une question, l'application reconnaît et réponses, mais la réponse parlée déclenche un autre événement de reconnaissance, et je me retrouve dans une boucle infinie discours divertissant.
Une autre utilisation possible de la parole avec une application console est de reconnaître des commandes telles que, « Lancer le bloc-notes » et "Mot de lancement". En d'autres termes, une application de console permet d'effectuer des actions sur votre machine hôte qui serait normalement effectuée à l'aide de multiples interactions souris et clavier.
Dr. James McCaffrey travaille pour Microsoft Research à Redmond, Washington Il a travaillé sur plusieurs produits Microsoft, y compris Internet Explorer et Bing. Dr. McCaffrey est joignable au jammc@microsoft.com.
Remercie les experts techniques Microsoft Research suivants d'avoir relu cet article : Rob Gruen, Mark Marron et Curtis von Veh