Riconoscimento vocale

Pacchetto della documentazione di riferimento | (NuGet) | Esempi aggiuntivi in GitHub

In questa guida pratica si apprenderà come riconoscere e trascrivere il parlato in testo in tempo reale.

Creare una configurazione di Voce

Per chiamare il servizio Voce usando Speech SDK, è necessario creare un'istanza SpeechConfig di . Questa classe include informazioni sulla sottoscrizione, ad esempio la chiave e la posizione/area associata, l'endpoint, l'host o il token di autorizzazione.

1. Creare un'istanza SpeechConfig usando la chiave e la posizione/area.
2. Creare una risorsa Voce nel portale di Azure. Per altre informazioni, vedere Creare una risorsa multiservizio.

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

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

È possibile inizializzare SpeechConfig in altri modi:

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

Nota

Indipendentemente dal fatto che si stia eseguendo il riconoscimento vocale, la sintesi vocale, la traduzione o il riconoscimento finalità, si crea sempre una configurazione.

Riconoscimento vocale da un microfono

Per riconoscere il riconoscimento vocale usando il microfono del dispositivo, creare un'istanza AudioConfig usando il FromDefaultMicrophoneInput() metodo . Inizializzare quindi l'oggetto SpeechRecognizer passando speechConfig e audioConfig.

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

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

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

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

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

Riconoscimento vocale da un file

Se si vuole riconoscere la voce da un file audio anziché da un microfono, è comunque necessario creare un'istanza AudioConfig . Ma per questo caso non si chiama FromDefaultMicrophoneInput(). Chiamare FromWavFileInput() e passare il percorso del 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 speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);

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

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

Riconoscimento vocale da un flusso in memoria

Per molti casi d'uso, è probabile che i dati audio provenga da Archiviazione BLOB di Azure oppure che siano già in memoria come byte[] istanza o una struttura di dati non elaborata simile. L'esempio seguente usa PushAudioInputStream per riconoscere il parlato, che è essenzialmente un flusso di memoria astratta. Il codice di esempio esegue le azioni seguenti:

• Scrive dati audio non elaborati (PCM) in PushAudioInputStream usando la Write() funzione , che accetta un'istanza byte[] di .
• Legge un file .wav usando FileReader a scopo dimostrativo. Se si dispone già di dati audio in un'istanza byte[] , è possibile passare direttamente alla scrittura del contenuto nel flusso di input.
• Il formato predefinito è 16 bit, 16-KHz mono pulse-code modulation (PCM). Per personalizzare il formato, è possibile passare un AudioStreamFormat oggetto a CreatePushStream() usando la funzione AudioStreamFormat.GetWaveFormatPCM(sampleRate, (byte)bitRate, (byte)channels)statica .

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

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

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

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

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

L'uso di un flusso push come input presuppone che i dati audio siano un PCM non elaborato e ignori le intestazioni. L'API funziona ancora in alcuni casi se l'intestazione non è stata ignorata. Per ottenere risultati ottimali, è consigliabile implementare la logica per leggere le intestazioni in modo che byte[] inizi all'inizio dei dati audio.

Gestione degli errori

Gli esempi precedenti ottengono solo il testo riconosciuto dalla result.Text proprietà . Per gestire gli errori e altre risposte, è necessario scrivere codice per gestire il risultato. Il seguente codice valuta la proprietà result.Reason e:

• Stampa il risultato del riconoscimento: ResultReason.RecognizedSpeech.
• Se non è presente alcuna corrispondenza di riconoscimento, informa l'utente: ResultReason.NoMatch.
• Se viene rilevato un errore, viene visualizzato 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 set the speech resource key and region values?");
        }
        break;
}

Usare il 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 quando arrestare 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:

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

Creare quindi un'istanza TaskCompletionSource<int> per gestire lo stato del riconoscimento vocale:

var stopRecognition = new TaskCompletionSource<int>();

Successivamente, sottoscrivere gli eventi inviati SpeechRecognizer :

• Recognizing: segnale per gli eventi che contengono risultati intermedi di riconoscimento.
• Recognized: segnale per gli eventi che contengono risultati finali del riconoscimento, 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 che contengono risultati di riconoscimento annullati. Questi risultati indicano un tentativo di riconoscimento annullato in seguito a una richiesta di annullamento diretto. In alternativa, indicano un errore di trasporto o protocollo.

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

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

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

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

    stopRecognition.TrySetResult(0);
};

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

Con tutti gli elementi configurati, chiamare StartContinuousRecognitionAsync per iniziare a riconoscere:

await speechRecognizer.StartContinuousRecognitionAsync();

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

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

Modificare la lingua di origine

Un'attività comune per il riconoscimento vocale è la specifica della lingua di input (o di origine). Nell'esempio seguente viene illustrato come modificare la lingua di input in italiano. Nel codice trovare l'istanza SpeechConfig e aggiungere questa riga direttamente sotto di essa:

speechConfig.SpeechRecognitionLanguage = "it-IT";

