Come riconoscere il parlato

API REST di riconoscimento vocale | API REST per il riconoscimento vocale di brevi audio | Esempi aggiuntivi su GitHub

In questa guida pratica si apprenderà come usare Azure Voce in Foundry Tools per la conversione del riconoscimento vocale in tempo reale in testo. Il riconoscimento vocale in tempo reale è ideale per le applicazioni che richiedono trascrizioni immediate, ad esempio dettatura, assistenza del call center e didascalia per le riunioni live.

Per informazioni su come configurare l'ambiente per un'applicazione di esempio, vedere Avvio rapido: Riconoscere e convertire la voce in testo.

Convertire la voce in testo

Al prompt dei comandi eseguire il comando seguente. Inserire i valori seguenti nel comando :

• La chiave API della risorsa Speech
• Regione del servizio Speech
• Percorso del file audio di input

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 riceverà una risposta simile all'esempio seguente:

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

Per ulteriori informazioni, vedere il riferimento all'API REST Da voce a testo.

documentazione di Reference | Package (PyPi) | Esempi aggiuntivi in GitHub

In questa guida pratica si apprenderà come usare Azure Voce in Foundry Tools per la conversione del riconoscimento vocale in tempo reale in testo. Il riconoscimento vocale in tempo reale è ideale per le applicazioni che richiedono trascrizioni immediate, ad esempio dettatura, assistenza del call center e didascalia per le riunioni live.

Per informazioni su come configurare l'ambiente per un'applicazione di esempio, vedere Avvio rapido: Riconoscere e convertire la voce in testo.

Creare un'istanza di configurazione del riconoscimento vocale

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

1. Creare una risorsa Foundry per Sintesi vocale nel portale Azure. Ottieni la chiave della risorsa di riconoscimento vocale e la regione.
2. Creare un'istanza SpeechConfig usando il codice seguente. Sostituire YourSpeechKey e YourSpeechRegion con la chiave della risorsa di riconoscimento vocale e la regione.

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

È possibile inizializzare SpeechConfig in altri modi:

• Usare un endpoint e specificare un endpoint del servizio di riconoscimento vocale. Un token di riconoscimento vocale o di autorizzazione è facoltativo.
• Usare un host e fornire un indirizzo dell'host. Un token di riconoscimento vocale o di autorizzazione è facoltativo.
• Usare un token di autorizzazione con la regione o la località associata.

Riconoscere discorsi 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.")
    speech_recognition_result = speech_recognizer.recognize_once_async().get()
    print(speech_recognition_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 informazioni su come ottenere l'ID dispositivo, vedere Selezionare un dispositivo di input audio con Speech SDK.

Riconoscere il parlato 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)

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

from_file()

Gestire gli errori

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

• Stampa il risultato del riconoscimento: speechsdk.ResultReason.RecognizedSpeech.
• Se non viene trovata 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 speech_recognition_result.reason == speechsdk.ResultReason.RecognizedSpeech:
    print("Recognized: {}".format(speech_recognition_result.text))
elif speech_recognition_result.reason == speechsdk.ResultReason.NoMatch:
    print("No speech could be recognized: {}".format(speech_recognition_result.no_match_details))
elif speech_recognition_result.reason == speechsdk.ResultReason.Canceled:
    cancellation_details = speech_recognition_result.cancellation_details
    print("Speech Recognition canceled: {}".format(cancellation_details.reason))
    if cancellation_details.reason == speechsdk.CancellationReason.Error:
        print("Error details: {}".format(cancellation_details.error_details))
        print("Did you set the speech resource key and region values?")

Usare il riconoscimento continuo

Gli esempi precedenti usano il riconoscimento single-shot, che riconosce una singola espressione. La fine di una singola espressione è determinata dall'ascolto del silenzio alla fine o fino a quando non viene elaborato un massimo di 15 secondi di audio.

Al contrario, si usa il riconoscimento continuo quando si vuole controllare quando arrestare il riconoscimento. Richiede la connessione a EventSignal per ottenere i risultati del riconoscimento. Per interrompere il riconoscimento, è necessario chiamare stop_continuous_recognition() o stop_continuous_recognition_async(). Ecco un esempio di come viene eseguito il riconoscimento continuo in 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. Tenere presenti questi 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 di riconoscimento viene modificato in True.

def stop_cb(evt):
    print('CLOSING on {}'.format(evt))
    speech_recognizer.stop_continuous_recognition()
    global 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 tutto ciò che è configurato, è 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 specifica la 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 un elenco delle impostazioni locali supportate, vedere Lingua e supporto vocale per il servizio Voce.

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="YourSpeechResoureKey", region="YourServiceRegion")
speech_config.endpoint_id = "YourEndpointId"
speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config)

Eseguire e usare un contenitore

I contenitori del riconoscimento vocale forniscono API di endpoint di query basato su websocket a cui si accede tramite Speech SDK e Speech CLI. 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.

Segmentazione semantica

La segmentazione semantica è una strategia di segmentazione del riconoscimento vocale progettata per attenuare i problemi associati alla segmentazione basata sul silenzio:

• Under-segmentation: quando gli utenti parlano per molto tempo senza pause, possono vedere una lunga sequenza di testo senza interruzioni ("muro di testo"), che degrada gravemente l'esperienza di leggibilità.
• Over-segmentation: quando un utente fa una pausa per un breve periodo di tempo, il meccanismo di rilevamento del silenzio può segmentare erroneamente.

Invece di basarsi solo sui timeout del silenzio, la segmentazione semantica principalmente segmenta e restituisce i risultati finali quando rileva la punteggiatura finale della frase, ad esempio '.' o '?'. Ciò migliora l'esperienza utente con segmenti di qualità superiore, semanticamente completi e impedisce risultati intermedi lunghi.

Per usare la segmentazione semantica, è necessario impostare la proprietà seguente nell'istanza SpeechConfig usata per creare un oggetto SpeechRecognizer:

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

Di seguito sono riportate alcune limitazioni della segmentazione semantica:

• Per usare la segmentazione semantica, è necessario Speech SDK versione 1.41 o successiva.
• La segmentazione semantica è destinata solo all'uso nel riconoscimento continuo. Sono inclusi scenari come dettatura e sottotitoli. Non deve essere usato in modalità di riconoscimento singolo o in scenari interattivi.
• La segmentazione semantica non è disponibile per tutte le lingue e le impostazioni locali.
• La segmentazione semantica non supporta ancora i punteggi di attendibilità e gli elenchi NBest. Di conseguenza, non è consigliabile la segmentazione semantica se si usano punteggi di attendibilità o elenchi N-Best.

Perfezionamento post-flusso (anteprima)

Il perfezionamento del flusso posteriore migliora l'accuratezza della trascrizione finale eseguendo un secondo passaggio di riconoscimento in parallelo allo streaming in tempo reale. I risultati intermedi e parziali rimangono a bassa latenza. Solo il risultato finale viene sostituito con una versione più accurata che usa un contesto audio più ampio.

Per abilitare il perfezionamento post-flusso, impostare la proprietà SpeechServiceResponse_PostProcessingOption sull'istanza SpeechConfig.

speechConfig->SetProperty(PropertyId::SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speechConfig.SetProperty(PropertyId.SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speechConfig.setProperty(PropertyId.SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speech_config.set_property(
    speechsdk.PropertyId.SpeechServiceResponse_PostProcessingOption,
    "PostRefinement"
)

Alcune considerazioni importanti per il perfezionamento successivo alla trasmissione:

• Il raffinamento post-elaborazione funziona meglio per frasi più lunghe, come conversazioni, riunioni e dettatura. Per frasi molto brevi, il risultato raffinato potrebbe essere identico al risultato standard.
• Il perfezionamento post-flusso e la segmentazione semantica non possono essere usati insieme.
• La rifinitura post-flusso e TrueText sono valori separati della stessa proprietà SpeechServiceResponse_PostProcessingOption. È possibile impostare un solo valore alla volta.
• Il raffinamento post-stream è disponibile solo in selezionate aree di Azure durante l'anteprima pubblica.

Per altre informazioni sulle opzioni di post-elaborazione, vedere Come usare la post-elaborazione.

documentazione di Reference | Package (NuGet) | Esempi aggiuntivi in GitHub

In questa guida pratica si apprenderà come usare Azure Voce in Foundry Tools per la conversione del riconoscimento vocale in tempo reale in testo. Il riconoscimento vocale in tempo reale è ideale per le applicazioni che richiedono trascrizioni immediate, ad esempio dettatura, assistenza del call center e didascalia per le riunioni live.

Per informazioni su come configurare l'ambiente per un'applicazione di esempio, vedere Avvio rapido: Riconoscere e convertire la voce in testo.

Creare un'istanza di configurazione del riconoscimento vocale

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

1. Creare una risorsa Foundry per Sintesi vocale nel portale Azure. Ottenere la chiave e l'endpoint della risorsa Speech.
2. Creare un'istanza SpeechConfig usando il codice seguente. Sostituire YourSpeechKey e YourSpeechEndpoint con la chiave di risorsa e l'endpoint della risorsa Voce.

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.FromEndpoint(new Uri("YourSpeechEndpoint"), "YourSpeechKey");
    }
}

È possibile inizializzare SpeechConfig in altri modi:

• Usare un endpoint e specificare un endpoint del servizio di riconoscimento vocale. Una chiave o un token di autorizzazione è facoltativo.
• Usare un host e fornire un indirizzo dell'host. Una chiave o un token di autorizzazione è facoltativo.
• Usare un token di autorizzazione con la regione o la località associata.

Riconoscere discorsi da un microfono

Per riconoscere la voce usando il microfono del dispositivo, creare un'istanza di AudioConfig usando il metodo FromDefaultMicrophoneInput(). 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 speechRecognitionResult = await speechRecognizer.RecognizeOnceAsync();
        Console.WriteLine($"RECOGNIZED: Text={speechRecognitionResult.Text}");
    }

    async static Task Main(string[] args)
    {
        var speechConfig = SpeechConfig.FromEndpoint(new Uri("YourSpeechEndpoint"), "YourSpeechKey");
        await FromMic(speechConfig);
    }
}

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

