Introduzione alla traduzione vocale

Una delle funzionalità principali del servizio Voce è la capacità di riconoscere il parlato umano e tradurlo in altre lingue. In questa guida introduttiva si apprenderà come usare Speech SDK nelle app e nei prodotti per eseguire una traduzione vocale di alta qualità. Questa guida introduttiva illustra gli argomenti seguenti:

  • Traduzione vocale in testo
  • Traduzione vocale in più lingue di destinazione
  • Esecuzione della traduzione vocale diretta

Passare agli esempi su GitHub

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

Prerequisiti

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

Installare Speech SDK

Prima di poter eseguire qualsiasi operazione, è necessario installare Speech SDK. A seconda della piattaforma, seguire le istruzioni nella sezione Ottenere Speech SDK dell'articolo Informazioni su Speech SDK.

Importare le dipendenze

Per eseguire gli esempi in questo articolo, includere le istruzioni using seguenti all'inizio del file Program.cs.

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Threading.Tasks;
using Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Audio;
using Microsoft.CognitiveServices.Speech.Translation;

Dati sensibili e variabili di ambiente

Il codice sorgente di esempio in questo articolo dipende dalle variabili di ambiente per l'archiviazione di dati sensibili, ad esempio la chiave di sottoscrizione della risorsa Voce e l'area. La classe contiene due valori assegnati dalle variabili di ambiente dei Program static readonly string computer host, ad esempio e SPEECH__SUBSCRIPTION__KEY SPEECH__SERVICE__REGION . Entrambi questi campi si trova nell'ambito della classe, rendendoli accessibili all'interno dei corpi dei metodi della classe. Per altre informazioni sulle variabili di ambiente, vedere Variabili di ambiente e configurazione dell'applicazione.

public class Program
{
    static readonly string SPEECH__SUBSCRIPTION__KEY =
        Environment.GetEnvironmentVariable(nameof(SPEECH__SUBSCRIPTION__KEY));
    
    static readonly string SPEECH__SERVICE__REGION =
        Environment.GetEnvironmentVariable(nameof(SPEECH__SERVICE__REGION));

    static Task Main() => Task.CompletedTask;
}

Creare una configurazione di traduzione vocale

Per chiamare il servizio Voce con Speech SDK, è necessario creare una classe SpeechTranslationConfig. Questa classe include informazioni sulla sottoscrizione, ad esempio la chiave e l'area associata, l'endpoint, l'host o il token di autorizzazione.

Suggerimento

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

Esistono diversi modi per inizializzare SpeechTranslationConfig:

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

Vediamo come viene creata una classe SpeechTranslationConfig usando una chiave e un'area. Per ottenere queste credenziali, seguire la procedura descritta in Provare il servizio Voce gratuitamente.

public class Program
{
    static readonly string SPEECH__SUBSCRIPTION__KEY =
        Environment.GetEnvironmentVariable(nameof(SPEECH__SUBSCRIPTION__KEY));
    
    static readonly string SPEECH__SERVICE__REGION =
        Environment.GetEnvironmentVariable(nameof(SPEECH__SERVICE__REGION));

    static Task Main() => TranslateSpeechAsync();

    static async Task TranslateSpeechAsync()
    {
        var translationConfig =
            SpeechTranslationConfig.FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    }
}

Cambiare la lingua di origine

Un'attività comune della traduzione vocale è specificare la lingua di input (o di origine). Vediamo come cambiare la lingua di input in italiano. Nel codice interagire con SpeechTranslationConfig l'istanza , assegnando alla proprietà SpeechRecognitionLanguage .

static async Task TranslateSpeechAsync()
{
    var translationConfig =
        SpeechTranslationConfig.FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    // Source (input) language
    translationConfig.SpeechRecognitionLanguage = "it-IT";
}

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

Aggiungere la lingua di traduzione

Un'altra attività comune della traduzione vocale è specificare le lingue di traduzione di destinazione, almeno una è necessaria, ma l'uso di più lingue è supportato. Il frammento di codice seguente imposta il francese e il tedesco come destinazioni della lingua di traduzione.

static async Task TranslateSpeechAsync()
{
    var translationConfig =
        SpeechTranslationConfig.FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    translationConfig.SpeechRecognitionLanguage = "it-IT";
    
    // Translate to languages. See, https://aka.ms/speech/sttt-languages
    translationConfig.AddTargetLanguage("fr");
    translationConfig.AddTargetLanguage("de");
}

A ogni chiamata a AddTargetLanguage viene specificata una nuova lingua di traduzione di destinazione. In altre parole, quando il riconoscimento vocale viene riconosciuto dalla lingua di origine, ogni traduzione di destinazione è disponibile come parte dell'operazione di traduzione risultante.

Inizializzare un riconoscitore di traduzione

Dopo aver creato una classe SpeechTranslationConfig, il passaggio successivo consiste nell'inizializzare TranslationRecognizer. Quando si Inizializza TranslationRecognizer, sarà necessario passare translationConfig. L'oggetto di configurazione fornisce le credenziali richieste dal servizio voce per convalidare la richiesta.

Se si esegue il riconoscimento vocale usando il microfono predefinito del dispositivo, TranslationRecognizer avrà questo aspetto:

static async Task TranslateSpeechAsync()
{
    var translationConfig =
        SpeechTranslationConfig.FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    var fromLanguage = "en-US";
    var toLanguages = new List<string> { "it", "fr", "de" };
    translationConfig.SpeechRecognitionLanguage = fromLanguage;
    toLanguages.ForEach(translationConfig.AddTargetLanguage);

    using var recognizer = new TranslationRecognizer(translationConfig);
}

Se si vuole specificare il dispositivo di input audio, è necessario creare AudioConfig e specificare il parametro audioConfig quando si inizializza TranslationRecognizer.

In primo luogo, si fa riferimento AudioConfig all'oggetto come segue:

static async Task TranslateSpeechAsync()
{
    var translationConfig =
        SpeechTranslationConfig.FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    
    var fromLanguage = "en-US";
    var toLanguages = new List<string> { "it", "fr", "de" };
    translationConfig.SpeechRecognitionLanguage = fromLanguage;
    toLanguages.ForEach(translationConfig.AddTargetLanguage);

    using var audioConfig = AudioConfig.FromDefaultMicrophoneInput();
    using var recognizer = new TranslationRecognizer(translationConfig, audioConfig);
}

Se si vuole specificare un file audio invece di usare un microfono, è comunque necessario fornire audioConfig. Tuttavia, quando si crea AudioConfig, invece di chiamare FromDefaultMicrophoneInput, si chiamerà FromWavFileInput e si passerà il parametro filename.

static async Task TranslateSpeechAsync()
{
    var translationConfig =
        SpeechTranslationConfig.FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    
    var fromLanguage = "en-US";
    var toLanguages = new List<string> { "it", "fr", "de" };
    translationConfig.SpeechRecognitionLanguage = fromLanguage;
    toLanguages.ForEach(translationConfig.AddTargetLanguage);

    using var audioConfig = AudioConfig.FromWavFileInput("YourAudioFile.wav");
    using var recognizer = new TranslationRecognizer(translationConfig, audioConfig);
}

Traduzione vocale

Per tradurre la voce, Speech SDK si basa su un microfono o un input di file audio. Il riconoscimento vocale viene eseguito prima della traduzione vocale. Dopo l'inizializzazione di tutti gli oggetti, chiamare la funzione recognize-once e ottenere il risultato.

static async Task TranslateSpeechAsync()
{
    var translationConfig =
        SpeechTranslationConfig.FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    
    var fromLanguage = "en-US";
    var toLanguages = new List<string> { "it", "fr", "de" };
    translationConfig.SpeechRecognitionLanguage = fromLanguage;
    toLanguages.ForEach(translationConfig.AddTargetLanguage);

    using var recognizer = new TranslationRecognizer(translationConfig);

    Console.Write($"Say something in '{fromLanguage}' and ");
    Console.WriteLine($"we'll translate into '{string.Join("', '", toLanguages)}'.\n");
    
    var result = await recognizer.RecognizeOnceAsync();
    if (result.Reason == ResultReason.TranslatedSpeech)
    {
        Console.WriteLine($"Recognized: \"{result.Text}\":");
        foreach (var (language, translation) in result.Translations)
        {
            Console.WriteLine($"Translated into '{language}': {translation}");
        }
    }
}

Per altre informazioni sul riconoscimento vocale, vedere nozioni di base sul riconoscimento vocale.

Sintetizzare le traduzioni

Dopo aver completato correttamente il riconoscimento vocale e la traduzione, il risultato contiene tutte le traduzioni in un dizionario. La Translations chiave del dizionario è la lingua di traduzione di destinazione e il valore è il testo tradotto. La voce riconosciuta può essere tradotta e quindi sintetizzata in una lingua diversa (riconoscimento vocale).

Sintesi basata su eventi

TranslationRecognizerL'oggetto espone un evento Synthesizing . L'evento viene generato più volte e fornisce un meccanismo per recuperare l'audio sintetizzato dal risultato del riconoscimento della traduzione. Se si traduce in più lingue, vedere la sintesi manuale. Specificare la voce di sintesi assegnando un oggetto e VoiceName fornire un gestore eventi per l'evento e ottenere Synthesizing l'audio. L'esempio seguente salva l'audio tradotto come file wav.

Importante