La proprietà SpeechRecognitionLanguage si aspetta una stringa in formato è prevista una stringa di formato lingua-impostazioni locali. Per altre informazioni, vedere l'elenco delle impostazioni locali supportate per la sintesi vocale.

Identificazione della lingua

È possibile usare l'identificazione della lingua con il riconoscimento vocale quando è necessario identificare la lingua in un'origine audio e quindi trascriverla in testo.

Per un esempio di codice completo, vedere Identificazione della lingua.

Usare un endpoint personalizzato

Con il riconoscimento vocale personalizzato, è possibile caricare dati personalizzati, testare ed eseguire il training di un modello personalizzato, confrontare l'accuratezza tra i modelli e distribuire un modello in un endpoint personalizzato. Nell'esempio seguente viene illustrato come impostare un endpoint personalizzato.

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

Eseguire e usare un contenitore

I contenitori voce forniscono API endpoint di query basate su Websocket a cui si accede tramite Speech SDK e l'interfaccia della riga di comando di Voce. Per impostazione predefinita, Speech SDK e l'interfaccia della riga di comando di Voce usano il servizio Voce pubblico. Per usare il contenitore, è necessario modificare il metodo di inizializzazione. Usare un URL host del contenitore anziché una chiave e un'area.

Per altre informazioni sui contenitori, vedere URL host in Installare ed eseguire contenitori voce con Docker.

Modificare il modo in cui viene gestito il silenzio

Se si prevede che un utente parli più velocemente o più lento del solito, i comportamenti predefiniti per il silenzio non speciale nell'audio di input potrebbero non comportare ciò che ci si aspetta. I problemi comuni relativi alla gestione del silenzio includono:

• Concatenamento rapido di molte frasi in un singolo risultato di riconoscimento, invece di suddividere le frasi in singoli risultati.
• Riconoscimento vocale lento che separa parti di una singola frase in più risultati.
• Un riconoscimento single-shot che termina troppo rapidamente durante l'attesa dell'inizio del parlato.

Questi problemi possono essere risolti impostando una delle due proprietà di timeout nell'istanza SpeechConfig usata per creare un SpeechRecognizeroggetto :

• Il timeout del silenzio di segmentazione regola la quantità di audio non speciale consentita all'interno di una frase attualmente pronunciata prima che tale frase venga considerata "eseguita".
  • I valori più elevati in genere rendono i risultati più lunghi e consentono pause più lunghe dal parlante all'interno di una frase, ma rendono i risultati più lunghi per arrivare. Possono anche combinare frasi separate in un singolo risultato quando è impostato troppo alto.
  • I valori inferiori in genere rendono i risultati più brevi e garantiscono più richieste e interruzioni frequenti tra le frasi, ma possono anche causare la separazione di singole frasi in più risultati quando sono impostati troppo bassi.
  • Questo timeout può essere impostato su valori interi compresi tra 100 e 5000, in millisecondi, con un valore predefinito tipico di 500.
• Il timeout del silenzio iniziale regola la quantità di audio non speciale consentita prima di una frase prima che il tentativo di riconoscimento termini con un risultato "nessuna corrispondenza".
  • I valori più elevati offrono agli altoparlanti più tempo per reagire e iniziare a parlare, ma possono anche comportare una velocità di risposta lenta quando non viene parlato nulla.
  • I valori inferiori garantiscono una richiesta di "nessuna corrispondenza" per un'esperienza utente più veloce e una gestione audio più controllata, ma potrebbe ridurre troppo rapidamente un altoparlante quando è impostato troppo basso.
  • Poiché il riconoscimento continuo genera molti risultati, questo valore determina la frequenza con cui arrivano i risultati "nessuna corrispondenza", ma non influisce in caso contrario sul contenuto dei risultati del riconoscimento.
  • Questo timeout può essere impostato su qualsiasi valore intero non negativo, in millisecondi o impostato su 0 per disabilitarlo completamente. 5000 è un tipico valore predefinito per il riconoscimento a colpo singolo, mentre 15000 è un tipico valore predefinito per il riconoscimento continuo.

Poiché si verificano compromessi durante la modifica di questi timeout, è consigliabile modificare le impostazioni solo quando si verifica un problema relativo alla gestione del silenzio. I valori predefiniti gestiscono in modo ottimale la maggior parte dell'audio parlato e solo gli scenari non comuni devono riscontrare problemi.

Esempio: gli utenti che parlano un numero di serie come "ABC-123-4567" potrebbero sospendere tra gruppi di caratteri abbastanza a lungo per poter suddividere il numero di serie in più risultati. In questo caso, provare un valore superiore, ad esempio 2000 ms per il timeout del silenzio della segmentazione:

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

Esempio: un discorso registrato del relatore potrebbe essere abbastanza veloce che diverse frasi in una riga vengano combinate, con risultati di riconoscimento di grandi dimensioni che arrivano una o due volte al minuto. In questo caso, impostare il timeout del silenzio di segmentazione su un valore inferiore, ad esempio 300 ms:

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