Riconoscere il parlato da un file

Se si vuole riconoscere la voce da un file audio anziché da un microfono, è comunque necessario creare un'istanza AudioConfig . Tuttavia, non si chiama FromDefaultMicrophoneInput(). Chiama FromWavFileInput() e passa 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 speechRecognitionResult = await speechRecognizer.RecognizeOnceAsync();
        Console.WriteLine($"RECOGNIZED: Text={speechRecognitionResult.Text}");
    }

    async static Task Main(string[] args)
    {
        var speechConfig = SpeechConfig.FromEndpoint(new Uri("YourSpeechEndpoint"), "YourSpeechKey");
        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 istanza di byte[] 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 in PushAudioInputStream utilizzando la funzione Write(), che accetta un'istanza di byte[].
• 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 è dati PCM (pulse-code modulation) a 16 bit, 16 kHz, mono. 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 speechRecognitionResult = await speechRecognizer.RecognizeOnceAsync();
        Console.WriteLine($"RECOGNIZED: Text={speechRecognitionResult.Text}");
    }

    async static Task Main(string[] args)
    {
        var speechConfig = SpeechConfig.FromEndpoint(new Uri("YourSpeechEndpoint"), "YourSpeechKey");
        await FromStream(speechConfig);
    }
}

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

Gestire gli errori

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

• Stampa il risultato del riconoscimento: ResultReason.RecognizedSpeech.
• Se non viene trovata alcuna corrispondenza di riconoscimento, informa l'utente: ResultReason.NoMatch.
• Se viene rilevato un errore, viene visualizzato il messaggio di errore: ResultReason.Canceled.

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

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

Usare il riconoscimento continuo

Gli esempi precedenti usano il riconoscimento single-shot, che riconosce una singola espressione. La fine di una singola espressione è determinata dall'ascolto del silenzio alla fine o fino a quando non viene elaborato un massimo di 15 secondi di audio.

Al contrario, si usa il riconoscimento continuo quando si vuole controllare quando arrestare il riconoscimento. Richiede di sottoscrivere agli eventi Recognizing, Recognized e Canceled per ottenere i risultati del riconoscimento. Per arrestare il riconoscimento, è necessario chiamare StopContinuousRecognitionAsync. Ecco un esempio di come viene eseguito il riconoscimento continuo in 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 che SpeechRecognizer invia.

• 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 endpoint 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 specifica la 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 SpeechRecognitionLanguage proprietà prevede una stringa di formato delle impostazioni locali della lingua. Per un elenco delle impostazioni locali supportate, vedere Lingua e supporto vocale per il servizio Voce.

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.FromEndpoint(new Uri("YourSpeechEndpoint"), "YourSpeechKey");
speechConfig.EndpointId = "YourEndpointId";
var speechRecognizer = new SpeechRecognizer(speechConfig);

Eseguire e usare un contenitore

I contenitori del riconoscimento vocale forniscono API di endpoint di query basato su websocket a cui si accede tramite Speech SDK e Speech CLI. 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 un utente parla più velocemente o più lentamente del solito, i comportamenti predefiniti per il silenzio non verbale nell'audio di input potrebbero non produrre il risultato atteso. I problemi comuni relativi alla gestione del silenzio includono:

• Riconoscimento rapido che collega molte frasi in un unico risultato di riconoscimento, invece di dividerle in risultati individuali.
• Il rallentamento del parlato che suddivide le parti di una singola frase in risultati multipli distinti.
• Un riconoscimento a colpo singolo che termina troppo rapidamente mentre si attende l'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 parlato consentita all'interno di una frase attualmente pronunciata, prima che tale frase venga considerata "completata."
  • 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 interruzioni più immediate e frequenti tra le frasi, ma possono anche causare la separazione di singole frasi in risultati multipli 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 vocale consentita prima di una frase affinché il tentativo di riconoscimento non termini con un risultato di "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.
  • Valori più bassi garantiscono un messaggio di "nessuna corrispondenza" per un'esperienza utente più veloce e una gestione audio più controllata, ma potrebbero interrompere troppo rapidamente un altoparlante quando sono impostati troppo bassi.
  • 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é esistono compromessi durante la modifica di questi timeout, è consigliabile modificare le impostazioni solo quando si verifica un problema correlato 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 di un numero di serie come "ABC-123-4567" potrebbero sospendere tra gruppi di caratteri un tempo sufficiente per suddividere il numero di serie in più risultati. In questo caso, provare un valore superiore come 2000 millisecondi per il timeout del silenzio di segmentazione:

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

Esempio: Il discorso di un relatore registrato potrebbe essere abbastanza veloce da far sì che diverse frasi consecutive vengano combinate, con risultati di riconoscimento corposi che possono arrivare solo 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 single-shot che chiede a un interlocutore di trovare e leggere un numero di serie termina troppo rapidamente mentre si cerca di trovare il numero. In questo caso, provare un timeout di silenzio iniziale più lungo, ad esempio 10.000 ms:

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

Segmentazione semantica

