Il presente articolo è stato tradotto automaticamente.
Riconoscimento vocale
Riconoscimento vocale con app desktop .NET
Scaricare il codice di esempio
Con l'introduzione di Windows Phone Cortana, l'assistente personale attivati dal discorso (così come il simile she-who-must-not-be-named della ditta di frutta), applicazioni abilitate discorso hanno preso un posto sempre più importante nello sviluppo di software. In questo articolo, vi mostrerò come iniziare con riconoscimento vocale e sintesi vocale in Windows applicazioni console, applicazioni Windows Form e applicazioni Windows Presentation Foundation (WPF).
Si noti che è inoltre possibile aggiungere capacità vocale per Windows Phone apps, ASP.NET Web apps, applicazioni Windows Store, applicazioni Windows RT e Xbox Kinect, ma le tecniche per farlo sono diverse da quelle presentate in questo articolo.
Un buon modo per vedere che cosa questo articolo spiega è quello di dare un'occhiata agli screenshot di due programmi diversi demo in Figura 1 e Figura 2. Dopo l'applicazione console in Figura 1 è stato lanciato, l'app immediatamente ha parlato la frase "Io sono sveglio." Naturalmente, non si sente la demo durante la lettura di questo articolo, così il programma demo Visualizza il testo di ciò che dice il computer. Successivamente, l'utente ha parlato il comando "Discorso su". La demo ha fatto eco il testo che è stato riconosciuto, e poi, dietro le quinte, attivato l'applicazione ascoltare e rispondere alle richieste di aggiungere due numeri.
.png "riconoscimento vocale e sintesi in un'applicazione Console")
Figura 1 riconoscimento vocale e sintesi in un'applicazione Console
.png "riconoscimento vocale in un Windows forma applicazione")
Figura 2 riconoscimento vocale in un Windows forma applicazione
L'utente ha chiesto l'applicazione per aggiungere uno più due, quindi due più tre. L'applicazione ha riconosciuto questi comandi vocali e ha dato le risposte ad alta voce. Descriverò i modi più utili per utilizzare il riconoscimento vocale più tardi.
L'utente poi emesso il comando "Discorso off," che è disattivata in attesa di comandi per aggiungere numeri, ma completamente non disattivare il riconoscimento vocale. Con discorso fuori, il prossimo comando vocale per aggiungere uno più due è stato ignorato. Infine, l'utente acceso discorso indietro e ha parlato il comando di sciocchezze, "Klatu barada nikto," che l'applicazione è riconosciuto come il comando completamente disattivare il riconoscimento vocale e uscire dall'applicazione.
Figura 2 illustra un'applicazione Windows Form discorso fittizia. L'applicazione riconosce i comandi vocali, ma non risponde con uscita vocale. Quando l'applicazione è stata lanciata, non era verificato il discorso sul controllo checkbox, indicanti riconoscimento vocale non era attivo. L'utente controllato il discorso sul controllo e quindi ha parlato, "Ciao". L'applicazione ha fatto eco il testo riconosciuto parlato nel controllo ListBox nella parte inferiore dell'applicazione.
L'utente poi ha detto, "Impostato 1 casella testo rosso." L'applicazione ha riconosciuto, "testo Set box 1 rosso," che è quasi — ma non abbastanza — esattamente ciò che l'utente ha parlato. Sebbene non visibile in Figura 2, il testo nel controllo TextBox nella parte superiore dell'applicazione è stato infatti impostato su "red".
Avanti, ha parlato dell'utente, "Impostare 1 casella di testo al bianco". L'applicazione ha riconosciuto "set 1 casella di testo bianca" e ha fatto proprio questo. L'utente ha concluso parlando, "Addio", e l'applicazione ha fatto eco il comando, ma non manipolare la Windows Form, anche se potrebbe avere, ad esempio, deselezionando il discorso sul controllo checkbox.
Nelle sezioni che seguono, si prenderanno attraverso il processo di creazione di entrambi i programmi demo, tra cui l'installazione delle librerie di discorso .NET richieste. Questo articolo presuppone che hai almeno intermedio competenze di programmazione, ma non si assume che nulla si sa di riconoscimento vocale o sintesi vocale.
L'aggiunta di discorso per un'applicazione Console
Per creare la demo mostrata Figura 1, ho lanciato Visual Studio e creato una nuova applicazione console c# denominata ConsoleSpeech. Ho usato con successo discorso con Visual Studio 2010 e 2012, ma qualsiasi versione recente dovrebbe funzionare. Dopo il codice del modello caricato nell'editor, nella finestra Solution Explorer ho rinominato il file Program.cs per il ConsoleSpeechProgram.cs più descrittivo e quindi Visual Studio ribattezzata classe programma per me.
Successivamente, aggiunto un riferimento al file Microsoft.Speech.dll, che era situato a \Microsoft SDKs\Speech\v11.0\Assembly C:\ProgramFiles (x86). Questa DLL non era sulla mia macchina host e doveva essere scaricato. L'installazione dei file necessari per aggiungere il riconoscimento vocale e sintesi di un'applicazione non è interamente banale. Io spiegare il processo di installazione in dettaglio nella sezione successiva di questo articolo, ma per ora, si supponga che Microsoft.Speech.dll presente sulla vostra macchina.
Dopo aver aggiunto il riferimento al discorso DLL, all'inizio del codice sorgente ho cancellato tutte le istruzioni using tranne quella che indica il primo livello dello spazio dei nomi System. Poi, aggiunto utilizzando le istruzioni agli spazi dei nomi Microsoft.Speech.Recognition, Microsoft.Speech.Synthesis e System. Globalization. I primi due spazi dei nomi sono associati con il discorso DLL. Nota: Un po' confusamente, ci sono anche gli spazi dei nomi System.Speech.Recognition e System.Speech.Synthesis. Mi spiego subito la differenza. Lo spazio dei nomi di globalizzazione era disponibile per impostazione predefinita e non richiede l'aggiunta di un nuovo riferimento al progetto.
L'intero codice sorgente per la demo di applicazione console è mostrato Figura 3 ed è anche disponibile nel download del codice che accompagna questo articolo. Rimosso tutti i normali controllo degli errori per mantenere le idee più chiaro possibile.
Codice sorgente dell'applicazione Console di figura 3 Demo
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
Dopo l'utilizzo di istruzioni, il codice demo comincia come così:
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'oggetto di ambito di classe SpeechSynthesizer fornisce all'applicazione la capacità di parlare. L'oggetto SpeechRecognitionEngine consente all'applicazione di ascoltare e riconoscere parole o frasi. La variabile booleana "fatta" determina quando è finito l'intera applicazione. SpeechOn variabile booleana controlla se l'applicazione è in ascolto per eventuali comandi diversi da un comando per uscire dal programma.
L'idea qui è che l'applicazione di console non accetta input digitato da tastiera, quindi l'applicazione è sempre in ascolto per i comandi. Tuttavia, se speechOn è false, solo il comando per uscire dal programma sarà riconosciuto e ha agito; altri comandi saranno riconosciuti ma ignorati.
Inizia il metodo Main:
try
{
ss.SetOutputToDefaultAudioDevice();
Console.WriteLine("\n(Speaking: I am awake)");
ss.Speak("I am awake");
L'oggetto SpeechSynthesizer è stato istanziato quando fu dichiarata. Utilizzando un oggetto sintetizzatore è abbastanza semplice. Il SetOutputToDefaultAudioDevice metodo invia l'output agli altoparlanti della vostra macchina (uscita può anche essere inviato in un file). Il metodo Speak accetta una stringa e poi, Beh, parla. È facile!
Riconoscimento vocale è molto più difficile di sintesi vocale. Il metodo Main continua creando l'oggetto recognizer:
CultureInfo ci = new CultureInfo("en-us");
sre = new SpeechRecognitionEngine(ci);
sre.SetInputToDefaultAudioDevice();
sre.SpeechRecognized += sre_SpeechRecognized;
In primo luogo, la lingua di riconoscere è specificato, gli Stati Uniti inglese in questo caso, in un oggetto CultureInfo. Si trova l'oggetto CultureInfo dello spazio dei nomi di globalizzazione che è stato fatto riferimento con l'utilizzo di un'istruzione. Successivamente, dopo aver chiamato il Costruttore SpeechRecognitionEngine, input vocale viene impostato il dispositivo audio predefinito, un microfono nella maggior parte delle situazioni. Si noti che la maggior parte dei portatili hanno un microfono integrato, ma la maggior parte delle macchine desktop avrà bisogno di un microfono esterno (spesso combinato con un auricolare in questi giorni).
Il metodo chiave per l'oggetto recognizer è il gestore di eventi SpeechRecognized. Quando si utilizza Visual Studio, se si digita "sre.Discorsoriconosciuto + = "e attendere solo una frazione di secondo, l' IntelliSense dispongono volontà completamento automatico la dichiarazione con"sre_SpeechRecognized"per il nome del gestore eventi. Consigliamo di colpire il tasto tab per accettare e utilizzare tale nome predefinito.
Successivamente, la demo imposta la capacità di riconoscere i comandi per aggiungere due numeri:
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);
I tre oggetti chiavi qui sono un insieme di scelte, un modello GrammarBuilder e il controllo grammaticale. Quando sto progettando riconoscimento grammatica, iniziare elencando alcuni esempi specifici di quello che voglio riconoscere. Ad esempio, "che cosa è uno più due?" e, "ciò che è di tre più quattro?"
Quindi, determinare il modello generale corrispondente, ad esempio, "che cosa è < x > Plus < y >?" Il modello è un GrammarBuilder e i valori specifici che vanno nel modello sono le scelte. L'oggetto di grammatica incapsula il modello e scelte.
Nella demo, limitare i numeri di aggiungere da 1 a 4 e aggiungerli come stringhe per la collezione di scelte. Un approccio migliore è:
string[] numbers = new string[] { "1", "2", "3", "4" };
Choices ch_Numbers = new Choices(numbers);
Vi presento l'approccio più debole per creare un insieme di scelte per due motivi. In primo luogo, aggiungendo una stringa a un tempo era l'unico approccio visto in altri esempi di discorso. In secondo luogo, si potrebbe pensare che l'aggiunta di una stringa in un momento non dovrebbe anche lavorare; il tempo reale di Visual Studio IntelliSense dimostra che uno degli overload Add accetta un parametro di tipo "params string [] frasi". Se non notate la parola chiave params si potrebbe pensare che il metodo Add accetta solo una matrice di stringhe, anziché un array di tipo string o una singola stringa. Mi raccomando passando un array.
Creazione di un insieme di scelte di numeri consecutivi è un po' un caso speciale e permette un approccio programmatico come questo:
string[] numbers = new string[100];
for (int i = 0; i < 100; ++i)
numbers[i] = i.ToString();
Choices ch_Numbers = new Choices(numbers);
Dopo aver creato le scelte per riempire gli slot del GrammarBuilder, la demo crea il GrammarBuilder e quindi il controllo grammaticale, in questo modo:
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 demo utilizza un modello simile per creare una grammatica per i comandi di start e stop-relativi:
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);
Hai un sacco di flessibilità nella definizione di grammatiche. Qui, i comandi "discorso," "discorso fuori" e "klatu barada nikto" sono tutti collocati nella stessa grammatica, perché essi stanno logicamente correlati. I tre comandi potrebbero aver definiti in tre distinte grammatiche, o si può mettere il "discorso su" e "discorso fuori" comandi in una grammatica e il comando "klatu barada nikto" in una seconda grammatica.
Dopo aver creati tutti gli oggetti di grammatica, passavano per il riconoscimento vocale e riconoscimento vocale è attivato:
sre.LoadGrammarAsync(g_StartStop);
sre.LoadGrammarAsync(g_WhatIsXplusY);
sre.RecognizeAsync(RecognizeMode.Multiple);
L'argomento RecognizeMode.Multiple è necessario quando si hanno più di una grammatica, che avviene in tutti, ma i programmi più semplici. Le finiture del metodo Main in questo modo:
...
while (done == false) { ; }
Console.WriteLine("\nHit <enter> to close shell\n");
Console.ReadLine();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.ReadLine();
}
} // Main
La vuota dall'aspetto curioso ciclo while consente alla console di shell applicazione per rimanere in vita. Il ciclo terminerà quando la variabile booleana-nell'ambito della classe "fatto" è impostata su true per il gestore di eventi del sistema di riconoscimento vocale.
Movimentazione riconosciuto discorso
Il codice per il gestore eventi riconosciuti discorso inizia come questo:
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;
...
Il testo riconosciuto viene archiviato nel SpeechRecognizedproprietà EventArgs Result.Text. È anche possibile utilizzare la raccolta Result.Words. La proprietà Result.Confidence contiene un valore compreso tra 0.0 e 1.0 che è una misura approssimativa di quante probabilità il testo parlato corrisponde a qualsiasi delle grammatiche connesse con il sistema di riconoscimento. La demo incarica il gestore eventi di ignorare qualsiasi testo basso-fiducia-riconosciuto.
Valori di fiducia possono variare selvaggiamente a seconda della complessità del tuoi grammatiche, la qualità del microfono e così via. Ad esempio, se il programma demo deve riconoscere solo 1 a 4, i valori di fiducia sulla mia macchina sono in genere circa 0,75. Tuttavia, se la grammatica deve riconoscere da 1 a 100, i valori di fiducia cadere a circa 0,25. In breve, in genere deve sperimentare con valori di fiducia per ottenere risultati di riconoscimento vocale buona.
Successivamente, il gestore di eventi del sistema di riconoscimento vocale attiva o disattiva riconoscimento on e off:
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;
Anche se forse non del tutto evidente in un primo momento, la logica dovrebbe senso se si esamina un attimo. Successivamente, il comando di uscita segreta è elaborato:
if (txt.IndexOf("klatu") >= 0 && txt.IndexOf("barada") >= 0)
{
((SpeechRecognitionEngine)sender).RecognizeAsyncCancel();
done = true;
Console.WriteLine("(Speaking: Farewell)");
ss.Speak("Farewell");
}
Si noti che il modulo di riconoscimento vocale può infatti riconoscere parole senza senso. Se un oggetto grammatica contiene parole che non sono nel dizionario incorporato dell'oggetto, la grammatica tenta di identificare tali parole come meglio può utilizzando euristica semantico e solitamente è abbastanza successo. Questo è il motivo per cui ho usato "klatu" piuttosto che il corretto "klaatu" (da un vecchio film di fantascienza).
Si noti inoltre che non è necessario elaborare l'intero testo di grammatica Riconosciuto ("klatu barada nikto"), devi solo avere informazioni sufficienti per identificare in modo univoco una frase di grammatica ("klatu" e "buffoni").
Successivamente, comandi per aggiungere due numeri sono elaborati e finire il gestore eventi, classe Program e spazio dei nomi:
...
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
Si noti che il testo in Results.Text è case-sensitive ("Cosa" vs. "che cosa"). Una volta che tu hai riconosciuto una frase, è possibile analizzare le parole specifiche. In questo caso, il testo riconosciuto ha forma, "che cosa è x, y, più" così la "cosa" è in parole [0] e i due numeri da aggiungere (come stringhe) sono parole [2] e parole [4].
Installare le librerie
La spiegazione del programma demo si presume che tutte le librerie necessarie discorso installate sulla vostra macchina. Per creare ed eseguire i programmi demo, è necessario installare quattro pacchetti: un SDK per poter creare le demo in Visual Studio, un runtime per poter eseguire la demo dopo aver create, una lingua di riconoscimento e un linguaggio di sintesi (lingua).
Per installare il SDK, fare un Internet ricerca per "discorso piattaforma 11 SDK." Questo ti porterà alla pagina corretta nel Microsoft Download Center, come mostrato Figura 4. Dopo aver cliccato il pulsante Download, vedrai le opzioni come mostrato Figura 5. il SDK è disponibile in versioni a 32-bit e 64-bit. Consiglio vivamente utilizzando la versione a 32-bit indipendentemente da quale sia la tua macchina host. La versione 64 bit non interoperabilità con alcune applicazioni.
.png "SDK installazione principale pagina presso il Microsoft Download Center")
Figura 4 SDK installazione principale pagina presso il Microsoft Download Center
.png "installare il SDK di discorso")
Figura 5 installare il SDK di discorso
Non hai bisogno di nulla, tranne il singolo x 86. msi (32-bit). Dopo aver selezionato il file e cliccando il pulsante avanti, è possibile eseguire direttamente il programma di installazione. Le librerie di discorso non ti danno molto feedback circa una volta completata l'installazione, quindi non cercare una sorta di messaggio di successo.
Avanti, volete installare il runtime di discorso. Dopo trovando la pagina principale e cliccando il pulsante avanti, vedrai le opzioni come mostrato Figura 6.
.png "installazione del Runtime di discorso")
Figura 6 installazione del Runtime di discorso
È fondamentale che è scegliere la stessa versione della piattaforma (11 nella demo) e la versione bit (32 [x86] o 64 [x64]) come il SDK. Ancora una volta, Consiglio vivamente la versione a 32 bit anche se stai lavorando su una macchina a 64-bit.
Successivamente, è possibile installare la lingua di riconoscimento. La pagina di download è mostrata Figura 7. La demo utilizzato file MSSpeech_SR_en-us_TELE.msi (inglese-Stati Uniti). SR sta per riconoscimento vocale e la TELE è sinonimo di telefonia, il che significa che la lingua di riconoscimento è progettata per funzionare con bassa qualità audio di input, come quello di un microfono telefono o desktop.
.png "l'installazione la lingua di riconoscimento")
Figura 7 l'installazione la lingua di riconoscimento
Infine, è possibile installare la lingua di sintesi di discorso e la voce. La pagina di download è mostrata Figura 8. La demo utilizza il file MSSpeech_TTS_en-us_Helen.msi. TTS sta per sintesi vocale, che è essenzialmente un frase di sinonimo per sintesi vocale. Avviso ci sono due inglesi, U.S. voci disponibili. Ci sono altri inglese, non-US voci, troppo. Creazione file di sintesi è abbastanza difficile. È possibile acquistare e installare poi altre voci da una manciata di aziende.
.png "installazione del linguaggio di sintesi e voce")
Figura 8 installazione del linguaggio di sintesi e voce
È interessante notare che, anche se una lingua di riconoscimento vocale e una sintesi vocale linguistico sono davvero due cose completamente diverse, entrambe download sono opzioni da una pagina di download singolo. Download Center UI ti permette di controllare una lingua di riconoscimento e un linguaggio di sintesi, ma cercando di installarli allo stesso tempo è stato disastroso per me, quindi vi consiglio di installarli uno alla volta.
Microsoft.Speech vs. Speech
Se siete nuovi a riconoscimento vocale e sintesi per le applicazioni Windows, può facilmente ottenere confuso dalla documentazione perché ci sono piattaforme multiple di discorso. In particolare, oltre alla Biblioteca Microsoft.Speech.dll utilizzata dalle demo in questo articolo, c'è una libreria System.Speech.dll che fa parte del sistema operativo Windows. Le due librerie sono simili nel senso che le API sono quasi, ma non è la stessa. Quindi, se stai cercando on-line esempi di discorso e si vede un frammento di codice, piuttosto che un programma completo, non è sempre evidente se l'esempio si riferisce a Speech o Microsoft.Speech.
La linea di fondo è, se sei un principiante con il discorso, per l'aggiunta di discorso a un'applicazione .NET, utilizzare la libreria di Microsoft.Speech, non la libreria System. Speech.
Anche se le due librerie condividono alcuni dello stesso codice di base di nucleo e hanno API simili, sono decisamente differenti. Alcune delle principali differenze sono riassunti nella tabella Figura 9.
Figura 9 Microsoft.Speech vs Speech
| Microsoft.Speech.dll | System.Speech.dll |
| Necessario installare separatamente | Parte del sistema operativo (Windows Vista+) |
| Possibile pacchetto con apps | Non è possibile ridistribuire |
| Necessario costruire grammatiche | Utilizza grammatiche o dettatura gratis |
| Nessuna formazione utente | Formazione per utente specifico |
| Codice gestito API (c#) | Codice nativo API (C++) |
DLL System. Speech è parte del sistema operativo, perciò è installato su ogni macchina Windows. La DLL Microsoft.Speech (e un runtime associato e lingue) devono essere scaricati e installati su una macchina. Speech riconoscimento richiede solitamente la formazione degli utenti, dove l'utente legge il testo e il sistema impara a capire la pronuncia di quel particolare utente. Microsoft.Speech riconoscimento funziona immediatamente per qualsiasi utente. Speech può riconoscere qualsiasi parole (chiamate libero dettatura). Microsoft.Speech riconoscerà solo parole e frasi che sono in una grammatica definita dal programma.
Riconoscimento vocale aggiunta a un Windows forma applicazione
Il processo di aggiunta di riconoscimento vocale e sintesi di un'applicazione Windows Form o WPF è simile a quella del discorso l'aggiunta di un'applicazione console. Creare il programma demo fittizio indicato in Figura 2, lanciato Visual Studio e creato una nuova applicazione Windows Form c# e la chiamò WinFormSpeech.
Dopo il codice del modello caricato nell'editor Visual Studio , nella finestra Solution Explorer, aggiunto un riferimento al file Microsoft.Speech.dll, proprio come ho fatto con la demo di applicazione console. All'inizio del codice sorgente, ho eliminato inutili mediante istruzioni, lasciando solo i riferimenti a spazi dei nomi System, dati, disegno e forme. Aggiunto due istruzioni using per portare gli spazi dei nomi Microsoft.Speech.Recognition e System. Globalization nell'ambito.
La demo di Windows Form non usa sintesi vocale, quindi io non uso un riferimento alla libreria Microsoft.Speech.Synthesis. L'aggiunta di sintesi vocale per un Windows Form app è esattamente come l'aggiunta di sintesi di un'applicazione console.
Nella visualizzazione progettazione Visual Studio , ho trascinato un controllo TextBox, un controllo casella di controllo e un controllo ListBox al form. Fatto doppio clic sul controllo CheckBox e Visual Studio creato automaticamente uno scheletro del metodo del gestore eventi CheckChanged.
Ricordiamo che la demo di console app iniziato immediatamente in attesa di comandi vocali e ascoltato continuamente fino a quando l'app uscito. Tale approccio può essere utilizzato per un'applicazione Windows Form, ma invece ho deciso di consentire all'utente di attivare o disattivare il riconoscimento vocale e fuori utilizzando il controllo CheckBox.
Il codice sorgente per file Form1 del programma demo CS, che definisce una classe parziale, è presentato Figura 10. Un oggetto del motore di riconoscimento vocale viene dichiarato e creata un'istanza come un membro della forma. Nel costruttore del Form, associare il gestore eventi SpeechRecognized e creare e caricare due grammatiche:
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
}
Figura 10 aggiunta di riconoscimento vocale per un Windows costituisce
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
Potrei aver creato due oggetti grammatica direttamente come ho fatto nella console applicazione demo, ma, invece, mantenere le cose un po' più pulito, definito due metodi di supporto, GetHelloGoodbyeGrammar e GetTextBox1TextGrammar, per fare quel lavoro.
Si noti che il costruttore del Form non chiama il metodo RecognizeAsync, che significa che riconoscimento vocale non sarà immediatamente attivo quando viene avviata l'applicazione.
Metodo di supporto che gethellogoodbyegrammar segue lo stesso modello come descritto in precedenza in questo articolo:
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;
}
Analogamente, il metodo di supporto che crea un oggetto di grammatica per impostare il testo nel controllo TextBox di Windows Form non presenta sorprese:
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;
}
L'helper sarà riconoscere la frase, "impostare testo casella 1 rosso". Tuttavia, l'utente non deve parlare esattamente questa frase. Ad esempio, un utente potrebbe dire, "Si prega di impostare il testo nella casella di testo 1 rosso" e il modulo di riconoscimento vocale riconoscerebbe ancora la frase come "imposta testo box 1 rosso," anche se con un valore più basso di fiducia che se l'utente aveva abbinato esattamente il modello della grammatica. Mettere un altro modo, quando stai creando grammatiche, non dovete prendere in considerazione tutte le variazioni di una frase. Questo semplifica notevolmente utilizzando riconoscimento vocale.
La casella di controllo gestore eventi definito in questo modo:
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'oggetto engine di riconoscimento vocale, sre, rimane sempre nell'esistenza durante la vita dell'applicazione Windows Form. L'oggetto viene attivato e disattivato con metodi RecognizeAsync e RecognizeAsyncannullare quando l'utente attiva o disattiva il controllo CheckBox.
La definizione del gestore eventi riconosciuti discorso inizia con:
void sre_SpeechRecognized(object sender, SpeechRecognizedEventArgs e)
{
string txt = e.Result.Text;
float conf = e.Result.Confidence;
if (conf < 0.65) return;
...
Oltre alle più o meno sempre usato Result.Text e Result.Confidence proprietà, l'oggetto risultato ha parecchi altri utili, ma più avanzata, si potrebbe voler indagare, come omofoni e ReplacementWordUnits di proprietà. Inoltre, il modulo di riconoscimento vocale ha diversi eventi utili tali SpeechHypothesized.
Il codice del gestore eventi si conclude con:
...
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]; }));
}
}
Nel controllo ListBox utilizzando il delegato MethodInvoker fa eco il testo riconosciuto. Perché il riconoscimento vocale è in esecuzione in un thread diverso dal thread dell'interfaccia utente di Windows Form, una diretta tenta di accedere al controllo ListBox, come ad esempio:
listBox1.Items.Add("I heard you say: " + txt);
avrà esito negativo e genera un'eccezione. Un'alternativa al metodoInvoker è utilizzare il delegato Action come questo:
this.Invoke( (Action)( () =>
listBox1.Items.Add("I heard you say: " + txt)));
In teoria, in questa situazione, utilizzando il delegato MethodInvoker è leggermente più efficiente utilizzando il delegato Action perché MethodInvoker fa parte del namespace Windows. Forms e quindi specifiche per le applicazioni Windows Form. Delegato Action è più generale. In questo esempio viene illustrato completamente può modificare un'applicazione Windows Form utilizzando riconoscimento vocale — incredibilmente potente e utile.
Conclusioni
Le informazioni presentate in questo articolo dovrebbero ottenere fino e in esecuzione se si desidera esplorare il riconoscimento vocale e sintesi vocale con applicazioni .NET. Padroneggiare la tecnologia stessa non è troppo difficile, una volta arrivati sopra l'installazione iniziale e ostacoli di apprendimento. Il vero problema con riconoscimento vocale e sintesi è determinante quando sei utile.
Con applicazioni di console, è possibile creare interessanti avanti e indietro delle finestre di dialogo dove l'utente chiede una domanda e le risposte di applicazione, risultando in un ambiente simile a Cortana. Devi essere un po ' attenti perché quando il computer si parla, che il discorso sarà raccolto dal microfono e può essere riconosciuto. Ho trovato me stesso in alcune situazioni divertenti dove fare una domanda, l'applicazione riconosce e risposte, ma la risposta parlata attiva un altro evento di riconoscimento a finire in un loop infinito discorso divertente.
Un altro possibile utilizzo del discorso con un'applicazione console è di riconoscere i comandi, ad esempio, "Avviare blocco note" e "Parola di lancio". In altre parole, un'applicazione console può essere utilizzata per eseguire azioni sul computer host che sarebbe normalmente eseguito utilizzando interazioni multiple di mouse e tastiera.
Dr. James McCaffrey lavora per la ricerca di Microsoft di Redmond, WA Ha lavorato su diversi prodotti Microsoft, inclusi Internet Explorer e Bing. Dr. McCaffrey può essere raggiunto a jammc@microsoft.com.
Grazie ai seguenti esperti tecnici Microsoft Research per la revisione di questo articolo: Rob Gruen, Mark Marron e Curtis von Veh