Introduzione al riconoscimento vocale

Una delle principali funzionalità del servizio Voce è la possibilità di riconoscere e trascrivere la voce umana, ovvero di convertire la voce in testo scritto. Questa guida di avvio rapido illustra come usare Speech SDK in app e prodotti per eseguire la conversione della voce in testo scritto di alta qualità.

Passare agli esempi su GitHub

Per passare direttamente al codice di esempio, vedere gli esempi di avvio rapido C# in GitHub.

Prerequisiti

Questo articolo presuppone che si abbia un account Azure e una sottoscrizione del servizio Voce. Se l'account e la sottoscrizione non sono disponibili, provare il servizio Voce gratuitamente.

Installare Speech SDK

Se si vuole solo il nome del pacchetto per iniziare, eseguire Install-Package Microsoft.CognitiveServices.Speech nella console NuGet.

Per le istruzioni di installazione specifiche per la piattaforma, vedere i collegamenti seguenti:

Creare una configurazione di Voce

Per chiamare il servizio Voce con Speech SDK, è necessario creare una classe SpeechConfig. Questa classe include informazioni sulla sottoscrizione, ad esempio la chiave e il percorso/area, l'endpoint, l'host o il token di autorizzazione associati. Creare un SpeechConfig oggetto usando la chiave e la località/area geografica. Vedere la pagina Trova chiavi e località/area geografica per trovare la coppia chiave-località/area geografica.

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("<paste-your-speech-key-here>", "<paste-your-speech-location/region-here>");
    }
}

Esistono alcuni altri modi per inizializzare una classe SpeechConfig:

  • Con un endpoint: passare un endpoint del servizio Voce. La chiave e il token di autorizzazione sono facoltativi.
  • Con un host: passare l'indirizzo di un host. La chiave e il token di autorizzazione sono facoltativi.
  • Con un token di autorizzazione: passare un token di autorizzazione e l'area/posizione associata.

Nota

Sia che si esegua il riconoscimento vocale, la sintesi vocale, la traduzione o il riconoscimento finalità, sarà sempre necessario creare una configurazione.

Riconoscimento da microfono

Per eseguire il riconoscimento vocale usando il microfono del dispositivo, creare un oggetto AudioConfig usando FromDefaultMicrophoneInput(). Quindi, inizializzare una classe SpeechRecognizer, passando la classe audioConfig e speechConfig.

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 recognizer = new SpeechRecognizer(speechConfig, audioConfig);

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

    async static Task Main(string[] args)
    {
        var speechConfig = SpeechConfig.FromSubscription("<paste-your-speech-key-here>", "<paste-your-speech-location/region-here>");
        await FromMic(speechConfig);
    }
}

Se si vuole usare un dispositivo di input audio specifico, è necessario specificare l'ID del dispositivo nella classe AudioConfig. Informazioni su come ottenere l'ID del dispositivo di input audio.

Riconoscimento da file

Se si vuole specificare un file audio invece di un microfono per il riconoscimento vocale, è comunque necessario creare un oggetto AudioConfig. Tuttavia, quando si crea AudioConfig, invece di chiamare FromDefaultMicrophoneInput(), si chiamerà FromWavFileInput() e si passerà il percorso file.

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 recognizer = new SpeechRecognizer(speechConfig, audioConfig);

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

    async static Task Main(string[] args)
    {
        var speechConfig = SpeechConfig.FromSubscription("<paste-your-speech-key-here>", "<paste-your-speech-location/region-here>");
        await FromFile(speechConfig);
    }
}

Riconoscimento dal flusso in memoria

Per molti casi d'uso, è probabile che i dati audio provengano dall'archiviazione BLOB o che siano già in memoria come byte[] o una struttura di dati non elaborati simile. L'esempio seguente usa una classe PushAudioInputStream per riconoscere la voce, cioè fondamentalmente un flusso di memoria astratto. Nel codice di esempio vengono eseguite le operazioni seguenti:

  • Scrive i dati audio non elaborati (PCM) nella classe PushAudioInputStream usando la funzione Write(), che accetta un byte[].
  • Legge un file .wav usando un FileReader a scopo dimostrativo, ma se si hanno già dati audio in un byte[], è possibile passare direttamente alla scrittura del contenuto nel flusso di input.
  • Il formato predefinito è 16 bit, 16 KHz e PCM mono. Per personalizzare il formato, è possibile passare un oggetto AudioStreamFormat alla classe CreatePushStream() usando la funzione statica 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 audioInputStream = AudioInputStream.CreatePushStream();
        using var audioConfig = AudioConfig.FromStreamInput(audioInputStream);
        using var recognizer = new SpeechRecognizer(speechConfig, audioConfig);

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

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

    async static Task Main(string[] args)
    {
        var speechConfig = SpeechConfig.FromSubscription("<paste-your-speech-key-here>", "<paste-your-speech-location/region-here>");
        await FromStream(speechConfig);
    }
}

L'uso di un flusso push come input presuppone che i dati audio siano un PCM non elaborato, ad esempio ignorano le intestazioni. L'API continuerà a funzionare in determinati casi se l'intestazione non è stata ignorata, ma per ottenere risultati ottimali è consigliabile implementare la logica per leggere le intestazioni, in modo che il byte[] cominci all'inizio dei dati audio.

Gestione degli errori

Gli esempi precedenti ottengono semplicemente il testo riconosciuto da result.text, ma per gestire gli errori e altre risposte è necessario scrivere del codice per elaborare il risultato. Il seguente codice valuta la proprietà result.Reason e:

  • Stampa il risultato del riconoscimento: ResultReason.RecognizedSpeech
  • Se non esiste una corrispondenza di riconoscimento, informa l'utente: ResultReason.NoMatch
  • Se viene rilevato un errore, stampa il messaggio di errore: ResultReason.Canceled
switch (result.Reason)
{
    case ResultReason.RecognizedSpeech:
        Console.WriteLine($"RECOGNIZED: Text={result.Text}");
        break;
    case ResultReason.NoMatch:
        Console.WriteLine($"NOMATCH: Speech could not be recognized.");
        break;
    case ResultReason.Canceled:
        var cancellation = CancellationDetails.FromResult(result);
        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 update the speech key and location/region info?");
        }
        break;
}

Riconoscimento continuo

Gli esempi precedenti usano il riconoscimento singolo, che riconosce una singola espressione. La fine di una singola espressione viene determinata restando in ascolto del silenzio al termine o finché non vengono elaborati al massimo 15 secondi di audio.

Al contrario, si usa il riconoscimento continuo quando si vuole controllare il momento in cui interrompere il riconoscimento. Per ottenere i risultati del riconoscimento, è necessario sottoscrivere gli eventi Recognizing, Recognized e Canceled. Per arrestare il riconoscimento, è necessario chiamare StopContinuousRecognitionAsync. Ecco un esempio di riconoscimento continuo eseguito su un file di input audio.

Per iniziare, definire l'input e inizializzare un SpeechRecognizer:

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

Quindi, creare una proprietà TaskCompletionSource<int> per gestire lo stato del riconoscimento vocale.

var stopRecognition = new TaskCompletionSource<int>();