Esempio: un riconoscimento a colpo singolo che chiede a un parlante di trovare e leggere un numero di serie termina troppo rapidamente mentre viene trovato il numero. In questo caso, provare un timeout di silenzio iniziale più lungo, ad esempio 10.000 ms:

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

Pacchetto della documentazione di riferimento | (NuGet) | Esempi aggiuntivi in GitHub

In questa guida pratica si apprenderà come riconoscere e trascrivere il parlato in testo in tempo reale.

Creare una configurazione di Voce

Per chiamare il servizio Voce usando Speech SDK, è necessario creare un'istanza SpeechConfig di . Questa classe include informazioni sulla sottoscrizione, ad esempio la chiave e la posizione/area associata, l'endpoint, l'host o il token di autorizzazione.

1. Creare un'istanza SpeechConfig usando la chiave e l'area.
2. Creare una risorsa Voce nel portale di Azure. Per altre informazioni, vedere Creare una risorsa multiservizio.

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

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

È possibile inizializzare SpeechConfig in altri modi:

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

Nota

Indipendentemente dal fatto che si stia eseguendo il riconoscimento vocale, la sintesi vocale, la traduzione o il riconoscimento finalità, si crea sempre una configurazione.

Riconoscimento vocale da un microfono

Per riconoscere la voce usando il microfono del dispositivo, creare un'istanza AudioConfig usando la FromDefaultMicrophoneInput() funzione membro. Inizializzare quindi l'oggettoSpeechRecognizer passando audioConfig e config.

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

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

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

Se si vuole usare un dispositivo di input audio specifico , è necessario specificare l'ID dispositivo in AudioConfig. Per altre informazioni su come ottenere l'ID dispositivo per il dispositivo di input audio, vedere Selezionare un dispositivo di input audio con Speech SDK

Riconoscimento vocale da un file

Se si vuole riconoscere la voce da un file audio invece di usare un microfono, è comunque necessario creare un'istanza AudioConfig . Ma per questo caso non si chiama FromDefaultMicrophoneInput(). Chiamare FromWavFileInput() e passare il percorso del file:

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

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

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

Riconoscimento vocale tramite la classe Recognizer

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. Di seguito è riportato un esempio di riconoscimento asincrono a colpo singolo tramite RecognizeOnceAsync:

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

È necessario scrivere codice per gestire il risultato. Questo esempio valuta result->Reason e:

• Stampa il risultato del riconoscimento: ResultReason::RecognizedSpeech.
• Se non è presente alcuna corrispondenza di riconoscimento, informa l'utente: ResultReason::NoMatch.
• Se viene rilevato un errore, viene visualizzato 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 set the speech resource key and region values?" << 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 audioConfig = AudioConfig::FromWavFileInput("YourAudioFile.wav");
auto speechRecognizer = SpeechRecognizer::FromConfig(config, audioConfig);

Creare quindi una variabile per gestire lo stato del riconoscimento vocale. Dichiarare promise<void> perché all'inizio del riconoscimento, è possibile presupporre che non sia terminato:

promise<void> recognitionEnd;

Successivamente, sottoscrivere gli eventi inviati SpeechRecognizer :

• Recognizing: segnale per gli eventi che contengono risultati intermedi di riconoscimento.
• Recognized: segnale per gli eventi che contengono risultati finali del riconoscimento, 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 che contengono risultati di riconoscimento annullati. Questi risultati indicano un tentativo di riconoscimento annullato in seguito a una richiesta di annullamento diretto. In alternativa, indicano un errore di trasporto o protocollo.

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

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

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

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

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

Con tutti gli elementi configurati, chiamare StopContinuousRecognitionAsync per iniziare a riconoscere:

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

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

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

Modificare la lingua di origine

Un'attività comune per il riconoscimento vocale è la specifica della lingua di input (o di origine). Nell'esempio seguente viene illustrato come modificare la lingua di input in tedesco. Nel codice trovare l'istanza SpeechConfig e aggiungere questa riga direttamente sotto di essa:

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

SetSpeechRecognitionLanguage è un parametro che accetta una stringa come argomento. Per altre informazioni, vedere l'elenco delle impostazioni locali supportate per la sintesi vocale.

Identificazione della lingua

È possibile usare l'identificazione della lingua con il riconoscimento vocale quando è necessario identificare la lingua in un'origine audio e quindi trascriverla in testo.

Per un esempio di codice completo, vedere Identificazione della lingua.

Usare un endpoint personalizzato

Con il riconoscimento vocale personalizzato, è possibile caricare dati personalizzati, testare ed eseguire il training di un modello personalizzato, confrontare l'accuratezza tra i modelli e distribuire un modello in un endpoint personalizzato. Nell'esempio seguente viene illustrato come impostare un endpoint personalizzato.

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

Eseguire e usare un contenitore

I contenitori voce forniscono API endpoint di query basate su Websocket a cui si accede tramite Speech SDK e l'interfaccia della riga di comando di Voce. Per impostazione predefinita, Speech SDK e l'interfaccia della riga di comando di Voce usano il servizio Voce pubblico. Per usare il contenitore, è necessario modificare il metodo di inizializzazione. Usare un URL host del contenitore anziché una chiave e un'area.