La segmentazione semantica è una strategia di segmentazione del riconoscimento vocale progettata per attenuare i problemi associati alla segmentazione basata sul silenzio:

• Under-segmentation: quando gli utenti parlano per molto tempo senza pause, possono vedere una lunga sequenza di testo senza interruzioni ("muro di testo"), che degrada gravemente l'esperienza di leggibilità.
• Over-segmentation: quando un utente fa una pausa per un breve periodo di tempo, il meccanismo di rilevamento del silenzio può segmentare erroneamente.

Invece di basarsi solo sui timeout del silenzio, la segmentazione semantica principalmente segmenta e restituisce i risultati finali quando rileva la punteggiatura finale della frase, ad esempio '.' o '?'. Ciò migliora l'esperienza utente con segmenti di qualità superiore, semanticamente completi e impedisce risultati intermedi lunghi.

Per usare la segmentazione semantica, è necessario impostare la proprietà seguente nell'istanza SpeechConfig usata per creare un oggetto SpeechRecognizer:

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

Di seguito sono riportate alcune limitazioni della segmentazione semantica:

• Per usare la segmentazione semantica, è necessario Speech SDK versione 1.41 o successiva.
• La segmentazione semantica è destinata solo all'uso nel riconoscimento continuo. Sono inclusi scenari come dettatura e sottotitoli. Non deve essere usato in modalità di riconoscimento singolo o in scenari interattivi.
• La segmentazione semantica non è disponibile per tutte le lingue e le impostazioni locali.
• La segmentazione semantica non supporta ancora i punteggi di attendibilità e gli elenchi NBest. Di conseguenza, non è consigliabile la segmentazione semantica se si usano punteggi di attendibilità o elenchi N-Best.

Perfezionamento post-stream (anteprima)

Il perfezionamento del flusso posteriore migliora l'accuratezza della trascrizione finale eseguendo un secondo passaggio di riconoscimento in parallelo allo streaming in tempo reale. I risultati intermedi e parziali rimangono a bassa latenza. Solo il risultato finale viene sostituito con una versione più accurata che usa un contesto audio più ampio.

Per abilitare il perfezionamento post-flusso, impostare la proprietà SpeechServiceResponse_PostProcessingOption sull'istanza SpeechConfig.

speechConfig->SetProperty(PropertyId::SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speechConfig.SetProperty(PropertyId.SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speechConfig.setProperty(PropertyId.SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speech_config.set_property(
    speechsdk.PropertyId.SpeechServiceResponse_PostProcessingOption,
    "PostRefinement"
)

Alcune considerazioni importanti per il perfezionamento successivo alla trasmissione:

• Il raffinamento post-elaborazione funziona meglio per frasi più lunghe, come conversazioni, riunioni e dettatura. Per frasi molto brevi, il risultato raffinato potrebbe essere identico al risultato standard.
• Il perfezionamento post-flusso e la segmentazione semantica non possono essere usati insieme.
• La rifinitura post-flusso e TrueText sono valori separati della stessa proprietà SpeechServiceResponse_PostProcessingOption. È possibile impostare un solo valore alla volta.
• Il raffinamento post-stream è disponibile solo in selezionate aree di Azure durante l'anteprima pubblica.

Per altre informazioni sulle opzioni di post-elaborazione, vedere Come usare la post-elaborazione.

Documentazione di riferimento | Pacchetto (npm) | Esempi aggiuntivi su GitHub | Codice sorgente della libreria

In questa guida pratica si apprenderà come usare Azure Voce in Foundry Tools per la conversione del riconoscimento vocale in tempo reale in testo. Il riconoscimento vocale in tempo reale è ideale per le applicazioni che richiedono trascrizioni immediate, ad esempio dettatura, assistenza del call center e didascalia per le riunioni live.

Per informazioni su come configurare l'ambiente per un'applicazione di esempio, vedere Avvio rapido: Riconoscere e convertire la voce in testo.

Creare un'istanza di configurazione del riconoscimento vocale

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

1. Creare una risorsa Foundry per Sintesi vocale nel portale Azure. Ottenere la chiave e l'endpoint della risorsa Speech.
2. Creare un'istanza SpeechConfig usando il codice seguente. Sostituire YourSpeechEndpoint e YourSpeechKey con l'endpoint e la chiave della risorsa Speech.

const speechConfig = sdk.SpeechConfig.fromEndpoint(new URL("YourSpeechEndpoint"), "YourSpeechKey");

È possibile inizializzare SpeechConfig in altri modi:

• Usare un endpoint e specificare un endpoint del servizio di riconoscimento vocale. Una chiave o un token di autorizzazione è facoltativo.
• Usare un host e fornire un indirizzo dell'host. Una chiave o un token di autorizzazione è facoltativo.
• Usare un token di autorizzazione con la regione o la località associata.

Riconoscere discorsi 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 da voce a testo da un microfono su 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.

Riconoscere il parlato da un file

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

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

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.fromEndpoint("YourSpeechEndpoint", "YourSpeechKey");

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) grezzi che ignorano le intestazioni. L'API funziona ancora in alcuni casi se l'intestazione non viene omessa. Per ottenere risultati ottimali, è consigliabile implementare la logica per leggere le intestazioni in modo che fs inizi all'inizio dei dati audio.

Gestire gli 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 codice seguente valuta la result.reason proprietà 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 endpoint values?");
        }
        break;
    }