Infine, sottoscrivere gli eventi inviati dal SpeechRecognizer.

  • Recognizing: segnale per gli eventi contenenti i risultati del riconoscimento intermedio.
  • Recognized: segnale per gli eventi contenenti i risultati del riconoscimento finale, che indicano un tentativo di riconoscimento riuscito.
  • SessionStopped: segnale per gli eventi che indicano la fine di una sessione di riconoscimento (operazione).
  • Canceled: segnale per gli eventi contenenti risultati di riconoscimento annullati (a indicare un tentativo di riconoscimento annullato in seguito a una richiesta di annullamento diretta o, in alternativa, a un errore di trasporto o di protocollo).
recognizer.Recognizing += (s, e) =>
{
    Console.WriteLine($"RECOGNIZING: Text={e.Result.Text}");
};

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

recognizer.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 update the speech key and location/region info?");
    }

    stopRecognition.TrySetResult(0);
};

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

Al termine della configurazione, chiamare StartContinuousRecognitionAsync per avviare il riconoscimento.

await recognizer.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 recognizer.StopContinuousRecognitionAsync();

Modalità dettatura

Quando si usa il riconoscimento continuo, è possibile abilitare l'elaborazione della dettatura usando la corrispondente funzione. In questa modalità l'istanza di SpeechConfig interpreta le descrizioni testuali delle strutture di frasi, ad esempio la punteggiatura. Ad esempio, l'espressione "Vivi in città punto interrogativo" verrebbe interpretata come "Vivi in città?".

Per abilitare la modalità di dettatura, usare il metodo EnableDictation in SpeechConfig.

speechConfig.EnableDictation();

Cambiare la lingua di origine

Un'attività comune per il riconoscimento vocale è la specifica della lingua di input (o di origine). Vediamo come cambiare la lingua di input in italiano. Nel codice trovare SpeechConfig, quindi aggiungere questa riga al di sotto.

speechConfig.SpeechRecognitionLanguage = "it-IT";

La proprietà SpeechRecognitionLanguage si aspetta una stringa in formato è prevista una stringa di formato lingua-impostazioni locali. È possibile specificare qualsiasi valore nella colonna Locale nell'elenco di impostazioni locali/lingue supportate.

Migliorare l'accuratezza del riconoscimento

Gli elenchi di frasi vengono usati per identificare frasi note nei dati audio, ad esempio il nome di una persona o una specifica località. Se si fornisce un elenco di frasi, è possibile migliorare l'accuratezza del riconoscimento vocale.

Se ad esempio è presente un comando "Sposta in" e una delle possibili destinazioni pronunciabili è "Vaso", è possibile aggiungere la voce "Sposta in vaso". L'aggiunta di una frase aumenta la probabilità che, durante il riconoscimento dell'audio, venga riconosciuta la frase "Sposta in vaso" invece di "Sposta invaso"

All'elenco di frasi è possibile aggiungere singole parole o frasi complete. Una voce di un elenco di frasi viene usata per migliorare il riconoscimento di parole e frasi dell'elenco, anche quando le voci capitano nel mezzo di un'espressione.

Importante

La funzionalità Elenco frasi è disponibile nelle lingue seguenti: en-US, de-DE, en-AU, en-CA, en-GB, en-IN, es-ES, fr-FR, it-IT, ja-JP, pt-BR, zh-CN

La funzionalità Elenco frasi deve essere usata con non più di poche centinaia di frasi. Se si dispone di un elenco più ampio o per le lingue attualmente non supportate, il training di un modello personalizzato sarà probabilmente la scelta migliore per migliorare l'accuratezza.

Non usare la funzionalità Elenco frasi con endpoint personalizzati. Eseguire invece il training di un modello personalizzato che include le frasi.

Per usare un elenco di frasi, creare prima di tutto un oggetto PhraseListGrammar, quindi aggiungere parole o frasi specifiche con AddPhrase.

Tutte le modifiche apportate a PhraseListGrammar diventano effettive al successivo riconoscimento o dopo una riconnessione al servizio Voce.

var phraseList = PhraseListGrammar.FromRecognizer(recognizer);
phraseList.AddPhrase("Supercalifragilisticexpialidocious");

Se è necessario cancellare l'elenco di frasi:

phraseList.Clear();

Altre opzioni per migliorare l'accuratezza del riconoscimento

Gli elenchi di frasi sono solo una delle opzioni disponibili per migliorare l'accuratezza del riconoscimento. È anche possibile:

Una delle principali funzionalità del servizio Voce è la possibilità di riconoscere e trascrivere la voce umana, ovvero di convertire la voce in testo scritto. Questa guida di avvio rapido illustra come usare Speech SDK in app e prodotti per eseguire la conversione della voce in testo scritto di alta qualità.

Passare agli esempi su GitHub

Per passare direttamente al codice di esempio, vedere gli esempi di avvio rapido C++ in GitHub.

Prerequisiti

Questo articolo presuppone che si abbia un account Azure e una sottoscrizione del servizio Voce. Se l'account e la sottoscrizione non sono disponibili, provare il servizio Voce gratuitamente.

Installare Speech SDK

Prima di poter eseguire qualsiasi operazione, è necessario installare Speech SDK. A seconda della piattaforma, usare le istruzioni seguenti:

Creare una configurazione di Voce

Per chiamare il servizio Voce con Speech SDK, è necessario creare una classe SpeechConfig. Questa classe include informazioni sulla sottoscrizione, ad esempio la chiave e il percorso/area, l'endpoint, l'host o il token di autorizzazione associati. Creare una classe SpeechConfig usando la chiave e l'area. Vedere la pagina Trova chiavi e località/area geografica per trovare la coppia chiave-località/area geografica.

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

auto config = SpeechConfig::FromSubscription("<paste-your-speech-key-here>", "<paste-your-speech-location/region-here>");

Esistono alcuni altri modi per inizializzare una classe SpeechConfig:

  • Con un endpoint: passare un endpoint del servizio Voce. La chiave e il token di autorizzazione sono facoltativi.
  • Con un host: passare l'indirizzo di un host. La chiave e il token di autorizzazione sono facoltativi.
  • Con un token di autorizzazione: passare un token di autorizzazione e l'area associata.

Nota

Sia che si esegua il riconoscimento vocale, la sintesi vocale, la traduzione o il riconoscimento finalità, sarà sempre necessario creare una configurazione.

Riconoscimento da microfono

Per eseguire il riconoscimento vocale usando il microfono del dispositivo, creare un oggetto AudioConfig usando FromDefaultMicrophoneInput(). Quindi, inizializzare una classe SpeechRecognizer, passando la classe audioConfig e config.

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

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

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

Se si vuole usare un dispositivo di input audio specifico, è necessario specificare l'ID del dispositivo nella classe AudioConfig. Informazioni su come ottenere l'ID del dispositivo di input audio.

Riconoscimento da file

Se si vuole specificare un file audio invece di usare un microfono per il riconoscimento vocale, è comunque necessario creare un oggetto AudioConfig. Tuttavia, quando si crea AudioConfig, invece di chiamare FromDefaultMicrophoneInput(), si chiamerà FromWavFileInput() e si passerà il percorso file.

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

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

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

Riconoscimento vocale

La classe Recognizer per Speech SDK per C++ espone alcuni metodi che è possibile usare per il riconoscimento vocale.

Riconoscimento singolo

Il riconoscimento singolo riconosce in modo asincrono una singola espressione. La fine di una singola espressione viene determinata restando in ascolto del silenzio al termine o finché non vengono elaborati al massimo 15 secondi di audio. Ecco un esempio di riconoscimento singolo asincrono usando RecognizeOnceAsync:

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