La sintesi basata su eventi funziona solo con una singola traduzione, non aggiungere più lingue di traduzione di destinazione. Inoltre, deve essere la stessa lingua della lingua di traduzione di destinazione, ad esempio VoiceName ; potrebbe eseguire il mapping a "de" "de-DE-Hedda" .

static async Task TranslateSpeechAsync()
{
    var translationConfig =
        SpeechTranslationConfig.FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    
    var fromLanguage = "en-US";
    var toLanguage = "de";
    translationConfig.SpeechRecognitionLanguage = fromLanguage;
    translationConfig.AddTargetLanguage(toLanguage);

    // See: https://aka.ms/speech/sdkregion#standard-and-neural-voices
    translationConfig.VoiceName = "de-DE-Hedda";

    using var recognizer = new TranslationRecognizer(translationConfig);

    recognizer.Synthesizing += (_, e) =>
    {
        var audio = e.Result.GetAudio();
        Console.WriteLine($"Audio synthesized: {audio.Length:#,0} byte(s) {(audio.Length == 0 ? "(Complete)" : "")}");

        if (audio.Length > 0)
        {
            File.WriteAllBytes("YourAudioFile.wav", audio);
        }
    };

    Console.Write($"Say something in '{fromLanguage}' and ");
    Console.WriteLine($"we'll translate into '{toLanguage}'.\n");

    var result = await recognizer.RecognizeOnceAsync();
    if (result.Reason == ResultReason.TranslatedSpeech)
    {
        Console.WriteLine($"Recognized: \"{result.Text}\"");
        Console.WriteLine($"Translated into '{toLanguage}': {result.Translations[toLanguage]}");
    }
}

Sintesi manuale

Il Translations dizionario può essere usato per sintetizzare l'audio dal testo di traduzione. Scorrere ogni traduzione e sintetizzare la traduzione. Quando si crea un'istanza di , la proprietà dell'oggetto deve essere SpeechSynthesizer SpeechConfig SpeechSynthesisVoiceName impostata sulla voce desiderata. L'esempio seguente viene tradotto in cinque lingue e ogni traduzione viene quindi sintetizzata in un file audio nella lingua neurale corrispondente.

static async Task TranslateSpeechAsync()
{
    var translationConfig =
        SpeechTranslationConfig.FromSubscription(SPEECH__SERVICE__KEY, SPEECH__SERVICE__REGION);

    var fromLanguage = "en-US";
    var toLanguages = new List<string> { "de", "en", "it", "pt", "zh-Hans" };
    translationConfig.SpeechRecognitionLanguage = fromLanguage;
    toLanguages.ForEach(translationConfig.AddTargetLanguage);

    using var recognizer = new TranslationRecognizer(translationConfig);

    Console.Write($"Say something in '{fromLanguage}' and ");
    Console.WriteLine($"we'll translate into '{string.Join("', '", toLanguages)}'.\n");

    var result = await recognizer.RecognizeOnceAsync();
    if (result.Reason == ResultReason.TranslatedSpeech)
    {
        // See: https://aka.ms/speech/sdkregion#standard-and-neural-voices
        var languageToVoiceMap = new Dictionary<string, string>
        {
            ["de"] = "de-DE-KatjaNeural",
            ["en"] = "en-US-AriaNeural",
            ["it"] = "it-IT-ElsaNeural",
            ["pt"] = "pt-BR-FranciscaNeural",
            ["zh-Hans"] = "zh-CN-XiaoxiaoNeural"
        };

        Console.WriteLine($"Recognized: \"{result.Text}\"");

        foreach (var (language, translation) in result.Translations)
        {
            Console.WriteLine($"Translated into '{language}': {translation}");

            var speechConfig =
                SpeechConfig.FromSubscription(
                    SPEECH__SERVICE__KEY, SPEECH__SERVICE__REGION);
            speechConfig.SpeechSynthesisVoiceName = languageToVoiceMap[language];

            using var audioConfig = AudioConfig.FromWavFileOutput($"{language}-translation.wav");
            using var synthesizer = new SpeechSynthesizer(speechConfig, audioConfig);
            
            await synthesizer.SpeakTextAsync(translation);
        }
    }
}

Per altre informazioni sulla sintesi vocale, vedere nozioni di base sulla sintesi vocale.

Traduzione multilingue con identificazione della lingua

In molti scenari potrebbe non essere possibile conoscere le lingue di input da specificare. L'uso dell'identificazione della lingua consente di specificare fino a dieci possibili lingue di input e di tradurli automaticamente nelle lingue di destinazione.

L'esempio seguente usa la traduzione continua da un file audio e rileva automaticamente la lingua di input, anche se la lingua parlata cambia. Quando si esegue en-US l'esempio, zh-CN verrà rilevato automaticamente perché sono definiti in AutoDetectSourceLanguageConfig . Il riconoscimento vocale verrà quindi tradotto in de e come specificato nelle chiamate a fr AddTargetLanguage() .

Importante

Questa funzionalità è attualmente disponibile in anteprima.

using Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Audio;

public static async Task MultiLingualTranslation()
{
    var region = "<paste-your-region>";
    // currently the v2 endpoint is required for this design pattern
    var endpointString = $"wss://{region}.stt.speech.microsoft.com/speech/universal/v2";
    var endpointUrl = new Uri(endpointString);
    
    var config = SpeechConfig.FromEndpoint(endpointUrl, "<paste-your-subscription-key>");

    // Source lang is required, but is currently NoOp 
    string fromLanguage = "en-US";
    config.SpeechRecognitionLanguage = fromLanguage;

    config.AddTargetLanguage("de");
    config.AddTargetLanguage("fr");

    config.SetProperty(PropertyId.SpeechServiceConnection_ContinuousLanguageIdPriority, "Latency");
    var autoDetectSourceLanguageConfig = AutoDetectSourceLanguageConfig.FromLanguages(new string[] { "en-US", "zh-CN" });

    var stopTranslation = new TaskCompletionSource<int>();
    using (var audioInput = AudioConfig.FromWavFileInput(@"path-to-your-audio-file.wav"))
    {
        using (var recognizer = new TranslationRecognizer(config, autoDetectSourceLanguageConfig, audioInput))
        {
            recognizer.Recognizing += (s, e) =>
            {
                var lidResult = e.Result.Properties.GetProperty(PropertyId.SpeechServiceConnection_AutoDetectSourceLanguageResult);

                Console.WriteLine($"RECOGNIZING in '{lidResult}': Text={e.Result.Text}");
                foreach (var element in e.Result.Translations)
                {
                    Console.WriteLine($"    TRANSLATING into '{element.Key}': {element.Value}");
                }
            };

            recognizer.Recognized += (s, e) => {
                if (e.Result.Reason == ResultReason.TranslatedSpeech)
                {
                    var lidResult = e.Result.Properties.GetProperty(PropertyId.SpeechServiceConnection_AutoDetectSourceLanguageResult);

                    Console.WriteLine($"RECOGNIZED in '{lidResult}': Text={e.Result.Text}");
                    foreach (var element in e.Result.Translations)
                    {
                        Console.WriteLine($"    TRANSLATED into '{element.Key}': {element.Value}");
                    }
                }
                else if (e.Result.Reason == ResultReason.RecognizedSpeech)
                {
                    Console.WriteLine($"RECOGNIZED: Text={e.Result.Text}");
                    Console.WriteLine($"    Speech not translated.");
                }
                else if (e.Result.Reason == ResultReason.NoMatch)
                {
                    Console.WriteLine($"NOMATCH: Speech could not be recognized.");
                }
            };

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

                if (e.Reason == CancellationReason.Error)
                {
                    Console.WriteLine($"CANCELED: ErrorCode={e.ErrorCode}");
                    Console.WriteLine($"CANCELED: ErrorDetails={e.ErrorDetails}");
                    Console.WriteLine($"CANCELED: Did you update the subscription info?");
                }

                stopTranslation.TrySetResult(0);
            };

            recognizer.SpeechStartDetected += (s, e) => {
                Console.WriteLine("\nSpeech start detected event.");
            };

            recognizer.SpeechEndDetected += (s, e) => {
                Console.WriteLine("\nSpeech end detected event.");
            };

            recognizer.SessionStarted += (s, e) => {
                Console.WriteLine("\nSession started event.");
            };

            recognizer.SessionStopped += (s, e) => {
                Console.WriteLine("\nSession stopped event.");
                Console.WriteLine($"\nStop translation.");
                stopTranslation.TrySetResult(0);
            };

            // Starts continuous recognition. Uses StopContinuousRecognitionAsync() to stop recognition.
            Console.WriteLine("Start translation...");
            await recognizer.StartContinuousRecognitionAsync().ConfigureAwait(false);

            Task.WaitAny(new[] { stopTranslation.Task });
            await recognizer.StopContinuousRecognitionAsync().ConfigureAwait(false);
        }
    }
}

Una delle funzionalità principali del servizio Voce è la possibilità di riconoscere la voce umana e di tradurla in altre lingue. In questa guida introduttiva si apprenderà come usare Speech SDK nelle app e nei prodotti per eseguire una traduzione vocale di alta qualità. Questa guida introduttiva illustra gli argomenti seguenti:

  • Traduzione della voce in testo
  • Traduzione vocale in più lingue di destinazione
  • Esecuzione della traduzione vocale diretta

Passare agli esempi su GitHub

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