Per altre informazioni sui contenitori, vedere URL host in Installare ed eseguire contenitori voce con Docker.

Pacchetto della documentazione di riferimento | (Go) | Esempi aggiuntivi in GitHub

In questa guida pratica si apprenderà come riconoscere e trascrivere il parlato in testo in tempo reale.

Riconoscimento vocale da un microfono

Usare l'esempio di codice seguente per eseguire il riconoscimento vocale dal microfono del dispositivo predefinito. Sostituire le variabili subscription e region rispettivamente con la chiave vocale e la posizione/area. Creare una risorsa Voce nel portale di Azure. Per altre informazioni, vedere Creare una risorsa multiservizio. L'esecuzione dello script avvia una sessione di riconoscimento 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)
	fmt.Println("Did you set the speech resource key and region values?")
}

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

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

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

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

A questo momento compilare ed eseguire il codice:

go build
go run quickstart

Per informazioni dettagliate, vedere il contenuto di riferimento per la SpeechConfig classe e il contenuto di riferimento per la SpeechRecognizer classe .

Riconoscimento vocale da un file audio

Usare l'esempio seguente per eseguire il riconoscimento vocale da un file audio. Sostituire le variabili subscription e region rispettivamente con la chiave vocale e la posizione/area. Creare una risorsa Voce nel portale di Azure. Per altre informazioni, vedere Creare una risorsa multiservizio. Sostituire inoltre la variabile file con un percorso di un file .wav . Quando si esegue lo script, riconosce la voce dal file e restituisce 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 :=  "YourSpeechKey"
    region := "YourSpeechRegion"
    file := "path/to/file.wav"

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

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

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

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

A questo momento compilare ed eseguire il codice:

go build
go run quickstart

Per informazioni dettagliate, vedere il contenuto di riferimento per la SpeechConfig classe e il contenuto di riferimento per la SpeechRecognizer classe .

Eseguire e usare un contenitore

I contenitori voce forniscono API endpoint di query basate su Websocket a cui si accede tramite Speech SDK e l'interfaccia della riga di comando di Voce. Per impostazione predefinita, Speech SDK e l'interfaccia della riga di comando di Voce usano il servizio Voce pubblico. Per usare il contenitore, è necessario modificare il metodo di inizializzazione. Usare un URL host del contenitore anziché una chiave e un'area.

Per altre informazioni sui contenitori, vedere URL host in Installare ed eseguire contenitori voce con Docker.

Documentazione di riferimento | Esempi aggiuntivi su GitHub

In questa guida pratica si apprenderà come riconoscere e trascrivere il parlato in testo in tempo reale.

Creare una configurazione di Voce

Per chiamare il servizio Voce usando Speech SDK, è necessario creare un'istanza di SpeechConfig . Questa classe include informazioni sulla sottoscrizione, ad esempio la chiave e la posizione/area associata, l'endpoint, l'host o il token di autorizzazione.

1. Creare un'istanza SpeechConfig usando la chiave e la posizione/area.
2. Creare una risorsa Voce nel portale di Azure. Per altre informazioni, vedere Creare una risorsa multiservizio.

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

È possibile inizializzare SpeechConfig in altri modi:

• Usare un endpoint e passare un endpoint del servizio Voce. La chiave e il token di autorizzazione sono facoltativi.
• Usare un host e passare un indirizzo host. La chiave e il token di autorizzazione sono facoltativi.
• Usare un token di autorizzazione con l'area o la località 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 vocale da un microfono

Per riconoscere il riconoscimento vocale usando il microfono del dispositivo, creare un'istanza AudioConfig usando il fromDefaultMicrophoneInput() metodo . Inizializzare quindi l'oggetto SpeechRecognizer passando 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 speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);

        System.out.println("Speak into your microphone.");
        Future<SpeechRecognitionResult> task = speechRecognizer.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 dispositivo in AudioConfig. Per altre informazioni su come ottenere l'ID dispositivo per il dispositivo di input audio, vedere Selezionare un dispositivo di input audio con Speech SDK.

Riconoscimento vocale da un file

Se si vuole riconoscere la voce da un file audio invece di usare un microfono, è comunque necessario creare un'istanza AudioConfig . Ma per questo caso non si chiama FromDefaultMicrophoneInput(). Chiamare fromWavFileInput() e passare il percorso del 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 speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);
        
        Future<SpeechRecognitionResult> task = speechRecognizer.recognizeOnceAsync();
        SpeechRecognitionResult result = task.get();
        System.out.println("RECOGNIZED: Text=" + result.getText());
    }
}

Gestione degli errori

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

• Stampa il risultato del riconoscimento: ResultReason.RecognizedSpeech.
• Se non è presente alcuna corrispondenza di riconoscimento, informa l'utente: ResultReason.NoMatch.
• Se viene rilevato un errore, viene visualizzato 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 set the speech resource key and region values?");
            }
        }
        break;
}

Usare il 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 quando arrestare 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 come è possibile eseguire il riconoscimento continuo in un file di input audio.