Per gestire il risultato è necessario scrivere del codice. Questo esempio valuta result->Reason:

  • Stampa il risultato del riconoscimento: ResultReason::RecognizedSpeech
  • Se non esiste una corrispondenza di riconoscimento, informa l'utente: ResultReason::NoMatch
  • Se viene rilevato un errore, stampa il messaggio di errore: 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 update the speech key and location/region info?" << std::endl;
            }
        }
        break;
    default:
        break;
}

Riconoscimento continuo

Il riconoscimento continuo è un po' più impegnativo rispetto al riconoscimento singolo. Per ottenere i risultati del riconoscimento, è necessario sottoscrivere gli eventi Recognizing, Recognized e Canceled. Per arrestare il riconoscimento, è necessario chiamare StopContinuousRecognitionAsync. Ecco un esempio di riconoscimento continuo eseguito su un file di input audio.

Per iniziare, definire l'input e inizializzare SpeechRecognizer:

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

Successivamente, creare una variabile per gestire lo stato del riconoscimento vocale. Per iniziare, verrà dichiarato un oggetto promise<void>, dal momento che all'inizio si può ovviamente presupporre che il riconoscimento non sia terminato.

promise<void> recognitionEnd;

Verranno sottoscritti gli eventi inviati da SpeechRecognizer.

  • Recognizing: segnale per gli eventi contenenti i risultati del riconoscimento intermedio.
  • Recognized: segnale per gli eventi contenenti i risultati del riconoscimento finale, che indicano un tentativo di riconoscimento riuscito.
  • SessionStopped: segnale per gli eventi che indicano la fine di una sessione di riconoscimento (operazione).
  • Canceled: segnale per gli eventi contenenti risultati di riconoscimento annullati (a indicare un tentativo di riconoscimento annullato in seguito a una richiesta di annullamento diretta o, in alternativa, a un errore di trasporto o di protocollo).
recognizer->Recognizing.Connect([](const SpeechRecognitionEventArgs& e)
    {
        cout << "Recognizing:" << e.Result->Text << std::endl;
    });

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

recognizer->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 update the speech key and location/region info?" << std::endl;

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

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

Con tutti gli elementi configurati, è possibile chiamare StopContinuousRecognitionAsync.

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

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

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

Modalità dettatura

Quando si usa il riconoscimento continuo, è possibile abilitare l'elaborazione della dettatura usando la corrispondente funzione. In questa modalità l'istanza di SpeechConfig interpreta le descrizioni testuali delle strutture di frasi, ad esempio la punteggiatura. Ad esempio, l'espressione "Vivi in città punto interrogativo" verrebbe interpretata come "Vivi in città?".

Per abilitare la modalità di dettatura, usare il metodo EnableDictation in SpeechConfig.

config->EnableDictation();

Cambiare la lingua di origine

Un'attività comune per il riconoscimento vocale è la specifica della lingua di input (o di origine). Vediamo come cambiare la lingua di input in tedesco. Nel codice trovare SpeechConfig, quindi aggiungere questa riga al di sotto.

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

SetSpeechRecognitionLanguage è un parametro che accetta una stringa come argomento. È possibile specificare qualsiasi valore nell'elenco di impostazioni locali/lingue supportate.

Migliorare l'accuratezza del riconoscimento

Gli elenchi di frasi vengono usati per identificare frasi note nei dati audio, ad esempio il nome di una persona o una specifica località. Se si fornisce un elenco di frasi, è possibile migliorare l'accuratezza del riconoscimento vocale.

Se ad esempio è presente un comando "Sposta in" e una delle possibili destinazioni pronunciabili è "Vaso", è possibile aggiungere la voce "Sposta in vaso". L'aggiunta di una frase aumenta la probabilità che, durante il riconoscimento dell'audio, venga riconosciuta la frase "Sposta in vaso" invece di "Sposta invaso"

All'elenco di frasi è possibile aggiungere singole parole o frasi complete. Una voce di un elenco di frasi viene usata per migliorare il riconoscimento di parole e frasi dell'elenco, anche quando le voci capitano nel mezzo di un'espressione.

Importante

La funzionalità Elenco frasi è disponibile nelle lingue seguenti: en-US, de-DE, en-AU, en-CA, en-GB, en-IN, es-ES, fr-FR, it-IT, ja-JP, pt-BR, zh-CN

La funzionalità Elenco frasi deve essere usata con non più di poche centinaia di frasi. Se si dispone di un elenco più ampio o per le lingue attualmente non supportate, il training di un modello personalizzato sarà probabilmente la scelta migliore per migliorare l'accuratezza.

Non usare la funzionalità Elenco frasi con endpoint personalizzati. Eseguire invece il training di un modello personalizzato che include le frasi.

Per usare un elenco di frasi, creare prima di tutto un oggetto PhraseListGrammar, quindi aggiungere parole o frasi specifiche con AddPhrase.

Tutte le modifiche apportate a PhraseListGrammar diventano effettive al successivo riconoscimento o dopo una riconnessione al servizio Voce.

auto phraseListGrammar = PhraseListGrammar::FromRecognizer(recognizer);
phraseListGrammar->AddPhrase("Supercalifragilisticexpialidocious");

Se è necessario cancellare l'elenco di frasi:

phraseListGrammar->Clear();

Altre opzioni per migliorare l'accuratezza del riconoscimento

Gli elenchi di frasi sono solo una delle opzioni disponibili per migliorare l'accuratezza del riconoscimento. È anche possibile:

Una delle principali funzionalità del servizio Voce è la possibilità di riconoscere e trascrivere la voce umana, ovvero di convertire la voce in testo scritto. Questa guida di avvio rapido illustra come usare Speech SDK in app e prodotti per eseguire la conversione della voce in testo scritto di alta qualità.

Passare agli esempi su GitHub

Per passare direttamente al codice di esempio, vedere gli esempi di avvio rapido Go in GitHub.

Prerequisiti

Questo articolo presuppone che si abbia un account Azure e una sottoscrizione del servizio Voce. Se l'account e la sottoscrizione non sono disponibili, provare il servizio Voce gratuitamente.

Installare Speech SDK

Prima di poter eseguire qualsiasi operazione, è necessario installare Speech SDK per Go.

Riconoscimento vocale da microfono

Usare l'esempio di codice seguente per eseguire il riconoscimento vocale dal microfono del dispositivo predefinito. Sostituire le variabili subscription e con la chiave di riconoscimento vocale e la region posizione/area geografica. Vedere la pagina Trova chiavi e località/area geografica per trovare la coppia chiave-posizione/area. Eseguendo lo script viene avviata una sessione di riconoscimento vocale sul microfono predefinito e sul testo di output.

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

func main() {
    subscription :=  "<paste-your-speech-key-here>"
    region := "<paste-your-speech-location/region-here>"

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

Eseguire i comandi seguenti per creare un file go.mod che si collega ai componenti ospitati in GitHub.

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

Ora compilare ed eseguire il codice.

go build
go run quickstart

Per informazioni dettagliate sulle classi SpeechConfig e SpeechRecognizer, vedere la documentazione di riferimento.

Riconoscimento vocale da file audio

Usare l'esempio seguente per eseguire il riconoscimento vocale da un file audio. Sostituire le variabili subscription e con la chiave di riconoscimento vocale e la region posizione/area geografica. Vedere la pagina Trova chiavi e località/area geografica per trovare la coppia chiave-posizione/area. Sostituire inoltre la variabile file con il percorso di un file WAV. Con l'esecuzione dello script viene eseguito il riconoscimento vocale dal file e viene restituito il risultato del testo.

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 :=  "<paste-your-speech-key-here>"
    region := "<paste-your-speech-location/region-here>"
    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)
}