Prerequisiti

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

Installare Speech SDK

Prima di poter eseguire qualsiasi operazione, è necessario installare Speech SDK. A seconda della piattaforma, seguire le istruzioni nella sezione Ottenere Speech SDK dell'articolo Informazioni su Speech SDK.

Importare le dipendenze

Per eseguire gli esempi in questo articolo, includere le istruzioni #include e seguenti all'inizio del file di codice using C++.

#include <iostream> // cin, cout
#include <fstream>
#include <string>
#include <stdio.h>
#include <stdlib.h>
#include <speechapi_cxx.h>

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

Dati sensibili e variabili di ambiente

Il codice sorgente di esempio in questo articolo dipende dalle variabili di ambiente per l'archiviazione dei dati sensibili, ad esempio la chiave di sottoscrizione della risorsa Voce e l'area. Il file di codice C++ contiene due valori stringa assegnati dalle variabili di ambiente dei computer host, in questo caso SPEECH__SUBSCRIPTION__KEY e SPEECH__SERVICE__REGION . Entrambi questi campi si trova nell'ambito della classe, rendendoli accessibili all'interno dei corpi dei metodi della classe. Per altre informazioni sulle variabili di ambiente, vedere Variabili di ambiente e configurazione dell'applicazione.

auto SPEECH__SUBSCRIPTION__KEY = getenv("SPEECH__SUBSCRIPTION__KEY");
auto SPEECH__SERVICE__REGION = getenv("SPEECH__SERVICE__REGION");

Creare una configurazione di traduzione vocale

Per chiamare il servizio Voce con Speech SDK, è necessario creare una classe SpeechTranslationConfig. Questa classe include informazioni sulla sottoscrizione, ad esempio la chiave e l'area associata, l'endpoint, l'host o il token di autorizzazione.

Suggerimento

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

Esistono diversi modi per inizializzare SpeechTranslationConfig:

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

Vediamo come viene creata una classe SpeechTranslationConfig usando una chiave e un'area. Per ottenere queste credenziali, seguire la procedura descritta in Provare il servizio Voce gratuitamente.

auto SPEECH__SUBSCRIPTION__KEY = getenv("SPEECH__SUBSCRIPTION__KEY");
auto SPEECH__SERVICE__REGION = getenv("SPEECH__SERVICE__REGION");

void translateSpeech() {
    auto config =
        SpeechTranslationConfig::FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
}

int main(int argc, char** argv) {
    setlocale(LC_ALL, "");
    translateSpeech();
    return 0;
}

Cambiare la lingua di origine

Un'attività comune della traduzione vocale è specificare la lingua di input (o di origine). Vediamo come cambiare la lingua di input in italiano. Nel codice interagire con SpeechTranslationConfig l'istanza di , chiamando il metodo SetSpeechRecognitionLanguage .

void translateSpeech() {
    auto translationConfig =
        SpeechTranslationConfig::FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    // Source (input) language
    translationConfig->SetSpeechRecognitionLanguage("it-IT");
}

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

Aggiungere la lingua di traduzione

Un'altra attività comune della traduzione vocale è specificare le lingue di traduzione di destinazione, almeno una è necessaria, ma sono supportati più. Il frammento di codice seguente imposta il francese e il tedesco come destinazioni della lingua di traduzione.

void translateSpeech() {
    auto translationConfig =
        SpeechTranslationConfig::FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    translationConfig->SetSpeechRecognitionLanguage("it-IT");

    // Translate to languages. See, https://aka.ms/speech/sttt-languages
    translationConfig->AddTargetLanguage("fr");
    translationConfig->AddTargetLanguage("de");
}

A ogni chiamata a AddTargetLanguage viene specificata una nuova lingua di traduzione di destinazione. In altre parole, quando il riconoscimento vocale viene riconosciuto dalla lingua di origine, ogni traduzione di destinazione è disponibile come parte dell'operazione di traduzione risultante.

Inizializzare un riconoscitore di traduzione

Dopo aver creato una classe SpeechTranslationConfig, il passaggio successivo consiste nell'inizializzare TranslationRecognizer. Quando si Inizializza TranslationRecognizer, sarà necessario passare translationConfig. L'oggetto di configurazione fornisce le credenziali richieste dal servizio voce per convalidare la richiesta.

Se si esegue il riconoscimento vocale usando il microfono predefinito del dispositivo, TranslationRecognizer avrà questo aspetto:

void translateSpeech() {
    auto translationConfig =
        SpeechTranslationConfig::FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    auto fromLanguage = "en-US";
    auto toLanguages = { "it", "fr", "de" };
    translationConfig->SetSpeechRecognitionLanguage(fromLanguage);
    for (auto language : toLanguages) {
        translationConfig->AddTargetLanguage(language);
    }

    auto recognizer = TranslationRecognizer::FromConfig(translationConfig);
}

Se si vuole specificare il dispositivo di input audio, è necessario creare AudioConfig e specificare il parametro audioConfig quando si inizializza TranslationRecognizer.

In primo luogo, si fa riferimento AudioConfig all'oggetto come segue:

void translateSpeech() {
    auto translationConfig =
        SpeechTranslationConfig::FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    auto fromLanguage = "en-US";
    auto toLanguages = { "it", "fr", "de" };
    translationConfig->SetSpeechRecognitionLanguage(fromLanguage);
    for (auto language : toLanguages) {
        translationConfig->AddTargetLanguage(language);
    }

    auto audioConfig = AudioConfig::FromDefaultMicrophoneInput();
    auto recognizer = TranslationRecognizer::FromConfig(translationConfig, audioConfig);
}

Se si vuole specificare un file audio invece di usare un microfono, è comunque necessario fornire audioConfig. Tuttavia, quando si crea AudioConfig, invece di chiamare FromDefaultMicrophoneInput, si chiamerà FromWavFileInput e si passerà il parametro filename.

void translateSpeech() {
    auto translationConfig =
        SpeechTranslationConfig::FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    auto fromLanguage = "en-US";
    auto toLanguages = { "it", "fr", "de" };
    translationConfig->SetSpeechRecognitionLanguage(fromLanguage);
    for (auto language : toLanguages) {
        translationConfig->AddTargetLanguage(language);
    }

    auto audioConfig = AudioConfig::FromWavFileInput("YourAudioFile.wav");
    auto recognizer = TranslationRecognizer::FromConfig(translationConfig, audioConfig);
}

Traduzione vocale

Per tradurre la voce, Speech SDK si basa su un microfono o un input di file audio. Il riconoscimento vocale viene eseguito prima della traduzione vocale. Dopo l'inizializzazione di tutti gli oggetti, chiamare la funzione recognize-once e ottenere il risultato.

void translateSpeech() {
    auto translationConfig =
        SpeechTranslationConfig::FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    string fromLanguage = "en-US";
    string toLanguages[3] = { "it", "fr", "de" };
    translationConfig->SetSpeechRecognitionLanguage(fromLanguage);
    for (auto language : toLanguages) {
        translationConfig->AddTargetLanguage(language);
    }

    auto recognizer = TranslationRecognizer::FromConfig(translationConfig);
    cout << "Say something in '" << fromLanguage << "' and we'll translate...\n";

    auto result = recognizer->RecognizeOnceAsync().get();
    if (result->Reason == ResultReason::TranslatedSpeech)
    {
        cout << "Recognized: \"" << result->Text << "\"" << std::endl;
        for (auto pair : result->Translations)
        {
            auto language = pair.first;
            auto translation = pair.second;
            cout << "Translated into '" << language << "': " << translation << std::endl;
        }
    }
}

Per altre informazioni sulla sintesi vocale, vedere nozioni di base sul riconoscimento vocale.

Sintetizzare le traduzioni

Dopo aver completato correttamente il riconoscimento vocale e la traduzione, il risultato contiene tutte le traduzioni in un dizionario. La Translations chiave del dizionario è la lingua di traduzione di destinazione e il valore è il testo tradotto. Il riconoscimento vocale riconosciuto può essere tradotto e quindi sintetizzato in una lingua diversa (sintesi vocale).

Sintesi basata su eventi

TranslationRecognizerL'oggetto espone un evento Synthesizing . L'evento viene generato più volte e fornisce un meccanismo per recuperare l'audio sintetizzato dal risultato del riconoscimento della traduzione. Se si traduce in più lingue, vedere sintesi manuale. Specificare la voce di sintesi assegnando un e fornire un gestore SetVoiceName eventi per Synthesizing l'evento e ottenere l'audio. L'esempio seguente salva l'audio tradotto come file wav.

Importante

La sintesi basata su eventi funziona solo con una singola traduzione, non aggiungere più lingue di traduzione di destinazione. Inoltre, deve essere la stessa lingua della lingua di traduzione di destinazione, ad esempio , potrebbe eseguire il SetVoiceName "de" mapping a "de-DE-Hedda" .