Per iniziare, definire l'input e inizializzare SpeechRecognizer:

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

Creare quindi una variabile per gestire lo stato del riconoscimento vocale. Dichiarare un'istanza Semaphore nell'ambito della classe:

private static Semaphore stopTranslationWithFileSemaphore;

Successivamente, sottoscrivere gli eventi inviati SpeechRecognizer :

• recognizing: segnale per gli eventi che contengono risultati intermedi di riconoscimento.
• recognized: segnale per gli eventi che contengono risultati finali del riconoscimento, 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 che contengono risultati di riconoscimento annullati. Questi risultati indicano un tentativo di riconoscimento annullato in seguito a una richiesta di annullamento diretto. In alternativa, indicano un errore di trasporto o protocollo.

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

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

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

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

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

    stopTranslationWithFileSemaphore.release();
});

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

Con tutti gli elementi configurati, chiamare startContinuousRecognitionAsync per iniziare a riconoscere:

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

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

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

Modificare la lingua di origine

Un'attività comune per il riconoscimento vocale è la specifica della lingua di input (o di origine). Nell'esempio seguente viene illustrato come modificare la lingua di input in francese. Nel codice trovare l'istanza SpeechConfig e aggiungere questa riga direttamente sotto di essa:

config.setSpeechRecognitionLanguage("fr-FR");

setSpeechRecognitionLanguage è un parametro che accetta una stringa come argomento. Fare riferimento all'elenco delle impostazioni locali supportate per il riconoscimento vocale.

Identificazione della lingua

È possibile usare l'identificazione della lingua con il riconoscimento vocale quando è necessario identificare la lingua in un'origine audio e quindi trascriverla in testo.

Per un esempio di codice completo, vedere Identificazione della lingua.

Usare un endpoint personalizzato

Con il riconoscimento vocale personalizzato, è possibile caricare dati personalizzati, testare ed eseguire il training di un modello personalizzato, confrontare l'accuratezza tra i modelli e distribuire un modello in un endpoint personalizzato. L'esempio seguente illustra come impostare un endpoint personalizzato:

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

Eseguire e usare un contenitore

I contenitori voce forniscono API endpoint di query basate su Websocket a cui si accede tramite Speech SDK e l'interfaccia della riga di comando di Voce. Per impostazione predefinita, Speech SDK e l'interfaccia della riga di comando di Voce usano il servizio Voce pubblico. Per usare il contenitore, è necessario modificare il metodo di inizializzazione. Usare un URL host del contenitore anziché una chiave e un'area.

Per altre informazioni sui contenitori, vedere URL host in Installare ed eseguire contenitori voce con Docker.

Pacchetto della documentazione di riferimento | (npm) | Esempi aggiuntivi nel codice sorgente della libreria GitHub |

In questa guida pratica si apprenderà come riconoscere e trascrivere il parlato in testo in tempo reale.

Creare una configurazione di Voce

Per chiamare il servizio Voce usando Speech SDK, è necessario creare un'istanza SpeechConfig di . Questa classe include informazioni sulla sottoscrizione, ad esempio la chiave e la posizione/area associata, l'endpoint, l'host o il token di autorizzazione.

1. Creare un'istanza SpeechConfig usando la chiave e la posizione/area.
2. Creare una risorsa Voce nel portale di Azure. Per altre informazioni, vedere Creare una risorsa multiservizio.

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

È possibile inizializzare SpeechConfig in altri modi:

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

Nota

Indipendentemente dal fatto che si stia eseguendo il riconoscimento vocale, la sintesi vocale, la traduzione o il riconoscimento finalità, si crea sempre una configurazione.

Riconoscimento vocale da un microfono

Il riconoscimento vocale da un microfono non è supportato in Node.js. È supportato solo in un ambiente JavaScript basato su browser. Per altre informazioni, vedere l'esempio React e l'implementazione del riconoscimento vocale da un microfono in GitHub. L'esempio React mostra i modelli di progettazione per lo scambio e la gestione dei token di autenticazione. Mostra anche l'acquisizione dell'audio da un microfono o da un file per le conversioni vocali in testo.

Nota

Se vuoi usare un dispositivo di input audio specifico , devi specificare l'ID dispositivo nell'oggetto AudioConfig . Per altre informazioni, vedere Selezionare un dispositivo di input audio con Speech SDK.

Riconoscimento vocale da un file

Per riconoscere la voce da un file audio, creare un'istanza AudioConfig usando il fromWavFileInput() metodo , che accetta un Buffer oggetto . Inizializzare SpeechRecognizer quindi passando audioConfig e speechConfig.

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

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

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

Riconoscimento vocale da un flusso in memoria

Per molti casi d'uso, è probabile che i dati audio provenga da Archiviazione BLOB di Azure. Oppure è già in memoria come struttura ArrayBuffer di dati non elaborata o simile. Il codice seguente:

• Crea un flusso push usando createPushStream().
• Legge un file .wav usando fs.createReadStream a scopo dimostrativo. Se si dispone già di dati audio in ArrayBuffer, è possibile passare direttamente alla scrittura del contenuto nel flusso di 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("YourSpeechKey", "YourSpeechRegion");

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

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

L'uso di un flusso push come input presuppone che i dati audio siano dati pcm (pulse-code modulation) non elaborati che ignorano le intestazioni. L'API funziona ancora in alcuni casi se l'intestazione non è stata ignorata. Per ottenere risultati ottimali, è consigliabile implementare la logica per leggere le intestazioni in modo che fs inizi all'inizio dei dati audio.

Gestione degli errori

Gli esempi precedenti ottengono solo il testo riconosciuto dalla result.text proprietà . Per gestire gli errori e altre risposte, è necessario scrivere codice per gestire il risultato. Il seguente codice valuta la proprietà result.reason e:

• Stampa il risultato del riconoscimento: ResultReason.RecognizedSpeech.
• Se non è presente alcuna corrispondenza di riconoscimento, informa l'utente: ResultReason.NoMatch.
• Se viene rilevato un errore, viene visualizzato 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 = sdk.CancellationDetails.fromResult(result);
        console.log(`CANCELED: Reason=${cancellation.reason}`);

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

Usare il 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, è possibile usare il riconoscimento continuo quando si vuole controllare quando arrestare 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:

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

Sottoscrivere quindi gli eventi inviati da SpeechRecognizer:

• recognizing: segnale per gli eventi che contengono risultati intermedi di riconoscimento.
• recognized: segnale per gli eventi che contengono risultati finali del riconoscimento, 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 che contengono risultati di riconoscimento annullati. Questi risultati indicano un tentativo di riconoscimento annullato in seguito a una richiesta di annullamento diretto. In alternativa, indicano un errore di trasporto o protocollo.

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

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

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

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

    speechRecognizer.stopContinuousRecognitionAsync();
};

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

Con tutti gli elementi configurati, chiamare startContinuousRecognitionAsync per iniziare a riconoscere:

speechRecognizer.startContinuousRecognitionAsync();

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

Modificare la lingua di origine

Un'attività comune per il riconoscimento vocale è la specifica della lingua di input (o di origine). Nell'esempio seguente viene illustrato come modificare la lingua di input in italiano. Nel codice trovare l'istanza SpeechConfig e aggiungere questa riga direttamente sotto di essa:

speechConfig.speechRecognitionLanguage = "it-IT";

La proprietà speechRecognitionLanguage si aspetta una stringa in formato è prevista una stringa di formato lingua-impostazioni locali. Per altre informazioni, vedere l'elenco delle impostazioni locali supportate per la sintesi vocale.

Identificazione della lingua

È possibile usare l'identificazione della lingua con il riconoscimento vocale quando è necessario identificare la lingua in un'origine audio e quindi trascriverla in testo.

Per un esempio di codice completo, vedere Identificazione della lingua.

Usare un endpoint personalizzato

Con il riconoscimento vocale personalizzato, è possibile caricare dati personalizzati, testare ed eseguire il training di un modello personalizzato, confrontare l'accuratezza tra i modelli e distribuire un modello in un endpoint personalizzato. Nell'esempio seguente viene illustrato come impostare un endpoint personalizzato.

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

Eseguire e usare un contenitore

I contenitori voce forniscono API endpoint di query basate su Websocket a cui si accede tramite Speech SDK e l'interfaccia della riga di comando di Voce. Per impostazione predefinita, Speech SDK e l'interfaccia della riga di comando di Voce usano il servizio Voce pubblico. Per usare il contenitore, è necessario modificare il metodo di inizializzazione. Usare un URL host del contenitore anziché una chiave e un'area.

Per altre informazioni sui contenitori, vedere URL host in Installare ed eseguire contenitori voce con Docker.

Pacchetto della documentazione di riferimento | (download) | Esempi aggiuntivi in GitHub

In questa guida pratica si apprenderà come riconoscere e trascrivere il parlato in testo in tempo reale.

Installare Speech SDK e gli esempi

Il repository Azure-Samples/cognitive-services-speech-sdk contiene esempi scritti in Objective-C per iOS e Mac. Selezionare un collegamento per visualizzare le istruzioni di installazione per ogni esempio:

• Riconoscimento vocale da un microfono in Objective-C in macOS
• Riconoscimento vocale in Objective-C in iOS
• Altri esempi per Objective-C in iOS

Per altre informazioni, vedere Le informazioni di riferimento su Speech SDK per Objective-C.

Usare un endpoint personalizzato

Con il riconoscimento vocale personalizzato, è possibile caricare dati personalizzati, testare ed eseguire il training di un modello personalizzato, confrontare l'accuratezza tra i modelli e distribuire un modello in un endpoint personalizzato. L'esempio seguente illustra come impostare un endpoint personalizzato:

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

Eseguire e usare un contenitore

I contenitori voce forniscono API endpoint di query basate su Websocket a cui si accede tramite Speech SDK e l'interfaccia della riga di comando di Voce. Per impostazione predefinita, Speech SDK e l'interfaccia della riga di comando di Voce usano il servizio Voce pubblico. Per usare il contenitore, è necessario modificare il metodo di inizializzazione. Usare un URL host del contenitore anziché una chiave e un'area.