Eseguire i comandi seguenti per creare un file go.mod che si collega ai componenti ospitati in GitHub.

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

Ora compilare ed eseguire il codice.

go build
go run quickstart

Per informazioni dettagliate sulle classi SpeechConfig e SpeechRecognizer, vedere la documentazione di riferimento.

Una delle principali funzionalità del servizio Voce è la possibilità di riconoscere e trascrivere la voce umana, ovvero di convertire la voce in testo scritto. Questa guida di avvio rapido illustra come usare Speech SDK in app e prodotti per eseguire la conversione della voce in testo scritto di alta qualità.

Passare agli esempi su GitHub

Per passare direttamente al codice di esempio, vedere gli esempi di avvio rapido Java in GitHub.

Prerequisiti

Questo articolo presuppone che si abbia un account Azure e una sottoscrizione del servizio Voce. Se l'account e la sottoscrizione non sono disponibili, provare il servizio Voce gratuitamente.

Installare Speech SDK

Prima di poter eseguire qualsiasi operazione, è necessario installare Speech SDK. A seconda della piattaforma, usare le istruzioni seguenti:

Creare una configurazione di Voce

Per chiamare il servizio Voce con Speech SDK, è necessario creare una classe SpeechConfig. Questa classe include informazioni sulla sottoscrizione, ad esempio la chiave e la posizione/area, l'endpoint, l'host o il token di autorizzazione associati. Creare un SpeechConfig oggetto usando la chiave e la posizione/area geografica. Vedere la pagina Trova chiavi e località/area geografica per trovare la coppia chiave-posizione/area.

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-subscription-key>", "<paste-your-region>");
    }
}

Esistono alcuni altri modi per inizializzare una classe SpeechConfig:

  • Con un endpoint: passare un endpoint del servizio Voce. La chiave e il token di autorizzazione sono facoltativi.
  • Con un host: passare l'indirizzo di un host. La chiave e il token di autorizzazione sono facoltativi.
  • Con un token di autorizzazione: passare un token di autorizzazione e l'area associata.

Nota

Sia che si esegua il riconoscimento vocale, la sintesi vocale, la traduzione o il riconoscimento finalità, sarà sempre necessario creare una configurazione.

Riconoscimento da microfono

Per eseguire il riconoscimento vocale usando il microfono del dispositivo, creare un oggetto AudioConfig usando fromDefaultMicrophoneInput(). Quindi, inizializzare una classe SpeechRecognizer, passando la classe audioConfig e 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-subscription-key>", "<paste-your-region>");
        fromMic(speechConfig);
    }

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

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

Se si vuole usare un dispositivo di input audio specifico, è necessario specificare l'ID del dispositivo nella classe AudioConfig. Informazioni su come ottenere l'ID del dispositivo di input audio.

Riconoscimento da file

Se si vuole specificare un file audio invece di usare un microfono per il riconoscimento vocale, è comunque necessario creare un oggetto AudioConfig. Tuttavia, quando si crea AudioConfig, invece di chiamare fromDefaultMicrophoneInput(), si chiamerà fromWavFileInput() e si passerà il percorso file.

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-subscription-key>", "<paste-your-region>");
        fromFile(speechConfig);
    }

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

Gestione degli errori

Gli esempi precedenti ottengono semplicemente il testo riconosciuto con result.getText(), ma per gestire gli errori e altre risposte è necessario scrivere del codice per elaborare il risultato. Nell'esempio seguente viene valutato come result.getReason() e:

  • Stampa il risultato del riconoscimento: ResultReason.RecognizedSpeech
  • Se non esiste una corrispondenza di riconoscimento, informa l'utente: ResultReason.NoMatch
  • Se viene rilevato un errore, stampa il messaggio di errore: ResultReason.Canceled
switch (result.getReason()) {
    case ResultReason.RecognizedSpeech:
        System.out.println("We recognized: " + result.getText());
        exitCode = 0;
        break;
    case ResultReason.NoMatch:
        System.out.println("NOMATCH: Speech could not be recognized.");
        break;
    case ResultReason.Canceled: {
            CancellationDetails cancellation = CancellationDetails.fromResult(result);
            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 update the subscription info?");
            }
        }
        break;
}

Riconoscimento continuo

Gli esempi precedenti usano il riconoscimento singolo, che riconosce una singola espressione. La fine di una singola espressione viene determinata restando in ascolto del silenzio al termine o finché non vengono elaborati al massimo 15 secondi di audio.

Al contrario, si usa il riconoscimento continuo quando si vuole controllare il momento in cui interrompere il riconoscimento. Per ottenere i risultati del riconoscimento, è necessario sottoscrivere gli eventi recognizing, recognized e canceled. Per arrestare il riconoscimento, è necessario chiamare stopContinuousRecognitionAsync. Ecco un esempio di riconoscimento continuo eseguito su un file di input audio.

Per iniziare, definire l'input e inizializzare SpeechRecognizer:

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

Successivamente, creare una variabile per gestire lo stato del riconoscimento vocale. Per iniziare, verrà dichiarato un oggetto Semaphore nell'ambito della classe.

private static Semaphore stopTranslationWithFileSemaphore;

Verranno sottoscritti gli eventi inviati da SpeechRecognizer.

  • recognizing: segnale per gli eventi contenenti i risultati del riconoscimento intermedio.
  • recognized: segnale per gli eventi contenenti i risultati del riconoscimento finale, che indicano un tentativo di riconoscimento riuscito.
  • sessionStopped: segnale per gli eventi che indicano la fine di una sessione di riconoscimento (operazione).
  • canceled: segnale per gli eventi contenenti risultati di riconoscimento annullati (a indicare un tentativo di riconoscimento annullato in seguito a una richiesta di annullamento diretta o, in alternativa, a un errore di trasporto o di protocollo).
// First initialize the semaphore.
stopTranslationWithFileSemaphore = new Semaphore(0);

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

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

recognizer.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 update the subscription info?");
    }

    stopTranslationWithFileSemaphore.release();
});

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

Con tutti gli elementi configurati, è possibile chiamare startContinuousRecognitionAsync.

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

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

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

Modalità dettatura

Quando si usa il riconoscimento continuo, è possibile abilitare l'elaborazione della dettatura usando la corrispondente funzione. In questa modalità l'istanza di SpeechConfig interpreta le descrizioni testuali delle strutture di frasi, ad esempio la punteggiatura. Ad esempio, l'espressione "Vivi in città punto interrogativo" verrebbe interpretata come "Vivi in città?".

Per abilitare la modalità di dettatura, usare il metodo enableDictation in SpeechConfig.

config.enableDictation();

Cambiare la lingua di origine

Un'attività comune per il riconoscimento vocale è la specifica della lingua di input (o di origine). Vediamo come cambiare la lingua di input in francese. Nel codice trovare SpeechConfig, quindi aggiungere questa riga al di sotto.

config.setSpeechRecognitionLanguage("fr-FR");

setSpeechRecognitionLanguage è un parametro che accetta una stringa come argomento. È possibile specificare qualsiasi valore nell'elenco di impostazioni locali/lingue supportate.

Migliorare l'accuratezza del riconoscimento