Usare il riconoscimento continuo

Gli esempi precedenti usano il riconoscimento single-shot, che riconosce una singola espressione. La fine di una singola espressione è determinata dall'ascolto del silenzio alla fine o fino a quando non viene elaborato un massimo di 15 secondi di audio.

Al contrario, è possibile usare il riconoscimento continuo quando si vuole controllare quando arrestare il riconoscimento. Richiede di registrarsi agli eventi Recognizing, Recognized, e Canceled per ottenere i risultati del riconoscimento. Per arrestare il riconoscimento, è necessario chiamare [stopContinuousRecognitionAsync] (/javascript/api/microsoft-cognitiveservices-speech-sdk/speechrecognizer#microsoft-cognitiveservices-speech-sdk-speechrecognizer-stopcontinuousrecognitionasync). Ecco un esempio di come viene eseguito il riconoscimento continuo in 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 endpoint values?");
    }

    speechRecognizer.stopContinuousRecognitionAsync();
};

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

Con tutti gli elementi configurati, chiamare [startContinuousRecognitionAsync] (/javascript/api/microsoft-cognitiveservices-speech-sdk/speechrecognizer#microsoft-cognitiveservices-speech-sdk-speechrecognizer-startkeywordrecognitionasync) 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 specifica la 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 di formato lingua-locale. Per un elenco delle impostazioni locali supportate, vedere Lingua e supporto vocale per il servizio Voce.

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("YourSpeechResoureKey", "YourServiceRegion");
speechConfig.endpointId = "YourEndpointId";
var speechRecognizer = new SpeechSDK.SpeechRecognizer(speechConfig);

Eseguire e usare un contenitore

I contenitori del riconoscimento vocale forniscono API di endpoint di query basato su websocket a cui si accede tramite Speech SDK e Speech CLI. 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 Reference | Esempi aggiuntivi in GitHub

In questa guida pratica si apprenderà come usare Azure Voce in Foundry Tools per la conversione del riconoscimento vocale in tempo reale in testo. Il riconoscimento vocale in tempo reale è ideale per le applicazioni che richiedono trascrizioni immediate, ad esempio dettatura, assistenza del call center e didascalia per le riunioni live.

Per informazioni su come configurare l'ambiente per un'applicazione di esempio, vedere Avvio rapido: Riconoscere e convertire la voce in testo.

Creare un'istanza di configurazione del riconoscimento vocale

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

1. Creare una risorsa di Foundry per la funzionalità di Voce nel portale Azure. Ottenere la chiave e l'area della risorsa Voce.
2. Creare un'istanza SpeechConfig usando la chiave e l'area di Riconoscimento vocale.

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

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

È possibile inizializzare SpeechConfig in altri modi:

• Usare un endpoint e specificare un endpoint del servizio di riconoscimento vocale. Una chiave o un token di autorizzazione è facoltativo.
• Usare un host e fornire un indirizzo dell'host. Una chiave o un token di autorizzazione è facoltativo.
• Usare un token di autorizzazione con la regione o la località associata.

Riconoscere discorsi da un microfono

Per riconoscere la voce usando il microfono del dispositivo, creare un'istanza di AudioConfig usando il metodo fromDefaultMicrophoneInput(). Inizializzare quindi l'oggetto SpeechRecognizer passando audioConfig e config.

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

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

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

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

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

Riconoscere il parlato da un file

Se si vuole riconoscere la voce da un file audio invece di usare un microfono, è comunque necessario creare un'istanza AudioConfig . Tuttavia, non si chiama FromDefaultMicrophoneInput(). Chiama fromWavFileInput() e passa il percorso del file:

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

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

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

Gestire gli errori

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

• Stampa il risultato del riconoscimento: ResultReason.RecognizedSpeech.
• Se non viene trovata alcuna corrispondenza di riconoscimento, informa l'utente: ResultReason.NoMatch.
• Se viene rilevato un errore, viene visualizzato il messaggio di errore: ResultReason.Canceled.

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

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

Usare il riconoscimento continuo

Gli esempi precedenti usano il riconoscimento single-shot, che riconosce una singola espressione. La fine di una singola espressione è determinata dall'ascolto del silenzio alla fine o fino a quando non viene elaborato un massimo di 15 secondi di audio.

Al contrario, si usa il riconoscimento continuo quando si vuole controllare quando arrestare il riconoscimento. Richiede di sottoscrivere agli eventi recognizing, recognized e canceled per ottenere i risultati del riconoscimento. 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 che SpeechRecognizer invia.

• 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 specifica la 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("YourSpeechKey", "YourServiceRegion");
speechConfig.setEndpointId("YourEndpointId");
SpeechRecognizer speechRecognizer = new SpeechRecognizer(speechConfig);

Eseguire e usare un contenitore

I contenitori del riconoscimento vocale forniscono API di endpoint di query basato su websocket a cui si accede tramite Speech SDK e Speech CLI. 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.

Segmentazione semantica

La segmentazione semantica è una strategia di segmentazione del riconoscimento vocale progettata per attenuare i problemi associati alla segmentazione basata sul silenzio:

• Under-segmentation: quando gli utenti parlano per molto tempo senza pause, possono vedere una lunga sequenza di testo senza interruzioni ("muro di testo"), che degrada gravemente l'esperienza di leggibilità.
• Over-segmentation: quando un utente fa una pausa per un breve periodo di tempo, il meccanismo di rilevamento del silenzio può segmentare erroneamente.

Invece di basarsi solo sui timeout del silenzio, la segmentazione semantica principalmente segmenta e restituisce i risultati finali quando rileva la punteggiatura finale della frase, ad esempio '.' o '?'. Ciò migliora l'esperienza utente con segmenti di qualità superiore, semanticamente completi e impedisce risultati intermedi lunghi.

Per usare la segmentazione semantica, è necessario impostare la proprietà seguente nell'istanza SpeechConfig usata per creare un oggetto SpeechRecognizer:

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

Di seguito sono riportate alcune limitazioni della segmentazione semantica:

• Per usare la segmentazione semantica, è necessario Speech SDK versione 1.41 o successiva.
• La segmentazione semantica è destinata solo all'uso nel riconoscimento continuo. Sono inclusi scenari come dettatura e sottotitoli. Non deve essere usato in modalità di riconoscimento singolo o in scenari interattivi.
• La segmentazione semantica non è disponibile per tutte le lingue e le impostazioni locali.
• La segmentazione semantica non supporta ancora i punteggi di attendibilità e gli elenchi NBest. Di conseguenza, non è consigliabile la segmentazione semantica se si usano punteggi di attendibilità o elenchi N-Best.

Perfezionamento post-flusso (anteprima)

Il perfezionamento del flusso posteriore migliora l'accuratezza della trascrizione finale eseguendo un secondo passaggio di riconoscimento in parallelo allo streaming in tempo reale. I risultati intermedi e parziali rimangono a bassa latenza. Solo il risultato finale viene sostituito con una versione più accurata che usa un contesto audio più ampio.

Per abilitare il perfezionamento post-flusso, impostare la proprietà SpeechServiceResponse_PostProcessingOption sull'istanza SpeechConfig.

speechConfig->SetProperty(PropertyId::SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speechConfig.SetProperty(PropertyId.SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speechConfig.setProperty(PropertyId.SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speech_config.set_property(
    speechsdk.PropertyId.SpeechServiceResponse_PostProcessingOption,
    "PostRefinement"
)

Alcune considerazioni importanti per il perfezionamento successivo alla trasmissione:

• Il raffinamento post-elaborazione funziona meglio per frasi più lunghe, come conversazioni, riunioni e dettatura. Per frasi molto brevi, il risultato raffinato potrebbe essere identico al risultato standard.
• Il perfezionamento post-flusso e la segmentazione semantica non possono essere usati insieme.
• La rifinitura post-flusso e TrueText sono valori separati della stessa proprietà SpeechServiceResponse_PostProcessingOption. È possibile impostare un solo valore alla volta.
• Il raffinamento post-stream è disponibile solo in selezionate aree di Azure durante l'anteprima pubblica.

Per altre informazioni sulle opzioni di post-elaborazione, vedere Come usare la post-elaborazione.

documentazione di Reference | Package (NuGet) | Esempi aggiuntivi in GitHub

In questa guida pratica si apprenderà come usare Azure Voce in Foundry Tools per la conversione del riconoscimento vocale in tempo reale in testo. Il riconoscimento vocale in tempo reale è ideale per le applicazioni che richiedono trascrizioni immediate, ad esempio dettatura, assistenza del call center e didascalia per le riunioni live.

Per informazioni su come configurare l'ambiente per un'applicazione di esempio, vedere Avvio rapido: Riconoscere e convertire la voce in testo.

Creare un'istanza di configurazione del riconoscimento vocale

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

1. Creare una risorsa Foundry per Sintesi vocale nel portale Azure. Ottenere la chiave e l'endpoint della risorsa Speech.
2. Creare un'istanza SpeechConfig usando il codice seguente. Sostituire YourSpeechKey e YourSpeechEndpoint con la chiave di risorsa e l'endpoint della risorsa Voce.

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

auto speechConfig = SpeechConfig::FromEndpoint("YourServiceEndpoint", "YourSpeechResourceKey");

È possibile inizializzare SpeechConfig in altri modi:

• Usare un endpoint e specificare un endpoint del servizio di riconoscimento vocale. Una chiave o un token di autorizzazione è facoltativo.
• Usare un host e fornire un indirizzo dell'host. Una chiave o un token di autorizzazione è facoltativo.
• Usare un token di autorizzazione con la regione o la località associata.

Riconoscere discorsi da un microfono

Per riconoscere la voce usando il microfono del dispositivo, creare un'istanza AudioConfig usando la funzione membro FromDefaultMicrophoneInput(). 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 informazioni su come ottenere l'ID dispositivo, vedere Selezionare un dispositivo di input audio con Speech SDK.

Riconoscere il parlato da un file

Se si vuole riconoscere la voce da un file audio invece di usare un microfono, è comunque necessario creare un'istanza AudioConfig . Tuttavia, non si chiama FromDefaultMicrophoneInput(). Chiama FromWavFileInput() e passa 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 a colpo singolo

Il riconoscimento single-shot riconosce in modo asincrono una singola espressione. La fine di una singola espressione è determinata dall'ascolto del silenzio alla fine o fino a quando non viene elaborato un massimo di 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 viene trovata 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 endpoint values?" << std::endl;
            }
        }
        break;
    default:
        break;
}

Riconoscimento continuo

Il riconoscimento continuo è un po' più coinvolto rispetto al riconoscimento a colpo singolo. Richiede di sottoscrivere agli eventi Recognizing, Recognized e Canceled per ottenere i risultati del riconoscimento. 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 che SpeechRecognizer invia.

• 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 endpoint 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 StartContinuousRecognitionAsync 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 specifica la 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 un elenco delle impostazioni locali supportate, vedere Lingua e supporto vocale per il servizio Voce.

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::FromEndpoint("YourServiceEndpoint", "YourSpeechResourceKey");
speechConfig->SetEndpointId("YourEndpointId");
auto speechRecognizer = SpeechRecognizer::FromConfig(speechConfig);

Eseguire e usare un contenitore

I contenitori del riconoscimento vocale forniscono API di endpoint di query basato su websocket a cui si accede tramite Speech SDK e Speech CLI. 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 endpoint.

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

Segmentazione semantica

La segmentazione semantica è una strategia di segmentazione del riconoscimento vocale progettata per attenuare i problemi associati alla segmentazione basata sul silenzio:

• Under-segmentation: quando gli utenti parlano per molto tempo senza pause, possono vedere una lunga sequenza di testo senza interruzioni ("muro di testo"), che degrada gravemente l'esperienza di leggibilità.
• Over-segmentation: quando un utente fa una pausa per un breve periodo di tempo, il meccanismo di rilevamento del silenzio può segmentare erroneamente.

Invece di basarsi solo sui timeout del silenzio, la segmentazione semantica principalmente segmenta e restituisce i risultati finali quando rileva la punteggiatura finale della frase, ad esempio '.' o '?'. Ciò migliora l'esperienza utente con segmenti di qualità superiore, semanticamente completi e impedisce risultati intermedi lunghi.

Per usare la segmentazione semantica, è necessario impostare la proprietà seguente nell'istanza SpeechConfig usata per creare un oggetto SpeechRecognizer:

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

Di seguito sono riportate alcune limitazioni della segmentazione semantica:

• Per usare la segmentazione semantica, è necessario Speech SDK versione 1.41 o successiva.
• La segmentazione semantica è destinata solo all'uso nel riconoscimento continuo. Sono inclusi scenari come dettatura e sottotitoli. Non deve essere usato in modalità di riconoscimento singolo o in scenari interattivi.
• La segmentazione semantica non è disponibile per tutte le lingue e le impostazioni locali.
• La segmentazione semantica non supporta ancora i punteggi di attendibilità e gli elenchi NBest. Di conseguenza, non è consigliabile la segmentazione semantica se si usano punteggi di attendibilità o elenchi N-Best.

Perfezionamento post-flusso (anteprima)

Il perfezionamento del flusso posteriore migliora l'accuratezza della trascrizione finale eseguendo un secondo passaggio di riconoscimento in parallelo allo streaming in tempo reale. I risultati intermedi e parziali rimangono a bassa latenza. Solo il risultato finale viene sostituito con una versione più accurata che usa un contesto audio più ampio.

Per abilitare il perfezionamento post-flusso, impostare la proprietà SpeechServiceResponse_PostProcessingOption sull'istanza SpeechConfig.

speechConfig->SetProperty(PropertyId::SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speechConfig.SetProperty(PropertyId.SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speechConfig.setProperty(PropertyId.SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speech_config.set_property(
    speechsdk.PropertyId.SpeechServiceResponse_PostProcessingOption,
    "PostRefinement"
)

Alcune considerazioni importanti per il perfezionamento successivo alla trasmissione:

• Il raffinamento post-elaborazione funziona meglio per frasi più lunghe, come conversazioni, riunioni e dettatura. Per frasi molto brevi, il risultato raffinato potrebbe essere identico al risultato standard.
• Il perfezionamento post-flusso e la segmentazione semantica non possono essere usati insieme.
• La rifinitura post-flusso e TrueText sono valori separati della stessa proprietà SpeechServiceResponse_PostProcessingOption. È possibile impostare un solo valore alla volta.
• Il raffinamento post-stream è disponibile solo in selezionate aree di Azure durante l'anteprima pubblica.

Per altre informazioni sulle opzioni di post-elaborazione, vedere Come usare la post-elaborazione.

documentazione di Reference | Package (Go) | Esempi aggiuntivi in GitHub

In questa guida pratica si apprenderà come usare Azure Voce in Foundry Tools per la conversione del riconoscimento vocale in tempo reale in testo. Il riconoscimento vocale in tempo reale è ideale per le applicazioni che richiedono trascrizioni immediate, ad esempio dettatura, assistenza del call center e didascalia per le riunioni live.

Per informazioni su come configurare l'ambiente per un'applicazione di esempio, vedere Avvio rapido: Riconoscere e convertire la voce in testo.

Riconoscere il discorso in testo da un microfono

1. Creare una risorsa Foundry per Sintesi vocale nel portale Azure. Ottieni la chiave della risorsa di riconoscimento vocale e la regione.
2. Usare l'esempio di codice seguente per eseguire il riconoscimento vocale dal microfono del dispositivo predefinito. Sostituire YourSpeechKey e YourSpeechRegion con la chiave e l'area della risorsa Voce. 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 classe SpeechConfig e la classe SpeechRecognizer classe.

Converti voce in testo da file audio

Usare l'esempio seguente per eseguire il riconoscimento vocale da un file audio. Sostituire YourSpeechKey e YourSpeechRegion con la chiave della risorsa di riconoscimento vocale e la regione. 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 classe SpeechConfig e la classe SpeechRecognizer classe.

Eseguire e usare un contenitore

I contenitori del riconoscimento vocale forniscono API di endpoint di query basato su websocket a cui si accede tramite Speech SDK e Speech CLI. 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 Reference | Package (download) | Esempi aggiuntivi in GitHub

In questa guida pratica si apprenderà come usare Azure Voce in Foundry Tools per la conversione del riconoscimento vocale in tempo reale in testo. Il riconoscimento vocale in tempo reale è ideale per le applicazioni che richiedono trascrizioni immediate, ad esempio dettatura, assistenza del call center e didascalia per le riunioni live.

Per informazioni su come configurare l'ambiente per un'applicazione di esempio, vedere Avvio rapido: Riconoscere e convertire la voce in testo.

Installare Speech SDK e campioni

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:

• Riconoscere il parlato da un microfono in Objective-C su macOS
• Riconoscere il parlato in Objective-C su iOS
• Più esempi per Objective-C su iOS

Per ulteriori informazioni, consultare il riferimento 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:"YourSpeechResoureKey" region:"YourServiceRegion"];
speechConfig.endpointId = "YourEndpointId";
SPXSpeechRecognizer* speechRecognizer = [[SPXSpeechRecognizer alloc] init:speechConfig];

Eseguire e usare un contenitore

I contenitori del riconoscimento vocale forniscono API di endpoint di query basato su websocket a cui si accede tramite Speech SDK e Speech CLI. 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.

In questa guida pratica si apprenderà come usare Azure Voce in Foundry Tools per la conversione del riconoscimento vocale in tempo reale in testo. Il riconoscimento vocale in tempo reale è ideale per le applicazioni che richiedono trascrizioni immediate, ad esempio dettatura, assistenza del call center e didascalia per le riunioni live.

Per informazioni su come configurare l'ambiente per un'applicazione di esempio, vedere Avvio rapido: Riconoscere e convertire la voce in testo.

Riconoscere discorsi 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.

Ora puoi eseguire il Speech CLI per riconoscere il parlato dal microfono. Dalla riga di comando, passare alla directory che contiene il file binario di Speech CLI. Eseguire quindi il comando seguente:

spx recognize --microphone

Parla al microfono e puoi vedere la trascrizione delle tue parole in testo in tempo reale. La CLI di Speech si arresta dopo un periodo di silenzio, o quando si preme Ctrl+C.

Riconoscere il parlato da un file

L'interfaccia della riga di comando di Speech può riconoscere la voce in molti formati di file e lingue naturali. In questo esempio è possibile usare qualsiasi file di .wav (16 kHz o 8 kHz, 16 bit e mono PCM) che contiene la voce inglese. In alternativa, 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 la CLI di Riconoscimento Vocale e riconoscere il parlato presente nel file audio.

spx recognize --file whatstheweatherlike.wav

La CLI di Speech mostra una trascrizione testuale del discorso sullo schermo.

Eseguire e usare un contenitore

I contenitori del riconoscimento vocale forniscono API di endpoint di query basato su websocket a cui si accede tramite Speech SDK e Speech CLI. 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 Reference | Package (download) | Esempi aggiuntivi in GitHub

In questa guida pratica si apprenderà come usare Azure Voce in Foundry Tools per la conversione del riconoscimento vocale in tempo reale in testo. Il riconoscimento vocale in tempo reale è ideale per le applicazioni che richiedono trascrizioni immediate, ad esempio dettatura, assistenza del call center e didascalia per le riunioni live.

Per informazioni su come configurare l'ambiente per un'applicazione di esempio, vedere Avvio rapido: Riconoscere e convertire la voce in testo.

Installare Speech SDK e campioni

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:

• Riconoscere il parlato in Swift su macOS
• Riconoscere il parlato con Swift su iOS

Per ulteriori informazioni, consultare il riferimento 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:

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

Eseguire e usare un contenitore

I contenitori del riconoscimento vocale forniscono API di endpoint di query basato su websocket a cui si accede tramite Speech SDK e Speech CLI. 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.