Per altre informazioni sui contenitori, vedere URL host in Installare ed eseguire contenitori voce con Docker.

Pacchetto della documentazione di riferimento | (download) | Esempi aggiuntivi in GitHub

In questa guida pratica si apprenderà come riconoscere e trascrivere il parlato in testo in tempo reale.

Installare Speech SDK e gli esempi

Il repository Azure-Samples/cognitive-services-speech-sdk contiene esempi scritti in Swift per iOS e Mac. Selezionare un collegamento per visualizzare le istruzioni di installazione per ogni esempio:

• Riconoscimento vocale in Swift in macOS
• Riconoscimento vocale in Swift in iOS

Per altre informazioni, vedere le informazioni di riferimento su Speech SDK per Swift.

Usare un endpoint personalizzato

Con il riconoscimento vocale personalizzato, è possibile caricare dati personalizzati, testare ed eseguire il training di un modello personalizzato, confrontare l'accuratezza tra i modelli e distribuire un modello in un endpoint personalizzato. L'esempio seguente illustra come impostare un endpoint personalizzato:

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

Eseguire e usare un contenitore

I contenitori voce forniscono API endpoint di query basate su Websocket a cui si accede tramite Speech SDK e l'interfaccia della riga di comando di Voce. Per impostazione predefinita, Speech SDK e l'interfaccia della riga di comando di Voce usano il servizio Voce pubblico. Per usare il contenitore, è necessario modificare il metodo di inizializzazione. Usare un URL host del contenitore anziché una chiave e un'area.

Per altre informazioni sui contenitori, vedere URL host in Installare ed eseguire contenitori voce con Docker.

Pacchetto della documentazione di riferimento | (PyPi) | Esempi aggiuntivi in GitHub

In questa guida pratica si apprenderà come riconoscere e trascrivere il parlato in testo in tempo reale.

Creare una configurazione di Voce

Per chiamare il servizio Voce usando Speech SDK, è necessario creare un'istanza SpeechConfig di . Questa classe include informazioni sulla sottoscrizione, ad esempio la chiave vocale e la posizione/area associata, l'endpoint, l'host o il token di autorizzazione.

1. Creare un'istanza SpeechConfig usando la chiave vocale e la posizione/area.
2. Creare una risorsa Voce nel portale di Azure. Per altre informazioni, vedere Creare una risorsa multiservizio.

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

È possibile inizializzare SpeechConfig in altri modi:

• Usare un endpoint e passare un endpoint del servizio Voce. Un token di riconoscimento vocale o di autorizzazione è facoltativo.
• Usare un host e passare un indirizzo host. Un token di riconoscimento vocale o di autorizzazione è facoltativo.
• Usare un token di autorizzazione con l'area o la località associata.

Nota

Indipendentemente dal fatto che si stia eseguendo il riconoscimento vocale, la sintesi vocale, la traduzione o il riconoscimento finalità, si crea sempre una configurazione.

Riconoscimento vocale da un microfono

Per riconoscere il riconoscimento vocale usando il microfono del dispositivo, creare un'istanza SpeechRecognizer senza passare AudioConfige quindi passare speech_config:

import azure.cognitiveservices.speech as speechsdk

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

    print("Speak into your microphone.")
    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 dispositivo in AudioConfige passarlo al SpeechRecognizer parametro del audio_config costruttore. Per altre informazioni su come ottenere l'ID dispositivo per il dispositivo di input audio, vedere Selezionare un dispositivo di input audio con Speech SDK

Riconoscimento vocale da un file

Se si vuole riconoscere la voce da un file audio anziché usare un microfono, creare un'istanza AudioConfig e usare il filename parametro :

import azure.cognitiveservices.speech as speechsdk

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

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

from_file()

Gestione degli errori

Gli esempi precedenti ottengono solo il testo riconosciuto dalla result.text proprietà . Per gestire gli errori e altre risposte, è necessario scrivere codice per gestire il risultato. Il seguente codice valuta la proprietà result.reason e:

• Stampa il risultato del riconoscimento: speechsdk.ResultReason.RecognizedSpeech.
• Se non è presente alcuna corrispondenza di riconoscimento, informa l'utente: speechsdk.ResultReason.NoMatch.
• Se viene rilevato un errore, viene visualizzato 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))
        print("Did you set the speech resource key and region values?")

Usare il 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 quando arrestare il riconoscimento. Richiede la connessione per EventSignal ottenere i risultati del riconoscimento. Per interrompere il riconoscimento, è necessario chiamare 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)

Creare quindi una variabile per gestire lo stato del riconoscimento vocale. Impostare la variabile su False perché all'inizio del riconoscimento, è possibile presupporre che non venga completata:

done = False

Creare ora un callback per arrestare il riconoscimento continuo quando evt viene ricevuto. Tieni in considerazione i seguenti punti:

• Quando evt viene ricevuto, il evt messaggio viene stampato.
• Dopo evt la ricezione, viene chiamato 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

Nell'esempio di codice seguente viene illustrato come connettere i callback agli eventi inviati da SpeechRecognizer. Gli eventi sono:

• recognizing: segnale per gli eventi che contengono risultati intermedi di riconoscimento.
• recognized: segnale per gli eventi che contengono risultati finali del riconoscimento, 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 che contengono risultati di riconoscimento annullati. Questi risultati indicano un tentativo di riconoscimento annullato in seguito a una richiesta di annullamento diretto. In alternativa, indicano un errore di trasporto o 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 tutti gli elementi configurati, è possibile chiamare start_continuous_recognition():

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

Modificare la lingua di origine

Un'attività comune per il riconoscimento vocale è la specifica della lingua di input (o di origine). Nell'esempio seguente viene illustrato come modificare la lingua di input in tedesco. Nel codice trovare l'istanza SpeechConfig e aggiungere questa riga direttamente sotto di essa:

speech_config.speech_recognition_language="de-DE"

speech_recognition_language è un parametro che accetta una stringa come argomento. Per altre informazioni, vedere l'elenco delle impostazioni locali supportate per la sintesi vocale.

Identificazione della lingua

È possibile usare l'identificazione della lingua con riconoscimento vocale quando è necessario identificare la lingua in un'origine audio e quindi trascriverla in testo.

Per un esempio di codice completo, vedere Identificazione della lingua.

Usare un endpoint personalizzato

Con il riconoscimento vocale personalizzato, è possibile caricare dati personalizzati, testare ed eseguire il training di un modello personalizzato, confrontare l'accuratezza tra i modelli e distribuire un modello in un endpoint personalizzato. Nell'esempio seguente viene illustrato come impostare un endpoint personalizzato.

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

Eseguire e usare un contenitore

I contenitori voce forniscono API endpoint di query basate su Websocket a cui si accede tramite Speech SDK e l'interfaccia della riga di comando di Voce. Per impostazione predefinita, Speech SDK e l'interfaccia della riga di comando di Voce usano il servizio Voce pubblico. Per usare il contenitore, è necessario modificare il metodo di inizializzazione. Usare un URL host del contenitore anziché una chiave e un'area.

Per altre informazioni sui contenitori, vedere URL host in Installare ed eseguire contenitori voce con Docker.

Informazioni di riferimento | sull'API REST Riconoscimento vocale in testo per brevi riferimenti | audio Esempi aggiuntivi in GitHub

In questa guida pratica si apprenderà come riconoscere e trascrivere il parlato in testo in tempo reale.

Convertire il parlato in testo

Al prompt dei comandi, eseguire questo comando. Inserire i valori seguenti nel comando :

• Chiave di sottoscrizione per il servizio Voce.
• L'area del servizio Voce.
• Percorso dei file audio di input. È possibile generare file audio usando il testo per 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'

Si dovrebbe ricevere una risposta con un corpo JSON simile all'esempio seguente:

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

Per altre informazioni, vedere Le informazioni di riferimento sull'API REST Riconoscimento vocale.

In questa guida pratica si apprenderà come riconoscere e trascrivere il parlato in testo in tempo reale.

Riconoscimento vocale da un microfono

Collegare e accendere il microfono del PC. Disattiva tutte le app che potrebbero anche usare il microfono. Alcuni computer hanno un microfono predefinito, 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. Poi eseguire quindi 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 voce alla tabella di testo. Ad esempio, aggiungere --source de-DE per il riconoscimento vocale in tedesco.

Parla al microfono e puoi vedere la trascrizione delle tue parole in testo in tempo reale. L'interfaccia della riga di comando di Voce si arresta dopo un periodo di silenzio o quando si seleziona CTRL+C.

Riconoscimento vocale da un file

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 qualsiasi file .wav (16 KHz o 8 KHz, 16 bit e mono PCM) che contiene la voce in 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.

Usare il comando seguente per eseguire l'interfaccia della riga di comando di Voce per riconoscere la voce presente nel file audio:

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 voce alla tabella di testo. Ad esempio, aggiungere --source de-DE per il riconoscimento vocale in tedesco.

L'interfaccia della riga di comando di Voce mostra una trascrizione del testo del riconoscimento vocale sullo schermo.

Eseguire e usare un contenitore

I contenitori voce forniscono API endpoint di query basate su Websocket a cui si accede tramite Speech SDK e l'interfaccia della riga di comando di Voce. Per impostazione predefinita, Speech SDK e l'interfaccia della riga di comando di Voce usano il servizio Voce pubblico. Per usare il contenitore, è necessario modificare il metodo di inizializzazione. Usare un URL host del contenitore anziché una chiave e un'area.

Per altre informazioni sui contenitori, vedere URL host in Installare ed eseguire contenitori voce con Docker.

Passaggi successivi

• Provare la guida introduttiva al riconoscimento vocale
• Migliorare l'accuratezza del riconoscimento con il riconoscimento vocale personalizzato
• Usare la trascrizione batch