Gli elenchi di frasi vengono usati per identificare frasi note nei dati audio, ad esempio il nome di una persona o una specifica località. Se si fornisce un elenco di frasi, è possibile migliorare l'accuratezza del riconoscimento vocale.

Se ad esempio è presente un comando "Sposta in" e una delle possibili destinazioni pronunciabili è "Vaso", è possibile aggiungere la voce "Sposta in vaso". L'aggiunta di una frase aumenta la probabilità che, durante il riconoscimento dell'audio, venga riconosciuta la frase "Sposta in vaso" invece di "Sposta invaso"

All'elenco di frasi è possibile aggiungere singole parole o frasi complete. Una voce di un elenco di frasi viene usata per migliorare il riconoscimento di parole e frasi dell'elenco, anche quando le voci capitano nel mezzo di un'espressione.

Importante

La funzionalità Elenco frasi è disponibile nelle lingue seguenti: en-US, de-DE, en-AU, en-CA, en-GB, en-IN, es-ES, fr-FR, it-IT, ja-JP, pt-BR, zh-CN

La funzionalità Elenco frasi deve essere usata con un numero di frasi non superiore a poche centinaia. Se si dispone di un elenco più ampio o per le lingue attualmente non supportate, il training di un modello personalizzato sarà probabilmente la scelta migliore per migliorare l'accuratezza.

Non usare la funzionalità Elenco frasi con endpoint personalizzati. Eseguire invece il training di un modello personalizzato che include le frasi.

Per usare un elenco di frasi, creare prima di tutto un oggetto PhraseListGrammar, quindi aggiungere parole o frasi specifiche con AddPhrase.

Tutte le modifiche apportate a PhraseListGrammar diventano effettive al successivo riconoscimento o dopo una riconnessione al servizio Voce.

PhraseListGrammar phraseList = PhraseListGrammar.fromRecognizer(recognizer);
phraseList.addPhrase("Supercalifragilisticexpialidocious");

Se è necessario cancellare l'elenco di frasi:

phraseList.clear();

Altre opzioni per migliorare l'accuratezza del riconoscimento

Gli elenchi di frasi sono solo una delle opzioni disponibili per migliorare l'accuratezza del riconoscimento. È anche possibile:

Una delle principali funzionalità del servizio Voce è la possibilità di riconoscere e trascrivere la voce umana, ovvero di convertire la voce in testo scritto. Questa guida di avvio rapido illustra come usare Speech SDK in app e prodotti per eseguire la conversione della voce in testo scritto di alta qualità.

Passare agli esempi su GitHub

Per passare direttamente al codice di esempio, vedere gli esempi di avvio rapido JavaScript in GitHub.

In alternativa, vedere l'React per informazioni su come usare Speech SDK in un ambiente basato su browser.

Prerequisiti

Questo articolo presuppone che si abbia un account Azure e una sottoscrizione del servizio Voce. Se l'account e la sottoscrizione non sono disponibili, provare il servizio Voce gratuitamente.

Installare Speech SDK

Prima di poter eseguire qualsiasi operazione, è necessario installare Speech SDK per Node.js. Se si vuole installare solo il nome del pacchetto, eseguire npm install microsoft-cognitiveservices-speech-sdk . Per istruzioni sull'installazione guidata, vedere l'articolo introduttivo.

Usare require l'istruzione seguente per importare l'SDK.

const sdk = require("microsoft-cognitiveservices-speech-sdk");

Per altre informazioni su require , vedere la documentazione relativa alla richiesta.

Creare una configurazione di Voce

Per chiamare il servizio Voce con Speech SDK, è necessario creare una classe SpeechConfig. Questa classe include informazioni sulla sottoscrizione, ad esempio la chiave e la posizione/area, l'endpoint, l'host o il token di autorizzazione associati. Creare un SpeechConfig oggetto usando la chiave e la posizione/area geografica. Per trovare la coppia chiave-posizione/area, vedere la pagina Trovare chiavi e località/area.

const speechConfig = sdk.SpeechConfig.fromSubscription("<paste-your-speech-key-here>", "<paste-your-speech-location/region-here>");

Esistono alcuni altri modi per inizializzare una classe SpeechConfig:

  • Con un endpoint: passare un endpoint del servizio Voce. La chiave e il token di autorizzazione sono facoltativi.
  • Con un host: passare l'indirizzo di un host. La chiave e il token di autorizzazione sono facoltativi.
  • Con un token di autorizzazione: passare un token di autorizzazione e la località o l'area associata.

Nota

Sia che si esegua il riconoscimento vocale, la sintesi vocale, la traduzione o il riconoscimento finalità, sarà sempre necessario creare una configurazione.

Riconoscimento da microfono (solo browser)

Il riconoscimento vocale da un microfono non è supportato in Node.js ed è supportato solo in un ambiente JavaScript basato su browser. Vedere l React di esempio su GitHub per vedere l'implementazionedel riconoscimento vocale dal microfono.

Nota

Se si vuole usare un dispositivo di input audio specifico, è necessario specificare l'ID del dispositivo nella classe AudioConfig. Informazioni su come ottenere l'ID del dispositivo di input audio.

Riconoscimento da file

Per riconoscere la voce da un file audio, creare un AudioConfig oggetto usando che accetta un oggetto fromWavFileInput() Buffer . Quindi, inizializzare una classe SpeechRecognizer, passando la classe audioConfig e speechConfig.

const fs = require('fs');
const sdk = require("microsoft-cognitiveservices-speech-sdk");
const speechConfig = sdk.SpeechConfig.fromSubscription("<paste-your-speech-key-here>", "<paste-your-speech-location/region-here>");

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

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

Riconoscimento dal flusso in memoria

Per molti casi d'uso, è probabile che i dati audio siano provenienti dall'archiviazione BLOB o che siano già in memoria come struttura di dati non elaborati o ArrayBuffer simile. Il codice seguente:

  • Crea un flusso push usando createPushStream() .
  • Legge un file usando a scopo dimostrativo, ma se si dispone già di dati audio in un , è possibile passare direttamente alla scrittura del contenuto .wav fs.createReadStream nel flusso di ArrayBuffer input.
  • Crea una configurazione audio usando il flusso push.
const fs = require('fs');
const sdk = require("microsoft-cognitiveservices-speech-sdk");
const speechConfig = sdk.SpeechConfig.fromSubscription("<paste-your-speech-key-here>", "<paste-your-speech-location/region-here>");

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 recognizer = new sdk.SpeechRecognizer(speechConfig, audioConfig);
    recognizer.recognizeOnceAsync(result => {
        console.log(`RECOGNIZED: Text=${result.text}`);
        recognizer.close();
    });
}
fromStream();

L'uso di un flusso push come input presuppone che i dati audio siano un PCM non elaborato, ad esempio ignorano le intestazioni. L'API continuerà a funzionare in determinati casi se l'intestazione non è stata ignorata, ma per ottenere risultati ottimali è consigliabile implementare la logica per leggere le intestazioni, in modo che il fs cominci all'inizio dei dati audio.

Gestione degli errori

Gli esempi precedenti ottengono semplicemente il testo riconosciuto da result.text, ma per gestire gli errori e altre risposte è necessario scrivere del codice per elaborare il risultato. Il seguente codice valuta la proprietà result.reason e:

  • Stampa il risultato del riconoscimento: ResultReason.RecognizedSpeech
  • Se non esiste una corrispondenza di riconoscimento, informa l'utente: ResultReason.NoMatch
  • Se viene rilevato un errore, stampa il messaggio di errore: 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 = 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 update the key and location/region info?");
        }
        break;
    }