void translateSpeech() {
    auto translationConfig =
        SpeechTranslationConfig::FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    auto fromLanguage = "en-US";
    auto toLanguage = "de";
    translationConfig->SetSpeechRecognitionLanguage(fromLanguage);
    translationConfig->AddTargetLanguage(toLanguage);

    // See: https://aka.ms/speech/sdkregion#standard-and-neural-voices
    translationConfig->SetVoiceName("de-DE-Hedda");

    auto recognizer = TranslationRecognizer::FromConfig(translationConfig);
    recognizer->Synthesizing.Connect([](const TranslationSynthesisEventArgs& e)
        {
            auto audio = e.Result->Audio;
            auto size = audio.size();
            cout << "Audio synthesized: " << size << " byte(s)" << (size == 0 ? "(COMPLETE)" : "") << std::endl;

            if (size > 0) {
                ofstream file("translation.wav", ios::out | ios::binary);
                auto audioData = audio.data();
                file.write((const char*)audioData, sizeof(audio[0]) * size);
                file.close();
            }
        });

    cout << "Say something in '" << fromLanguage << "' and we'll translate...\n";

    auto result = recognizer->RecognizeOnceAsync().get();
    if (result->Reason == ResultReason::TranslatedSpeech)
    {
        cout << "Recognized: \"" << result->Text << "\"" << std::endl;
        for (auto pair : result->Translations)
        {
            auto language = pair.first;
            auto translation = pair.second;
            cout << "Translated into '" << language << "': " << translation << std::endl;
        }
    }
}

Sintesi manuale

Il Translations dizionario può essere usato per sintetizzare l'audio dal testo della traduzione. Scorrere ogni traduzione e sintetizzare la traduzione. Quando si crea un'istanza di , la proprietà dell'oggetto deve essere SpeechSynthesizer SpeechConfig SetSpeechSynthesisVoiceName impostata sulla voce desiderata. L'esempio seguente traduce in cinque lingue e ogni traduzione viene quindi sintetizzata in un file audio nella lingua neurale corrispondente.

void translateSpeech() {
    auto translationConfig =
        SpeechTranslationConfig::FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    auto fromLanguage = "en-US";
    auto toLanguages = { "de", "en", "it", "pt", "zh-Hans" };
    translationConfig->SetSpeechRecognitionLanguage(fromLanguage);
    for (auto language : toLanguages) {
        translationConfig->AddTargetLanguage(language);
    }

    auto recognizer = TranslationRecognizer::FromConfig(translationConfig);

    cout << "Say something in '" << fromLanguage << "' and we'll translate...\n";

    auto result = recognizer->RecognizeOnceAsync().get();
    if (result->Reason == ResultReason::TranslatedSpeech)
    {
        // See: https://aka.ms/speech/sdkregion#standard-and-neural-voices
        map<string, string> languageToVoiceMap;
        languageToVoiceMap["de"] = "de-DE-KatjaNeural";
        languageToVoiceMap["en"] = "en-US-AriaNeural";
        languageToVoiceMap["it"] = "it-IT-ElsaNeural";
        languageToVoiceMap["pt"] = "pt-BR-FranciscaNeural";
        languageToVoiceMap["zh-Hans"] = "zh-CN-XiaoxiaoNeural";

        cout << "Recognized: \"" << result->Text << "\"" << std::endl;
        for (auto pair : result->Translations)
        {
            auto language = pair.first;
            auto translation = pair.second;
            cout << "Translated into '" << language << "': " << translation << std::endl;

            auto speech_config =
                SpeechConfig::FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
            speech_config->SetSpeechSynthesisVoiceName(languageToVoiceMap[language]);

            auto audio_config = AudioConfig::FromWavFileOutput(language + "-translation.wav");
            auto synthesizer = SpeechSynthesizer::FromConfig(speech_config, audio_config);

            synthesizer->SpeakTextAsync(translation).get();
        }
    }
}

Per altre informazioni sulla sintesi vocale, vedere nozioni di base sulla sintesi vocale.

Traduzione multilingue con identificazione della lingua

In molti scenari potrebbe non essere possibile sapere quali lingue di input specificare. L'identificazione della lingua consente di specificare fino a dieci possibili lingue di input e di eseguire automaticamente la traduzione nelle lingue di destinazione.

L'esempio seguente usa la traduzione continua da un file audio e rileva automaticamente la lingua di input, anche se la lingua parlata cambia. Quando si esegue l'esempio, en-US zh-CN e vengono rilevati automaticamente perché sono definiti in AutoDetectSourceLanguageConfig . Il parlato verrà quindi tradotto in de e come specificato nelle chiamate a fr AddTargetLanguage() .

Importante

Questa funzionalità è attualmente disponibile in anteprima.

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

void MultiLingualTranslation()
{
    auto region = "<paste-your-region>";
    // currently the v2 endpoint is required for this design pattern
    auto endpointString = std::format("wss://{}.stt.speech.microsoft.com/speech/universal/v2", region);
    auto config = SpeechConfig::FromEndpoint(endpointString, "<paste-your-subscription-key>");

    config->SetProperty(PropertyId::SpeechServiceConnection_ContinuousLanguageIdPriority, "Latency");
    auto autoDetectSourceLanguageConfig = AutoDetectSourceLanguageConfig::FromLanguages({ "en-US", "zh-CN" });

    promise<void> recognitionEnd;
    // Source lang is required, but is currently NoOp 
    auto fromLanguage = "en-US";
    config->SetSpeechRecognitionLanguage(fromLanguage);
    config->AddTargetLanguage("de");
    config->AddTargetLanguage("fr");

    auto audioInput = AudioConfig::FromWavFileInput("path-to-your-audio-file.wav");
    auto recognizer = TranslationRecognizer::FromConfig(config, autoDetectSourceLanguageConfig, audioInput);

    recognizer->Recognizing.Connect([](const TranslationRecognitionEventArgs& e)
        {
            std::string lidResult = e.Result->Properties.GetProperty(PropertyId::SpeechServiceConnection_AutoDetectSourceLanguageResult);

            cout << "Recognizing in Language = "<< lidResult << ":" << e.Result->Text << std::endl;
            for (const auto& it : e.Result->Translations)
            {
                cout << "  Translated into '" << it.first.c_str() << "': " << it.second.c_str() << std::endl;
            }
        });

    recognizer->Recognized.Connect([](const TranslationRecognitionEventArgs& e)
        {
            if (e.Result->Reason == ResultReason::TranslatedSpeech)
            {
                std::string lidResult = e.Result->Properties.GetProperty(PropertyId::SpeechServiceConnection_AutoDetectSourceLanguageResult);
                cout << "RECOGNIZED in Language = " << lidResult << ": Text=" << e.Result->Text << std::endl;
            }
            else 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;
            }

            for (const auto& it : e.Result->Translations)
            {
                cout << "  Translated into '" << it.first.c_str() << "': " << it.second.c_str() << std::endl;
            }
        });

    recognizer->Canceled.Connect([&recognitionEnd](const TranslationRecognitionCanceledEventArgs& e)
        {
            cout << "CANCELED: Reason=" << (int)e.Reason << std::endl;
            if (e.Reason == CancellationReason::Error)
            {
                cout << "CANCELED: ErrorCode=" << (int)e.ErrorCode << std::endl;
                cout << "CANCELED: ErrorDetails=" << e.ErrorDetails << std::endl;
                cout << "CANCELED: Did you update the subscription info?" << std::endl;

                recognitionEnd.set_value();
            }
        });

    recognizer->Synthesizing.Connect([](const TranslationSynthesisEventArgs& e)
        {
            auto size = e.Result->Audio.size();
            cout << "Translation synthesis result: size of audio data: " << size
                << (size == 0 ? "(END)" : "");
        });

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

    // Starts continuos recognition. Use StopContinuousRecognitionAsync() to stop recognition.
    recognizer->StartContinuousRecognitionAsync().get();
    recognitionEnd.get_future().get();
    recognizer->StopContinuousRecognitionAsync().get();
}

Una delle funzionalità principali del servizio di riconoscimento vocale è la possibilità di riconoscere la voce umana e tradurla in altre lingue. Questa Guida introduttiva illustra come usare l'SDK di riconoscimento vocale nelle app e nei prodotti per eseguire la traduzione vocale di alta qualità. Questa Guida introduttiva illustra gli argomenti tra cui:

  • Conversione vocale in testo
  • Conversione di riconoscimento vocale in più lingue di destinazione
  • Esecuzione della traduzione vocale diretta

Passare agli esempi su GitHub

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

Prerequisiti

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

Installare Speech SDK

Prima di poter eseguire qualsiasi operazione, è necessario installare Speech SDK. A seconda della piattaforma, seguire le istruzioni riportate nella sezione Get The Speech SDK dell'articolo About The Speech SDK .

Importare le dipendenze

Per eseguire gli esempi in questo articolo, includere le import istruzioni seguenti all'inizio di *. File di codice Java.

package speech;

import java.io.*;
import java.util.*;
import java.util.concurrent.*;
import com.microsoft.cognitiveservices.speech.*;
import com.microsoft.cognitiveservices.speech.audio.*;
import com.microsoft.cognitiveservices.speech.translation.*;

Variabili di ambiente e dati sensibili

Il codice sorgente di esempio in questo articolo dipende dalle variabili di ambiente per l'archiviazione di dati sensibili, ad esempio la chiave di sottoscrizione della risorsa vocale e l'area. Il file di codice Java contiene due static final String valori assegnati dalle variabili di ambiente dei computer host, ovvero SPEECH__SUBSCRIPTION__KEY e SPEECH__SERVICE__REGION . Entrambi questi campi si trovano nell'ambito della classe, rendendoli accessibili nei corpi dei metodi della classe. Per altre informazioni sulle variabili di ambiente, vedere variabili di ambiente e configurazione dell'applicazione.

public class App {