Riconoscimento continuo

Gli esempi precedenti usano il riconoscimento singolo, che riconosce una singola espressione. La fine di una singola espressione viene determinata restando in ascolto del silenzio al termine o finché non vengono elaborati al massimo 15 secondi di audio.

Al contrario, si usa il riconoscimento continuo quando si vuole controllare il momento in cui interrompere il riconoscimento. Per ottenere i risultati del riconoscimento, è necessario sottoscrivere gli eventi Recognizing, Recognized e Canceled. Per arrestare il riconoscimento, è necessario chiamare stopContinuousRecognitionAsync. Ecco un esempio di riconoscimento continuo eseguito su un file di input audio.

Per iniziare, definire l'input e inizializzare un SpeechRecognizer:

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

Infine, sottoscrivere gli eventi inviati dal SpeechRecognizer.

  • recognizing: segnale per gli eventi contenenti i risultati del riconoscimento intermedio.
  • recognized: segnale per gli eventi contenenti i risultati del riconoscimento finale, che indicano un tentativo di riconoscimento riuscito.
  • sessionStopped: segnale per gli eventi che indicano la fine di una sessione di riconoscimento (operazione).
  • canceled: segnale per gli eventi contenenti risultati di riconoscimento annullati (a indicare un tentativo di riconoscimento annullato in seguito a una richiesta di annullamento diretta o, in alternativa, a un errore di trasporto o di protocollo).
recognizer.recognizing = (s, e) => {
    console.log(`RECOGNIZING: Text=${e.result.text}`);
};

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

recognizer.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 update the key and location/region info?");
    }

    recognizer.stopContinuousRecognitionAsync();
};

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

Al termine della configurazione, chiamare startContinuousRecognitionAsync per avviare il riconoscimento.

recognizer.startContinuousRecognitionAsync();

// make the following call at some point to stop recognition.
// recognizer.StopContinuousRecognitionAsync();

Modalità dettatura

Quando si usa il riconoscimento continuo, è possibile abilitare l'elaborazione della dettatura usando la corrispondente funzione. In questa modalità l'istanza di SpeechConfig interpreta le descrizioni testuali delle strutture di frasi, ad esempio la punteggiatura. Ad esempio, l'espressione "Vivi in città punto interrogativo" verrebbe interpretata come "Vivi in città?".

Per abilitare la modalità di dettatura, usare il metodo enableDictation in SpeechConfig.

speechConfig.enableDictation();

Cambiare la lingua di origine

Un'attività comune per il riconoscimento vocale è la specifica della lingua di input (o di origine). Vediamo come cambiare la lingua di input in italiano. Nel codice trovare SpeechConfig, quindi aggiungere questa riga al di sotto.

speechConfig.speechRecognitionLanguage = "it-IT";

La proprietà speechRecognitionLanguage si aspetta una stringa in formato è prevista una stringa di formato lingua-impostazioni locali. È possibile specificare qualsiasi valore nella colonna Locale nell'elenco di impostazioni locali/lingue supportate.

Migliorare l'accuratezza del riconoscimento

Gli elenchi di frasi vengono usati per identificare frasi note nei dati audio, ad esempio il nome di una persona o una specifica località. Se si fornisce un elenco di frasi, è possibile migliorare l'accuratezza del riconoscimento vocale.

Se ad esempio è presente un comando "Sposta in" e una delle possibili destinazioni pronunciabili è "Vaso", è possibile aggiungere la voce "Sposta in vaso". L'aggiunta di una frase aumenta la probabilità che, durante il riconoscimento dell'audio, venga riconosciuta la frase "Sposta in vaso" invece di "Sposta invaso"

All'elenco di frasi è possibile aggiungere singole parole o frasi complete. Una voce di un elenco di frasi viene usata per migliorare il riconoscimento di parole e frasi dell'elenco, anche quando le voci capitano nel mezzo di un'espressione.

Importante

La funzionalità Elenco frasi è disponibile nelle lingue seguenti: en-US, de-DE, en-AU, en-CA, en-GB, en-IN, es-ES, fr-FR, it-IT, ja-JP, pt-BR, zh-CN

La funzionalità Elenco frasi deve essere usata con non più di poche centinaia di frasi. Se si dispone di un elenco più ampio o per le lingue attualmente non supportate, il training di un modello personalizzato sarà probabilmente la scelta migliore per migliorare l'accuratezza.

Non usare la funzionalità Elenco frasi con endpoint personalizzati. Eseguire invece il training di un modello personalizzato che include le frasi.

Per usare un elenco di frasi, creare prima di tutto un oggetto PhraseListGrammar, quindi aggiungere parole o frasi specifiche con addPhrase.

Tutte le modifiche apportate a PhraseListGrammar diventano effettive al successivo riconoscimento o dopo una riconnessione al servizio Voce.

const phraseList = sdk.PhraseListGrammar.fromRecognizer(recognizer);
phraseList.addPhrase("Supercalifragilisticexpialidocious");

Se è necessario cancellare l'elenco di frasi:

phraseList.clear();

Altre opzioni per migliorare l'accuratezza del riconoscimento

Gli elenchi di frasi sono solo una delle opzioni disponibili per migliorare l'accuratezza del riconoscimento. È anche possibile:

Una delle principali funzionalità del servizio Voce è la possibilità di riconoscere e trascrivere la voce umana, ovvero di convertire la voce in testo scritto. In questo esempio si apprenderà come usare Speech SDK nelle app e nei prodotti per eseguire una conversione voce-testo di alta qualità.

React di esempio in GitHub

Vedere l'React di esempio GitHub per informazioni su come usare Speech SDK in un ambiente JavaScript basato su browser. Questo esempio illustra esempi di modelli progettuali per lo scambio e la gestione di token di autenticazione e l'acquisizione di audio da un microfono o da un file per le conversioni da voce a testo.

Inoltre, i modelli di progettazione usati nella guidaNode.js di avvio rapido possono essere usati anche in un ambiente browser.

È possibile trascrivere il parlato in testo usando Speech SDK per Swift e Objective-C.

Prerequisiti

Gli esempi seguenti presuppongono che si abbia un account Azure e una sottoscrizione del servizio Voce. Se l'account e la sottoscrizione non sono disponibili, provare il servizio Voce gratuitamente.

Installare Speech SDK e gli esempi

Speech SDK di Servizi cognitivi contiene esempi scritti in Swift e Objective-C per iOS e Mac. Fare clic su un collegamento per visualizzare le istruzioni di installazione per ogni esempio:

Sono disponibili anche Informazioni di riferimento su Speech SDK per Objective-C.

Una delle principali funzionalità del servizio Voce è la possibilità di riconoscere e trascrivere la voce umana, ovvero di convertire la voce in testo scritto. Questa guida di avvio rapido illustra come usare Speech SDK in app e prodotti per eseguire la conversione della voce in testo scritto di alta qualità.

Passare agli esempi su GitHub

Per passare direttamente al codice di esempio, vedere gli esempi di avvio rapido Python in GitHub.

Prerequisiti

Questo articolo presuppone che:

Installare e importare Speech SDK

Prima di poter eseguire qualsiasi operazione, è necessario installare Speech SDK.

pip install azure-cognitiveservices-speech

Se si usa macOS e si verificano problemi di installazione, può essere necessario eseguire prima questo comando.

python3 -m pip install --upgrade pip

Dopo aver installato Speech SDK, importarlo nel progetto Python.

import azure.cognitiveservices.speech as speechsdk

Creare una configurazione di Voce

Per chiamare il servizio Voce con Speech SDK, è necessario creare una classe SpeechConfig. Questa classe include informazioni sulla sottoscrizione, ad esempio la chiave e il percorso/area, l'endpoint, l'host o il token di autorizzazione associati. Creare un SpeechConfig oggetto usando la chiave e la località/area geografica. Vedere la pagina Trova chiavi e località/area geografica per trovare la coppia chiave-località/area geografica.

speech_config = speechsdk.SpeechConfig(subscription="<paste-your-speech-key-here>", region="<paste-your-speech-location/region-here>")

Esistono alcuni altri modi per inizializzare una classe SpeechConfig:

  • Con un endpoint: passare un endpoint del servizio Voce. La chiave e il token di autorizzazione sono facoltativi.
  • Con un host: passare l'indirizzo di un host. La chiave e il token di autorizzazione sono facoltativi.
  • Con un token di autorizzazione: passare un token di autorizzazione e l'area associata.

Nota

Sia che si esegua il riconoscimento vocale, la sintesi vocale, la traduzione o il riconoscimento finalità, sarà sempre necessario creare una configurazione.

Riconoscimento da microfono

Per eseguire il riconoscimento vocale usando il microfono del dispositivo, è sufficiente creare un oggetto SpeechRecognizer senza passare una classe AudioConfig e passando la classe speech_config.

import azure.cognitiveservices.speech as speechsdk

def from_mic():
    speech_config = speechsdk.SpeechConfig(subscription="<paste-your-speech-key-here>", region="<paste-your-speech-location/region-here>")
    speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config)
    
    print("Speak into your microphone.")
    result = speech_recognizer.recognize_once_async().get()
    print(result.text)

from_mic()

Se si vuole usare un dispositivo di input audio specifico, è necessario specificare l'ID del dispositivo in una classe AudioConfig e passarlo al parametro audio_config del costruttore di SpeechRecognizer. Informazioni su come ottenere l'ID del dispositivo di input audio.

Riconoscimento da file

Se si vuole specificare un file audio invece di usare un microfono per il riconoscimento vocale, è comunque necessario creare un oggetto AudioConfig e usare il parametro filename.

import azure.cognitiveservices.speech as speechsdk

def from_file():
    speech_config = speechsdk.SpeechConfig(subscription="<paste-your-speech-key-here>", region="<paste-your-speech-location/region-here>")
    audio_input = speechsdk.AudioConfig(filename="your_file_name.wav")
    speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config, audio_config=audio_input)
    
    result = speech_recognizer.recognize_once_async().get()
    print(result.text)

from_file()

Gestione degli errori

Gli esempi precedenti ottengono semplicemente il testo riconosciuto da result.text, ma per gestire gli errori e altre risposte è necessario scrivere del codice per elaborare il risultato. Il seguente codice valuta la proprietà result.reason e:

  • Stampa il risultato del riconoscimento: speechsdk.ResultReason.RecognizedSpeech
  • Se non esiste una corrispondenza di riconoscimento, informa l'utente: speechsdk.ResultReason.NoMatch
  • Se viene rilevato un errore, stampa il messaggio di errore: speechsdk.ResultReason.Canceled
if result.reason == speechsdk.ResultReason.RecognizedSpeech:
    print("Recognized: {}".format(result.text))
elif result.reason == speechsdk.ResultReason.NoMatch:
    print("No speech could be recognized: {}".format(result.no_match_details))
elif result.reason == speechsdk.ResultReason.Canceled:
    cancellation_details = 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))

Riconoscimento continuo

Gli esempi precedenti usano il riconoscimento singolo, che riconosce una singola espressione. La fine di una singola espressione viene determinata restando in ascolto del silenzio al termine o finché non vengono elaborati al massimo 15 secondi di audio.

Al contrario, si usa il riconoscimento continuo quando si vuole controllare il momento in cui interrompere il riconoscimento. È necessario connettersi a per ottenere i risultati del riconoscimento e per arrestare il riconoscimento, è necessario chiamare EventSignal stop_continuous_recognition() o stop_continuous_recognition(). Ecco un esempio di riconoscimento continuo eseguito su un file di input audio.

Per iniziare, definire l'input e inizializzare SpeechRecognizer:

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

Successivamente, creare una variabile per gestire lo stato del riconoscimento vocale. Per iniziare, questa variabile verrà impostata su False, dal momento che all'inizio si può ovviamente presupporre che il riconoscimento non sia terminato.

done = False

A questo punto, verrà creato un callback per arrestare il riconoscimento continuo quando si riceve evt. Occorre tenere presenti alcuni aspetti.

  • Quando si riceve evt, viene stampato il messaggio evt.
  • Dopo la ricezione di evt, viene effettuata una chiamata a stop_continuous_recognition () per arrestare il riconoscimento.
  • Lo stato del riconoscimento cambia in True.
def stop_cb(evt):
    print('CLOSING on {}'.format(evt))
    speech_recognizer.stop_continuous_recognition()
    nonlocal done
    done = True

Questo esempio di codice mostra come connettere i callback agli eventi inviati da SpeechRecognizer.

  • recognizing: segnale per gli eventi contenenti i risultati del riconoscimento intermedio.
  • recognized: segnale per gli eventi contenenti i risultati del riconoscimento finale, che indicano un tentativo di riconoscimento riuscito.
  • session_started: segnale per gli eventi che indicano l'inizio di una sessione di riconoscimento (operazione).
  • session_stopped: segnale per gli eventi che indicano la fine di una sessione di riconoscimento (operazione).
  • canceled: segnale per gli eventi contenenti risultati di riconoscimento annullati (a indicare un tentativo di riconoscimento annullato in seguito a una richiesta di annullamento diretta o, in alternativa, a un errore di trasporto o di protocollo).
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)

Con tutte le impostazioni configurate, è possibile chiamare start_continuous_recognition ().

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

Modalità dettatura

Quando si usa il riconoscimento continuo, è possibile abilitare l'elaborazione della dettatura usando la corrispondente funzione. In questa modalità l'istanza di SpeechConfig interpreta le descrizioni testuali delle strutture di frasi, ad esempio la punteggiatura. Ad esempio, l'espressione "Vivi in città punto interrogativo" verrebbe interpretata come "Vivi in città?".

Per abilitare la modalità di dettatura, usare il metodo enable_dictation() in SpeechConfig.

SpeechConfig.enable_dictation()

Cambiare la lingua di origine

Un'attività comune per il riconoscimento vocale è la specifica della lingua di input (o di origine). Vediamo come cambiare la lingua di input in tedesco. Nel codice trovare SpeechConfig, quindi aggiungere questa riga al di sotto.

speech_config.speech_recognition_language="de-DE"

speech_recognition_language è un parametro che accetta una stringa come argomento. È possibile specificare qualsiasi valore nell'elenco di impostazioni locali/lingue supportate.

Migliorare l'accuratezza del riconoscimento

Gli elenchi di frasi vengono usati per identificare frasi note nei dati audio, ad esempio il nome di una persona o una specifica località. Se si fornisce un elenco di frasi, è possibile migliorare l'accuratezza del riconoscimento vocale.