    static final String SPEECH__SUBSCRIPTION__KEY = System.getenv("SPEECH__SUBSCRIPTION__KEY");
    static final String SPEECH__SERVICE__REGION = System.getenv("SPEECH__SERVICE__REGION");

    public static void main(String[] args) { }
}

Creare una configurazione di traduzione vocale

Per chiamare il servizio Voce con Speech SDK, è necessario creare una classe SpeechTranslationConfig. Questa classe include informazioni sulla sottoscrizione, ad esempio la chiave e l'area associata, l'endpoint, l'host o il token di autorizzazione.

Suggerimento

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

Esistono diversi modi per inizializzare SpeechTranslationConfig:

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

Vediamo come viene creata una classe SpeechTranslationConfig usando una chiave e un'area. Per ottenere queste credenziali, seguire la procedura descritta in Provare il servizio Voce gratuitamente.

public class App {

    static final String SPEECH__SUBSCRIPTION__KEY = System.getenv("SPEECH__SERVICE__KEY");
    static final String SPEECH__SERVICE__REGION = System.getenv("SPEECH__SERVICE__REGION");

    public static void main(String[] args) {
        try {
            translateSpeech();
            System.exit(0);
        } catch (Exception ex) {
            System.out.println(ex);
            System.exit(1);
        }
    }