Se ad esempio è presente un comando "Sposta in" e una delle possibili destinazioni pronunciabili è "Vaso", è possibile aggiungere la voce "Sposta in vaso". L'aggiunta di una frase aumenta la probabilità che, durante il riconoscimento dell'audio, venga riconosciuta la frase "Sposta in vaso" invece di "Sposta invaso"

All'elenco di frasi è possibile aggiungere singole parole o frasi complete. Una voce di un elenco di frasi viene usata per migliorare il riconoscimento di parole e frasi dell'elenco, anche quando le voci capitano nel mezzo di un'espressione.

Importante

La funzionalità Elenco frasi è disponibile nelle lingue seguenti: en-US, de-DE, en-AU, en-CA, en-GB, en-IN, es-ES, fr-FR, it-IT, ja-JP, pt-BR, zh-CN

La funzionalità Elenco frasi deve essere usata con non più di poche centinaia di frasi. Se si dispone di un elenco più ampio o per le lingue attualmente non supportate, il training di un modello personalizzato sarà probabilmente la scelta migliore per migliorare l'accuratezza.

Non usare la funzionalità Elenco frasi con endpoint personalizzati. Eseguire invece il training di un modello personalizzato che include le frasi.

Per usare un elenco di frasi, creare prima di tutto un oggetto PhraseListGrammar, quindi aggiungere parole o frasi specifiche con addPhrase.

Tutte le modifiche apportate a PhraseListGrammar diventano effettive al successivo riconoscimento o dopo una riconnessione al servizio Voce.

phrase_list_grammar = speechsdk.PhraseListGrammar.from_recognizer(reco)
phrase_list_grammar.addPhrase("Supercalifragilisticexpialidocious")

Se è necessario cancellare l'elenco di frasi:

phrase_list_grammar.clear()

Altre opzioni per migliorare l'accuratezza del riconoscimento

Gli elenchi di frasi sono solo una delle opzioni disponibili per migliorare l'accuratezza del riconoscimento. È anche possibile:

Questa guida di avvio rapido descrive come eseguire la conversione della voce in testo scritto con il servizio Voce e cURL.

Per informazioni generali sui concetti di Riconoscimento vocale, vedere l'articolo Panoramica.

Prerequisiti

Questo articolo presuppone che si abbia un account Azure e una sottoscrizione del servizio Voce. Se l'account e la sottoscrizione non sono disponibili, provare il servizio Voce gratuitamente.

Convertire il parlato in testo

Al prompt dei comandi, eseguire questo comando. Sarà necessario inserire i valori seguenti nel comando.

  • La chiave di sottoscrizione al Servizio di riconoscimento vocale dell'utente.
  • L'area del servizio Voce.
  • Il percorso del file audio di input. È possibile generare file audio tramite la sintesi vocale.
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'

Verrà restituita una risposta simile alla seguente.

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

Per altre informazioni, vedere la documentazione di riferimento dell'API REST di riconoscimento vocale.

Una delle principali funzionalità del servizio Voce è la possibilità di riconoscere e trascrivere la voce umana, ovvero di convertire la voce in testo scritto. Questa guida di avvio rapido illustra come usare l'interfaccia della riga di comando per Voce in app e prodotti per eseguire la conversione della voce in testo scritto di alta qualità.

Download e installazione

Per installare l’interfaccia della riga di comando di Voce su Windows, seguire questa procedura:

  1. In Windows è necessaria la versione di Microsoft Visual C++ Redistributable per Visual Studio 2019 per la piattaforma in uso. La prima volta che si esegue questa installazione può essere necessario riavviare il sistema.

  2. Installare .NET Core 3.1 SDK.

  3. Installare l'interfaccia della riga di comando di Riconoscimento vocale NuGet comando seguente:

    dotnet tool install --global Microsoft.CognitiveServices.Speech.CLI
    

Digitare spx per visualizzare la guida per l'interfaccia della riga di comando di Voce.

Nota

In alternativa a NuGet, è possibile scaricare ed estrarre l'interfaccia della riga di comando di Riconoscimento vocale per Windows come file ZIP.

Limitazioni dei tipi di carattere

In Windows, l'interfaccia della riga di comando di Voce può visualizzare solo i tipi di carattere disponibili per il prompt dei comandi nel computer locale. Il terminale Windows supporta tutti i tipi di carattere prodotti in modo interattivo dall'interfaccia della riga di comando di Voce.

Se l'output viene restituito in un file, è possibile che anche un editor di testo come Blocco note o un Web browser come Microsoft Edge visualizzi tutti i tipi di carattere.

Creare la configurazione della sottoscrizione

Per iniziare a usare l'interfaccia della riga di comando di Voce, è necessario immettere la chiave della sottoscrizione e l'identificatore di area del servizio Voce. Per ottenere queste credenziali, seguire la procedura descritta in Provare il servizio Voce gratuitamente. Dopo aver ottenuto l’identificatore dell’area e della chiave di sottoscrizione (ad esempio, eastus, westus), eseguire i comandi seguenti.

spx config @key --set SUBSCRIPTION-KEY
spx config @region --set REGION

L'autenticazione della sottoscrizione è ora archiviata per richieste SPX future. Se è necessario rimuovere uno di questi valori archiviati, eseguire spx config @region --clear o spx config @key --clear.

Riconoscimento vocale da microfono

Collegare e accendere il microfono del PC e disattivare eventuali app che potrebbero usare il microfono. Alcuni computer dispongono di un microfono incorporato, mentre altri richiedono la configurazione di un dispositivo Bluetooth.

A questo punto si è pronti per eseguire l'interfaccia della riga di comando vocale per Voce al fine di utilizzare il riconoscimento vocale dal microfono. Dalla riga di comando passare alla directory che contiene il file binario dell'interfaccia della riga di comando per Voce ed eseguire il comando seguente.

spx recognize --microphone

Nota

La lingua predefinita dell'interfaccia della riga di comando per Voce è l’inglese. È possibile scegliere una lingua diversa dalla tabella Riconoscimento vocale. Ad esempio, aggiungere --source de-DE per il riconoscimento vocale in tedesco.

Parlare nel microfono e sarà possibile vedere la trascrizione delle parole in testo in tempo reale. L'interfaccia della riga di comando per Voce si arresterà dopo un periodo di inattività o quando si preme CTRL + C.

Riconoscimento vocale da file audio

L'interfaccia della riga di comando per Voce può eseguire il riconoscimento vocale in molti formati di file e linguaggi naturali. In questo esempio è possibile usare un file WAV (16 kHz o 8 kHz, a 16 bit e PCM mono) che contiene la voce in lingua inglese. In alternativa, se si vuole un esempio rapido, scaricare il file whatstheweatherlike.wav e copiarlo nella stessa directory del file binario dell'interfaccia della riga di comando di Voce.

A questo punto si è pronti per eseguire l'interfaccia della riga di comando di Voce per riconoscere la voce trovata nel file audio eseguendo il comando seguente.

spx recognize --file whatstheweatherlike.wav

Nota

La lingua predefinita dell'interfaccia della riga di comando per Voce è l’inglese. È possibile scegliere una lingua diversa dalla tabella Riconoscimento vocale. Ad esempio, aggiungere --source de-DE per il riconoscimento vocale in tedesco.

L'interfaccia della riga di comando per Voce visualizzerà una trascrizione testuale della voce sullo schermo.

Passaggi successivi