    static void translateSpeech() {
        SpeechTranslationConfig config = SpeechTranslationConfig.fromSubscription(
            SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    }
}

Cambiare la lingua di origine

Una delle attività comuni della traduzione vocale è la specifica della lingua di input (o di origine). Vediamo come cambiare la lingua di input in italiano. Nel codice interagire con l' SpeechTranslationConfig istanza, chiamando il setSpeechRecognitionLanguage metodo.

static void translateSpeech() {
    SpeechTranslationConfig translationConfig = SpeechTranslationConfig.fromSubscription(
        SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    
    // Source (input) language
    translationConfig.setSpeechRecognitionLanguage("it-IT");
}

La setSpeechRecognitionLanguage funzione prevede una stringa di formato delle impostazioni locali della lingua. È possibile specificare qualsiasi valore nella colonna Locale nell'elenco di impostazioni locali/lingue supportate.

Aggiungi lingua di traduzione

Un'altra attività comune di traduzione vocale è quella di specificare i linguaggi di traduzione di destinazione, almeno uno è obbligatorio ma sono supportati più multipli. Il frammento di codice seguente imposta sia il francese che il tedesco come destinazioni del linguaggio di traduzione.

static void translateSpeech() {
    SpeechTranslationConfig translationConfig = SpeechTranslationConfig.fromSubscription(
        SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    
    translationConfig.setSpeechRecognitionLanguage("it-IT");

    // Translate to languages. See, https://aka.ms/speech/sttt-languages
    translationConfig.addTargetLanguage("fr");
    translationConfig.addTargetLanguage("de");
}

Con ogni chiamata a addTargetLanguage , viene specificato un nuovo linguaggio di conversione di destinazione. In altre parole, quando la voce vocale viene riconosciuta dalla lingua di origine, ogni conversione di destinazione è disponibile come parte dell'operazione di conversione risultante.

Inizializzare un riconoscimento di traduzione

Dopo aver creato una classe SpeechTranslationConfig, il passaggio successivo consiste nell'inizializzare TranslationRecognizer. Quando si Inizializza TranslationRecognizer, sarà necessario passare translationConfig. L'oggetto di configurazione fornisce le credenziali richieste dal servizio di riconoscimento vocale per convalidare la richiesta.

Se si esegue il riconoscimento vocale usando il microfono predefinito del dispositivo, TranslationRecognizer avrà questo aspetto:

static void translateSpeech() {
    SpeechTranslationConfig translationConfig = SpeechTranslationConfig.fromSubscription(
        SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    
    String fromLanguage = "en-US";
    String[] toLanguages = { "it", "fr", "de" };
    translationConfig.setSpeechRecognitionLanguage(fromLanguage);
    for (String language : toLanguages) {
        translationConfig.addTargetLanguage(language);
    }

    try (TranslationRecognizer recognizer = new TranslationRecognizer(translationConfig)) {
    }
}

Se si vuole specificare il dispositivo di input audio, è necessario creare AudioConfig e specificare il parametro audioConfig quando si inizializza TranslationRecognizer.

In primo luogo, si farà riferimento all' AudioConfig oggetto come segue:

static void translateSpeech() {
    SpeechTranslationConfig translationConfig = SpeechTranslationConfig.fromSubscription(
        SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    
    String fromLanguage = "en-US";
    String[] toLanguages = { "it", "fr", "de" };
    translationConfig.setSpeechRecognitionLanguage(fromLanguage);
    for (String language : toLanguages) {
        translationConfig.addTargetLanguage(language);
    }

    AudioConfig audioConfig = AudioConfig.fromDefaultMicrophoneInput();
    try (TranslationRecognizer recognizer = new TranslationRecognizer(translationConfig, audioConfig)) {
        
    }
}

Se si vuole specificare un file audio invece di usare un microfono, è comunque necessario fornire audioConfig. Tuttavia, quando si crea AudioConfig, invece di chiamare fromDefaultMicrophoneInput, si chiamerà fromWavFileInput e si passerà il parametro filename.

static void translateSpeech() {
    SpeechTranslationConfig translationConfig = SpeechTranslationConfig.fromSubscription(
        SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    
    String fromLanguage = "en-US";
    String[] toLanguages = { "it", "fr", "de" };
    translationConfig.setSpeechRecognitionLanguage(fromLanguage);
    for (String language : toLanguages) {
        translationConfig.addTargetLanguage(language);
    }

    AudioConfig audioConfig = AudioConfig.fromWavFileInput("YourAudioFile.wav");
    try (TranslationRecognizer recognizer = new TranslationRecognizer(translationConfig, audioConfig)) {
        
    }
}

Traduzione vocale

Per tradurre la voce, l'SDK di riconoscimento vocale si basa su un microfono o un input di file audio. Il riconoscimento vocale si verifica prima della traduzione vocale. Dopo l'inizializzazione di tutti gli oggetti, chiamare la funzione Recognize-once e ottenere il risultato.

static void translateSpeech() throws ExecutionException, InterruptedException {
    SpeechTranslationConfig translationConfig = SpeechTranslationConfig.fromSubscription(
        SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    
    String fromLanguage = "en-US";
    String[] toLanguages = { "it", "fr", "de" };
    translationConfig.setSpeechRecognitionLanguage(fromLanguage);
    for (String language : toLanguages) {
        translationConfig.addTargetLanguage(language);
    }

    try (TranslationRecognizer recognizer = new TranslationRecognizer(translationConfig)) {
        System.out.printf("Say something in '%s' and we'll translate...", fromLanguage);

        TranslationRecognitionResult result = recognizer.recognizeOnceAsync().get();
        if (result.getReason() == ResultReason.TranslatedSpeech) {
            System.out.printf("Recognized: \"%s\"\n", result.getText());
            for (Map.Entry<String, String> pair : result.getTranslations().entrySet()) {
                System.out.printf("Translated into '%s': %s\n", pair.getKey(), pair.getValue());
            }
        }
    }
}

Per ulteriori informazioni sulla sintesi vocale, vedere le nozioni di base del riconoscimento vocale.

Sintetizza le traduzioni

Dopo un riconoscimento vocale e una traduzione con esito positivo, il risultato contiene tutte le traduzioni in un dizionario. La getTranslations funzione restituisce un dizionario con la chiave come lingua di conversione di destinazione e il valore è il testo tradotto. Il riconoscimento vocale riconosciuto può essere convertito, quindi sintetizzato in un linguaggio diverso (sintesi vocale).

Sintesi basata su eventi

L' TranslationRecognizer oggetto espone un synthesizing evento. L'evento viene generato più volte e fornisce un meccanismo per recuperare l'audio sintetizzato dal risultato del riconoscimento della traduzione. Se si esegue la conversione in più lingue, vedere sintesi manuale. Specificare la voce di sintesi assegnando un oggetto setVoiceName e fornire un gestore eventi per l' synthesizing evento, ottenere l'audio. Nell'esempio seguente viene salvato l'audio tradotto come file WAV .

Importante

La sintesi basata su eventi funziona solo con una singola traduzione. non aggiungere più lingue di traduzione di destinazione. Inoltre, setVoiceName deve essere la stessa lingua del linguaggio di traduzione di destinazione, ad esempio "de" . può eseguire il mapping a "de-DE-Hedda" .

static void translateSpeech() throws ExecutionException, FileNotFoundException, InterruptedException, IOException {
    SpeechTranslationConfig translationConfig = SpeechTranslationConfig.fromSubscription(
        SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);

    String fromLanguage = "en-US";
    String toLanguage = "de";
    translationConfig.setSpeechRecognitionLanguage(fromLanguage);
    translationConfig.addTargetLanguage(toLanguage);

    // See: https://aka.ms/speech/sdkregion#standard-and-neural-voices
    translationConfig.setVoiceName("de-DE-Hedda");

    try (TranslationRecognizer recognizer = new TranslationRecognizer(translationConfig)) {
        recognizer.synthesizing.addEventListener((s, e) -> {
            byte[] audio = e.getResult().getAudio();
            int size = audio.length;
            System.out.println("Audio synthesized: " + size + " byte(s)" + (size == 0 ? "(COMPLETE)" : ""));

            if (size > 0) {
                try (FileOutputStream file = new FileOutputStream("translation.wav")) {
                    file.write(audio);
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
            }
        });

        System.out.printf("Say something in '%s' and we'll translate...", fromLanguage);

        TranslationRecognitionResult result = recognizer.recognizeOnceAsync().get();
        if (result.getReason() == ResultReason.TranslatedSpeech) {
            System.out.printf("Recognized: \"%s\"\n", result.getText());
            for (Map.Entry<String, String> pair : result.getTranslations().entrySet()) {
                String language = pair.getKey();
                String translation = pair.getValue();
                System.out.printf("Translated into '%s': %s\n", language, translation);
            }
        }
    }
}

Sintesi manuale

La getTranslations funzione restituisce un dizionario che può essere usato per sintetizzare l'audio dal testo di traduzione. Scorrere ogni traduzione e sintetizzare la traduzione. Quando si crea un' SpeechSynthesizer istanza, l' SpeechConfig oggetto deve avere la setSpeechSynthesisVoiceName proprietà impostata sulla voce desiderata. Nell'esempio seguente viene convertito in cinque lingue e ogni conversione viene quindi sintetizzata in un file audio nel linguaggio neurale corrispondente.

static void translateSpeech() throws ExecutionException, InterruptedException {
    SpeechTranslationConfig translationConfig = SpeechTranslationConfig.fromSubscription(
        SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    
    String fromLanguage = "en-US";
    String[] toLanguages = { "de", "en", "it", "pt", "zh-Hans" };
    translationConfig.setSpeechRecognitionLanguage(fromLanguage);
    for (String language : toLanguages) {
        translationConfig.addTargetLanguage(language);
    }

    try (TranslationRecognizer recognizer = new TranslationRecognizer(translationConfig)) {
        System.out.printf("Say something in '%s' and we'll translate...", fromLanguage);

        TranslationRecognitionResult result = recognizer.recognizeOnceAsync().get();
        if (result.getReason() == ResultReason.TranslatedSpeech) {
            // See: https://aka.ms/speech/sdkregion#standard-and-neural-voices
            Map<String, String> languageToVoiceMap = new HashMap<String, String>();
            languageToVoiceMap.put("de", "de-DE-KatjaNeural");
            languageToVoiceMap.put("en", "en-US-AriaNeural");
            languageToVoiceMap.put("it", "it-IT-ElsaNeural");
            languageToVoiceMap.put("pt", "pt-BR-FranciscaNeural");
            languageToVoiceMap.put("zh-Hans", "zh-CN-XiaoxiaoNeural");

            System.out.printf("Recognized: \"%s\"\n", result.getText());
            for (Map.Entry<String, String> pair : result.getTranslations().entrySet()) {
                String language = pair.getKey();
                String translation = pair.getValue();
                System.out.printf("Translated into '%s': %s\n", language, translation);

                SpeechConfig speechConfig =
                    SpeechConfig.fromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
                speechConfig.setSpeechSynthesisVoiceName(languageToVoiceMap.get(language));

                AudioConfig audioConfig = AudioConfig.fromWavFileOutput(language + "-translation.wav");
                try (SpeechSynthesizer synthesizer = new SpeechSynthesizer(speechConfig, audioConfig)) {
                    synthesizer.SpeakTextAsync(translation).get();
                }
            }
        }
    }
}

Per ulteriori informazioni sulla sintesi vocale, vedere le nozioni di base sulla sintesi vocale.

Una delle funzionalità principali del servizio di riconoscimento vocale è la possibilità di riconoscere la voce umana e tradurla in altre lingue. Questa Guida introduttiva illustra come usare l'SDK di riconoscimento vocale nelle app e nei prodotti per eseguire la traduzione vocale di alta qualità. Questa Guida introduttiva illustra gli argomenti tra cui:

  • Conversione vocale in testo
  • Conversione di riconoscimento vocale in più lingue di destinazione
  • Esecuzione della traduzione vocale diretta

Passare agli esempi su GitHub

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

Prerequisiti

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

Installare Speech SDK

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

A seconda dell'ambiente di destinazione, inoltre, usare una delle alternative seguenti:

Scaricare ed estrarre il file SDK di riconoscimento vocale per JavaScript microsoft.cognitiveservices.speech.sdk.bundle.js e inserirlo in una cartella accessibile al file HTML.

<script src="microsoft.cognitiveservices.speech.sdk.bundle.js"></script>;

Suggerimento

Se la destinazione è un Web browser e si usa il tag <script>, il prefisso sdk non è necessario. Il prefisso sdk è un alias usato per la denominazione del modulo di require.

Creare una configurazione di traduzione

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

Nota

Sia che si esegua il riconoscimento vocale, la sintesi vocale, la traduzione o il riconoscimento finalità, sarà sempre necessario creare una configurazione. Esistono diversi modi per inizializzare SpeechTranslationConfig:

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

Vediamo come viene creata una classe SpeechTranslationConfig usando una chiave e un'area. Per ottenere queste credenziali, seguire la procedura descritta in Provare il servizio Voce gratuitamente.

const speechTranslationConfig = SpeechTranslationConfig.fromSubscription("YourSubscriptionKey", "YourServiceRegion");

Inizializzare un convertitore

Dopo aver creato una classe SpeechTranslationConfig, il passaggio successivo consiste nell'inizializzare TranslationRecognizer. Quando si Inizializza TranslationRecognizer, sarà necessario passare speechTranslationConfig. In questo modo vengono fornite le credenziali richieste dal servizio di traduzione per convalidare la richiesta.

Se si sta traducendo il riconoscimento vocale fornito tramite il microfono predefinito del dispositivo, ecco l' TranslationRecognizer aspetto che dovrebbe essere simile al seguente:

const translator = new TranslationRecognizer(speechTranslationConfig);

Se si vuole specificare il dispositivo di input audio, è necessario creare AudioConfig e specificare il parametro audioConfig quando si inizializza TranslationRecognizer.

Suggerimento

Informazioni su come ottenere l'ID del dispositivo di input audio. Fare riferimento all'oggetto AudioConfig come indicato di seguito:

const audioConfig = AudioConfig.fromDefaultMicrophoneInput();
const recognizer = new TranslationRecognizer(speechTranslationConfig, audioConfig);

Se si vuole specificare un file audio invece di usare un microfono, è comunque necessario fornire audioConfig. Questo è tuttavia possibile solo quando la destinazione è Node.js. Quando si crea un oggetto AudioConfig, invece di chiamare fromDefaultMicrophoneInput, si chiamerà fromWavFileOutput e si passerà il parametro filename.

const audioConfig = AudioConfig.fromWavFileInput("YourAudioFile.wav");
const recognizer = new TranslationRecognizer(speechTranslationConfig, audioConfig);

Traduzione vocale

La classe TranslationRecognizer per l'SDK di riconoscimento vocale per JavaScript espone alcuni metodi che è possibile usare per la traduzione vocale.

  • Single-Shot Translation (Async): esegue la conversione in modalità non di blocco (asincrono). Questo tradurrà 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.
  • Continuous Translation (Async): avvia in modo asincrono un'operazione di conversione continua. L'utente esegue la registrazione agli eventi e gestisce diversi Stati dell'applicazione. Per arrestare la conversione continua asincrona, chiamare stopContinuousRecognitionAsync .

Nota

Per altre informazioni, vedere come scegliere una modalità di riconoscimento vocale.

Specificare una lingua di destinazione

Per tradurre, è necessario specificare una lingua di origine e almeno una lingua di destinazione. È possibile scegliere una lingua di origine usando le impostazioni locali elencate nella tabella di traduzione vocale. Trova le opzioni per la lingua tradotta con lo stesso collegamento. Le opzioni per le lingue di destinazione sono diverse quando si desidera visualizzare il testo o si desidera ascoltare la sintesi vocale tradotta. Per eseguire la conversione dalla lingua inglese alla lingua tedesca, modificare l'oggetto Translation config:

speechTranslationConfig.speechRecognitionLanguage = "en-US";
speechTranslationConfig.addTargetLanguage("de");

Riconoscimento singolo

Di seguito è riportato un esempio di traduzione asincrona a singolo tentativo con recognizeOnceAsync :

recognizer.recognizeOnceAsync(result => {
    // Interact with result
});

Per gestire il risultato è necessario scrivere del codice. Questo esempio valuta result.reason per una traduzione in tedesco:

recognizer.recognizeOnceAsync(
  function (result) {
    let translation = result.translations.get("de");
    window.console.log(translation);
    recognizer.close();
  },
  function (err) {
    window.console.log(err);
    recognizer.close();
});

Il codice può anche gestire gli aggiornamenti forniti durante l'elaborazione della traduzione. È possibile utilizzare questi aggiornamenti per fornire commenti visivi sullo stato di avanzamento della traduzione. Vedere questo esempio di Node.js JavaScript per il codice di esempio che Mostra gli aggiornamenti forniti durante il processo di conversione. Il codice seguente visualizza anche i dettagli prodotti durante il processo di conversione.

recognizer.recognizing = function (s, e) {
    var str = ("(recognizing) Reason: " + SpeechSDK.ResultReason[e.result.reason] +
            " Text: " +  e.result.text +
            " Translation:");
    str += e.result.translations.get("de");
    console.log(str);
};
recognizer.recognized = function (s, e) {
    var str = "\r\n(recognized)  Reason: " + SpeechSDK.ResultReason[e.result.reason] +
            " Text: " + e.result.text +
            " Translation:";
    str += e.result.translations.get("de");
    str += "\r\n";
    console.log(str);
};

Traduzione continua

La traduzione continua è un po' più complessa rispetto al riconoscimento single-shot. Per ottenere i risultati del riconoscimento, è necessario sottoscrivere gli eventi recognizing, recognized e canceled. Per arrestare la traduzione, è necessario chiamare stopContinuousRecognitionAsync . Di seguito è riportato un esempio di come viene eseguita la conversione continua su un file di input audio.

Per iniziare, definire l'input e inizializzare TranslationRecognizer:

const translator = new TranslationRecognizer(speechTranslationConfig);

Verranno sottoscritti gli eventi inviati da TranslationRecognizer.

  • recognizing: Segnale per gli eventi contenenti i risultati della traduzione intermedia.
  • recognized: Segnale per gli eventi contenenti i risultati finali della traduzione (che indicano un tentativo di conversione riuscito).
  • sessionStopped: Segnale per gli eventi che indicano la fine di una sessione di traduzione (operazione).
  • canceled: Segnale per gli eventi contenenti i risultati della traduzione annullata (indicante un tentativo di conversione annullato come risultato o una richiesta di annullamento diretta o, in alternativa, un errore di trasporto o di protocollo).
recognizer.recognizing = (s, e) => {
    console.log(`TRANSLATING: Text=${e.result.text}`);
};
recognizer.recognized = (s, e) => {
    if (e.result.reason == ResultReason.RecognizedSpeech) {
        console.log(`TRANSLATED: Text=${e.result.text}`);
    }
    else if (e.result.reason == ResultReason.NoMatch) {
        console.log("NOMATCH: Speech could not be translated.");
    }
};
recognizer.canceled = (s, e) => {
    console.log(`CANCELED: Reason=${e.reason}`);
    if (e.reason == CancellationReason.Error) {
        console.log(`"CANCELED: ErrorCode=${e.errorCode}`);
        console.log(`"CANCELED: ErrorDetails=${e.errorDetails}`);
        console.log("CANCELED: Did you update the subscription info?");
    }
    recognizer.stopContinuousRecognitionAsync();
};
recognizer.sessionStopped = (s, e) => {
    console.log("\n    Session stopped event.");
    recognizer.stopContinuousRecognitionAsync();
};

Con tutti gli elementi configurati, è possibile chiamare startContinuousRecognitionAsync.

// Starts continuous recognition. Uses stopContinuousRecognitionAsync() to stop recognition.
recognizer.startContinuousRecognitionAsync();
// Something later can call, stops recognition.
// recognizer.StopContinuousRecognitionAsync();

Scegliere una lingua di origine

Un'attività comune per la traduzione vocale è la specifica della lingua di input (o di origine). Vediamo come cambiare la lingua di input in italiano. Nel codice trovare il SpeechTranslationConfig e quindi aggiungere la riga seguente direttamente sotto di essa.

speechTranslationConfig.speechRecognitionLanguage = "it-IT";

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

Scegliere una o più lingue di destinazione

L'SDK vocale può tradurre in più lingue di destinazione in parallelo. Le lingue di destinazione disponibili sono leggermente diverse dall'elenco della lingua di origine e si specificano le lingue di destinazione usando un codice di lingua, anziché le impostazioni locali. Per un elenco dei codici di lingua per le destinazioni di testo, vedere la tabella traduzione vocale nella pagina supporto per la lingua. È anche possibile trovare informazioni dettagliate sulla traduzione in linguaggi sintetizzati.

Il codice seguente aggiunge il tedesco come lingua di destinazione:

translationConfig.addTargetLanguage("de");

Poiché sono possibili più traduzioni della lingua di destinazione, il codice deve specificare la lingua di destinazione quando si esamina il risultato. Il codice seguente ottiene i risultati della traduzione per il tedesco.

recognizer.recognized = function (s, e) {
    var str = "\r\n(recognized)  Reason: " +
            sdk.ResultReason[e.result.reason] +
            " Text: " + e.result.text + " Translations:";
    var language = "de";
    str += " [" + language + "] " + e.result.translations.get(language);
    str += "\r\n";
    // show str somewhere
};

Una delle funzionalità principali del servizio di riconoscimento vocale è la possibilità di riconoscere la voce umana e tradurla in altre lingue. Questa Guida introduttiva illustra come usare l'SDK di riconoscimento vocale nelle app e nei prodotti per eseguire la traduzione vocale di alta qualità. Questa Guida introduttiva illustra gli argomenti tra cui:

  • Conversione vocale in testo
  • Conversione di riconoscimento vocale in più lingue di destinazione
  • Esecuzione della traduzione vocale diretta

Passare agli esempi su GitHub

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

Prerequisiti

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

Installare Speech SDK

Prima di poter eseguire qualsiasi operazione, è necessario installare Speech SDK. A seconda della piattaforma, seguire le istruzioni riportate nella sezione Get The Speech SDK dell'articolo About The Speech SDK .

Importare le dipendenze

Per eseguire gli esempi in questo articolo, includere le import istruzioni seguenti all'inizio del file di codice Python.

import os
import azure.cognitiveservices.speech as speechsdk

Variabili di ambiente e dati sensibili

Il codice sorgente di esempio in questo articolo dipende dalle variabili di ambiente per l'archiviazione di dati sensibili, ad esempio la chiave di sottoscrizione della risorsa vocale e l'area. Il file di codice Python contiene due valori assegnati dalle variabili di ambiente dei computer host, ovvero SPEECH__SUBSCRIPTION__KEY e SPEECH__SERVICE__REGION . Entrambe queste variabili si trovano nell'ambito globale, rendendole accessibili entro la definizione di funzione del file di codice. Per altre informazioni sulle variabili di ambiente, vedere variabili di ambiente e configurazione dell'applicazione.

speech_key, service_region = os.environ['SPEECH__SUBSCRIPTION__KEY'], os.environ['SPEECH__SERVICE__REGION']

Creare una configurazione di traduzione vocale

Per chiamare il servizio Voce con Speech SDK, è necessario creare una classe SpeechTranslationConfig. Questa classe include informazioni sulla sottoscrizione, ad esempio la chiave e l'area associata, l'endpoint, l'host o il token di autorizzazione.

Suggerimento

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

Esistono diversi modi per inizializzare SpeechTranslationConfig:

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

Vediamo come viene creata una classe SpeechTranslationConfig usando una chiave e un'area. Per ottenere queste credenziali, seguire la procedura descritta in Provare il servizio Voce gratuitamente.

from_language, to_language = 'en-US', 'de'

def translate_speech_to_text():
    translation_config = speechsdk.translation.SpeechTranslationConfig(
            subscription=speech_key, region=service_region)

Cambiare la lingua di origine

Una delle attività comuni della traduzione vocale è la specifica della lingua di input (o di origine). Vediamo come cambiare la lingua di input in italiano. Nel codice interagire con l' SpeechTranslationConfig istanza, assegnando alla speech_recognition_language Proprietà.

def translate_speech_to_text():
    translation_config = speechsdk.translation.SpeechTranslationConfig(
            subscription=speech_key, region=service_region)

    # Source (input) language
    translation_config.speech_recognition_language = from_language

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

Aggiungi lingua di traduzione

Un'altra attività comune di traduzione vocale è quella di specificare i linguaggi di traduzione di destinazione, almeno uno è obbligatorio ma sono supportati più multipli. Il frammento di codice seguente imposta sia il francese che il tedesco come destinazioni del linguaggio di traduzione.

def translate_speech_to_text():
    translation_config = speechsdk.translation.SpeechTranslationConfig(
            subscription=speech_key, region=service_region)

    translation_config.speech_recognition_language = "it-IT"

    # Translate to languages. See, https://aka.ms/speech/sttt-languages
    translation_config.add_target_language("fr")
    translation_config.add_target_language("de")

Con ogni chiamata a add_target_language , viene specificato un nuovo linguaggio di conversione di destinazione. In altre parole, quando la voce vocale viene riconosciuta dalla lingua di origine, ogni conversione di destinazione è disponibile come parte dell'operazione di conversione risultante.

Inizializzare un riconoscimento di traduzione

Dopo aver creato una classe SpeechTranslationConfig, il passaggio successivo consiste nell'inizializzare TranslationRecognizer. Quando si Inizializza TranslationRecognizer, sarà necessario passare translation_config. L'oggetto di configurazione fornisce le credenziali richieste dal servizio di riconoscimento vocale per convalidare la richiesta.

Se si esegue il riconoscimento vocale usando il microfono predefinito del dispositivo, TranslationRecognizer avrà questo aspetto:

def translate_speech_to_text():
    translation_config = speechsdk.translation.SpeechTranslationConfig(
            subscription=speech_key, region=service_region)

    translation_config.speech_recognition_language = from_language
    translation_config.add_target_language(to_language)

    recognizer = speechsdk.translation.TranslationRecognizer(
            translation_config=translation_config)

Se si vuole specificare il dispositivo di input audio, è necessario creare AudioConfig e specificare il parametro audio_config quando si inizializza TranslationRecognizer.

In primo luogo, si farà riferimento all' AudioConfig oggetto come segue:

def translate_speech_to_text():
    translation_config = speechsdk.translation.SpeechTranslationConfig(
            subscription=speech_key, region=service_region)

    translation_config.speech_recognition_language = from_language
    for lang in to_languages:
        translation_config.add_target_language(lang)

    audio_config = speechsdk.audio.AudioConfig(use_default_microphone=True)
    recognizer = speechsdk.translation.TranslationRecognizer(
            translation_config=translation_config, audio_config=audio_config)

Se si vuole specificare un file audio invece di usare un microfono, è comunque necessario fornire audioConfig. Tuttavia, quando si crea un oggetto AudioConfig , invece di chiamare con use_default_microphone=True , si chiamerà con filename="path-to-file.wav" e si fornirà il filename parametro.

def translate_speech_to_text():
    translation_config = speechsdk.translation.SpeechTranslationConfig(
            subscription=speech_key, region=service_region)

    translation_config.speech_recognition_language = from_language
    for lang in to_languages:
        translation_config.add_target_language(lang)

    audio_config = speechsdk.audio.AudioConfig(filename="path-to-file.wav")
    recognizer = speechsdk.translation.TranslationRecognizer(
            translation_config=translation_config, audio_config=audio_config)

Traduzione vocale

Per tradurre la voce, l'SDK di riconoscimento vocale si basa su un microfono o un input di file audio. Il riconoscimento vocale si verifica prima della traduzione vocale. Dopo l'inizializzazione di tutti gli oggetti, chiamare la funzione Recognize-once e ottenere il risultato.

import os
import azure.cognitiveservices.speech as speechsdk

speech_key, service_region = os.environ['SPEECH__SERVICE__KEY'], os.environ['SPEECH__SERVICE__REGION']
from_language, to_languages = 'en-US', 'de'

def translate_speech_to_text():
    translation_config = speechsdk.translation.SpeechTranslationConfig(
            subscription=speech_key, region=service_region)

    translation_config.speech_recognition_language = from_language
    translation_config.add_target_language(to_language)

    recognizer = speechsdk.translation.TranslationRecognizer(
            translation_config=translation_config)
    
    print('Say something...')
    result = recognizer.recognize_once()
    print(get_result_text(reason=result.reason, result=result))

def get_result_text(reason, result):
    reason_format = {
        speechsdk.ResultReason.TranslatedSpeech:
            f'RECOGNIZED "{from_language}": {result.text}\n' +
            f'TRANSLATED into "{to_language}"": {result.translations[to_language]}',
        speechsdk.ResultReason.RecognizedSpeech: f'Recognized: "{result.text}"',
        speechsdk.ResultReason.NoMatch: f'No speech could be recognized: {result.no_match_details}',
        speechsdk.ResultReason.Canceled: f'Speech Recognition canceled: {result.cancellation_details}'
    }
    return reason_format.get(reason, 'Unable to recognize speech')

translate_speech_to_text()

Per ulteriori informazioni sulla sintesi vocale, vedere le nozioni di base del riconoscimento vocale.

Sintetizza le traduzioni

Dopo un riconoscimento vocale e una traduzione con esito positivo, il risultato contiene tutte le traduzioni in un dizionario. La translations chiave del dizionario è il linguaggio di conversione di destinazione e il valore è il testo tradotto. Il riconoscimento vocale riconosciuto può essere convertito, quindi sintetizzato in un linguaggio diverso (sintesi vocale).

Sintesi basata su eventi

L' TranslationRecognizer oggetto espone un Synthesizing evento. L'evento viene generato più volte e fornisce un meccanismo per recuperare l'audio sintetizzato dal risultato del riconoscimento della traduzione. Se si esegue la conversione in più lingue, vedere sintesi manuale. Specificare la voce di sintesi assegnando un oggetto voice_name e fornire un gestore eventi per l' Synthesizing evento, ottenere l'audio. Nell'esempio seguente viene salvato l'audio tradotto come file WAV .

Importante

La sintesi basata su eventi funziona solo con una singola traduzione. non aggiungere più lingue di traduzione di destinazione. Inoltre, voice_name deve essere la stessa lingua del linguaggio di traduzione di destinazione, ad esempio "de" . può eseguire il mapping a "de-DE-Hedda" .

import os
import azure.cognitiveservices.speech as speechsdk

speech_key, service_region = os.environ['SPEECH__SERVICE__KEY'], os.environ['SPEECH__SERVICE__REGION']
from_language, to_language = 'en-US', 'de'

def translate_speech_to_text():
    translation_config = speechsdk.translation.SpeechTranslationConfig(
            subscription=speech_key, region=service_region)

    translation_config.speech_recognition_language = from_language
    translation_config.add_target_language(to_language)

    # See: https://aka.ms/speech/sdkregion#standard-and-neural-voices
    translation_config.voice_name = "de-DE-Hedda"

    recognizer = speechsdk.translation.TranslationRecognizer(
            translation_config=translation_config)

    def synthesis_callback(evt):
        size = len(evt.result.audio)
        print(f'Audio synthesized: {size} byte(s) {"(COMPLETED)" if size == 0 else ""}')

        if size > 0:
            file = open('translation.wav', 'wb+')
            file.write(evt.result.audio)
            file.close()

    recognizer.synthesizing.connect(synthesis_callback)

    print(f'Say something in "{from_language}" and we\'ll translate into "{to_language}".')

    result = recognizer.recognize_once()
    print(get_result_text(reason=result.reason, result=result))

def get_result_text(reason, result):
    reason_format = {
        speechsdk.ResultReason.TranslatedSpeech:
            f'Recognized "{from_language}": {result.text}\n' +
            f'Translated into "{to_language}"": {result.translations[to_language]}',
        speechsdk.ResultReason.RecognizedSpeech: f'Recognized: "{result.text}"',
        speechsdk.ResultReason.NoMatch: f'No speech could be recognized: {result.no_match_details}',
        speechsdk.ResultReason.Canceled: f'Speech Recognition canceled: {result.cancellation_details}'
    }
    return reason_format.get(reason, 'Unable to recognize speech')

translate_speech_to_text()

Sintesi manuale

Il translations dizionario può essere usato per sintetizzare l'audio dal testo di traduzione. Scorrere ogni traduzione e sintetizzare la traduzione. Quando si crea un' SpeechSynthesizer istanza, l' SpeechConfig oggetto deve avere la speech_synthesis_voice_name proprietà impostata sulla voce desiderata. Nell'esempio seguente viene convertito in cinque lingue e ogni conversione viene quindi sintetizzata in un file audio nel linguaggio neurale corrispondente.

import os
import azure.cognitiveservices.speech as speechsdk

speech_key, service_region = os.environ['SPEECH__SERVICE__KEY'], os.environ['SPEECH__SERVICE__REGION']
from_language, to_languages = 'en-US', [ 'de', 'en', 'it', 'pt', 'zh-Hans' ]

def translate_speech_to_text():
    translation_config = speechsdk.translation.SpeechTranslationConfig(
            subscription=speech_key, region=service_region)

    translation_config.speech_recognition_language = from_language
    for lang in to_languages:
        translation_config.add_target_language(lang)

    recognizer = speechsdk.translation.TranslationRecognizer(
            translation_config=translation_config)
    
    print('Say something...')
    result = recognizer.recognize_once()
    synthesize_translations(result=result)

def synthesize_translations(result):
    language_to_voice_map = {
        "de": "de-DE-KatjaNeural",
        "en": "en-US-AriaNeural",
        "it": "it-IT-ElsaNeural",
        "pt": "pt-BR-FranciscaNeural",
        "zh-Hans": "zh-CN-XiaoxiaoNeural"
    }
    print(f'Recognized: "{result.text}"')

    for language in result.translations:
        translation = result.translations[language]
        print(f'Translated into "{language}": {translation}')

        speech_config = speechsdk.SpeechConfig(subscription=speech_key, region=service_region)
        speech_config.speech_synthesis_voice_name = language_to_voice_map.get(language)
        
        audio_config = speechsdk.audio.AudioOutputConfig(filename=f'{language}-translation.wav')
        speech_synthesizer = speechsdk.SpeechSynthesizer(speech_config=speech_config, audio_config=audio_config)
        speech_synthesizer.speak_text_async(translation).get()

translate_speech_to_text()

Per ulteriori informazioni sulla sintesi vocale, vedere le nozioni di base sulla sintesi vocale.

Una delle funzionalità principali del servizio di riconoscimento vocale è la possibilità di riconoscere la voce umana e tradurla in altre lingue. Questa Guida introduttiva illustra come usare l'SDK di riconoscimento vocale nelle app e nei prodotti per eseguire la traduzione vocale di alta qualità. Questa Guida introduttiva converte il riconoscimento vocale dal microfono in testo in un'altra lingua.

Prerequisiti

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

Download e installazione

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

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

  2. Installare .NET Core 3.1 SDK.

  3. Installare l'interfaccia della riga di comando di Voce usando NuGet immettendo questo comando:

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

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

Nota

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

Limitazioni dei tipi di carattere

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

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

Creare la configurazione della sottoscrizione

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

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

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

Imposta lingua di origine e di destinazione

Questo comando chiama l'interfaccia della riga di comando vocale per tradurre la voce dal microfono dall'italiano al francese.

 spx translate --microphone --source it-IT --target fr

Passaggi successivi