Začínáme s překladem řeči

Článek
11/04/2021
41 min ke čtení

Jednou ze základních funkcí služby Speech je schopnost rozpoznávat lidskou řeč a překládat ji do jiných jazyků. V tomto rychlém startu se dozvíte, jak pomocí sady Speech SDK v aplikacích a produktech provádět vysoce kvalitní překlad řeči. Tento rychlý start se zabývá tématy, mezi která patří:

Překlad řeči na text
Překlad řeči do více cílových jazyků
Provádění přímého překladu řeči na řeč

Pokud chcete přeskočit přímo na ukázkový kód, podívejte se na ukázky rychlého startu pro C# na GitHub.

Požadavky

Tento článek předpokládá, že máte účet Azure a předplatné služby Speech. Pokud nemáte účet a předplatné, vyzkoušejte si službu Speech zdarma.

Instalace sady Speech SDK

Než budete moci cokoli udělat, budete si muset nainstalovat sadu Speech SDK. V závislosti na vaší platformě postupujte podle pokynů v části Získání sady Speech SDK článku Informace o sadě Speech SDK.

Import závislostí

Příklady v tomto článku spustíte tak, že na začátek souboru using Program.cs zahrníte následující příkazy.

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;

Citlivá data a proměnné prostředí

Příklad zdrojového kódu v tomto článku závisí na proměnných prostředí pro ukládání citlivých dat, jako je klíč předplatného prostředků služby Speech a oblast. Třída Program obsahuje dvě static readonly string hodnoty, které jsou přiřazeny z proměnných prostředí hostitelských počítačů, konkrétně a SPEECH__SUBSCRIPTION__KEY SPEECH__SERVICE__REGION . Obě tato pole jsou v oboru třídy, takže jsou přístupná v tělech metody třídy. Další informace o proměnných prostředí najdete v tématu proměnné prostředí a konfiguraci aplikace.

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

Vytvoření konfigurace překladu řeči

Pokud chcete volat službu Speech pomocí sady Speech SDK, musíte vytvořit SpeechTranslationConfig . Tato třída obsahuje informace o vašem předplatném, jako je klíč a přidružená oblast, koncový bod, hostitel nebo autorizační token.

Tip

Bez ohledu na to, jestli provádíte rozpoznávání řeči, syntézu řeči, překlad nebo rozpoznávání záměru, vždy vytvoříte konfiguraci.

Existuje několik způsobů, jak můžete inicializovat SpeechTranslationConfig :

S předplatným: Předejte klíč a přidruženou oblast.
S koncovým bodem: Předání koncového bodu služby Speech Klíč nebo autorizační token je volitelný.
S hostitelem: předejte adresu hostitele. Klíč nebo autorizační token je volitelný.
S autorizačním tokenem: předejte autorizační token a přidruženou oblast.

Pojďme se podívat, jak se vytvoří SpeechTranslationConfig objekt pomocí klíče a oblasti. Získejte tyto přihlašovací údaje podle pokynů v článku Vyzkoušejte si službu Speech zdarma.

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

Změna zdrojového jazyka

Jedním z běžných úkolů překladu řeči je určení vstupního (nebo zdrojového) jazyka. Podívejme se, jak byste změnili vstupní jazyk na italštinu. V kódu interagujete s SpeechTranslationConfig instancí a přiřazujete ji k SpeechRecognitionLanguage vlastnosti .

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

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

Vlastnost SpeechRecognitionLanguage očekává řetězec formátu národního prostředí jazyka. Ve sloupci Národní prostředí v seznamu podporovaných národního prostředí nebo jazyků můžete zadat libovolnou hodnotu.

Přidání jazyka překladu

Dalším běžným úkolem překladu řeči je určení cílových jazyků překladu, vyžaduje se alespoň jeden, ale použití více jazyků je podporováno. Následující fragment kódu nastaví jako cíle jazyka překladu francouzštinu i němčinu.

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

Při každém volání AddTargetLanguage metody je zadán nový cílový jazyk překladu. Jinými slovy, když je řeč rozpoznána ze zdrojového jazyka, je každý cílový překlad dostupný jako součást výsledné operace překladu.

Inicializace rozpoznávání překladu

Po vytvoření objektu SpeechTranslationConfig je dalším krokem inicializace TranslationRecognizer . Při inicializaci TranslationRecognizer objektu budete muset předat . translationConfig Objekt konfigurace poskytuje přihlašovací údaje, které služba Speech vyžaduje k ověření vašeho požadavku.

Pokud rozpoznáte řeč pomocí výchozího mikrofonu vašeho zařízení, měl by vypadat TranslationRecognizer tento kód:

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

Pokud chcete zadat vstupní zvukové zařízení, budete muset při inicializaci objektu vytvořit a zadat AudioConfig audioConfig parametr TranslationRecognizer .

Tip

Zjistěte, jak získat ID zařízení pro vstupní zvukové zařízení.

Nejprve budete odkazovat na AudioConfig objekt následujícím způsobem:

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

Pokud místo mikrofonu chcete zadat zvukový soubor, budete pořád muset zadat audioConfig . Když ale vytvoříte objekt , místo abyste volali , zavoláte a AudioConfig FromDefaultMicrophoneInput FromWavFileInput předáte filename parametr .

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

Překlad řeči

Při překladu řeči sada Speech SDK spoléhá na vstup mikrofonu nebo zvukového souboru. Rozpoznávání řeči probíhá před překladem řeči. Po inicializaci všech objektů zavolejte funkci recognize-once a získejte výsledek.

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

Další informace o převodu řeči na text najdete v základech rozpoznávání řeči.

Syntetizovat překlady

Po úspěšném rozpoznávání a překladu řeči obsahuje výsledek všechny překlady ve slovníku. Klíč Translations slovníku je cílový jazyk překladu a hodnota je přeložený text. Rozpoznanou řeč lze přeložit a pak syntetizovat v jiném jazyce (převod řeči na řeč).

Syntéza na základě událostí

Objekt TranslationRecognizer zpřístupňuje Synthesizing událost. Událost se několikrát shodí a poskytuje mechanismus pro načtení syntetizovaného zvuku z výsledku rozpoznávání překladu. Pokud překládáte do více jazyků, podívejte se na ruční syntézu. Určení syntézy hlasu přiřazením a poskytnutím obslužné rutiny události pro VoiceName Synthesizing událost, získání zvuku. Následující příklad uloží přeložený zvuk jako soubor .wav.

Důležité

Syntéza založená na událostech funguje pouze s jedním překladem, nepřidá více cílových jazyků překladu. Kromě toho by měl být stejný jazyk jako cílový jazyk překladu, například by VoiceName "de" se mohl namapovat na "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]}");
    }
}

Ruční syntéza

Slovník Translations lze použít k syntetizovat zvuk z textu překladu. Iteruje jednotlivými překlady a syntetizuje překlad. Při vytváření SpeechSynthesizer instance musí mít objekt vlastnost SpeechConfig SpeechSynthesisVoiceName nastavenou na požadovaný hlas. Následující příklad se přeloží do pěti jazyků a každý překlad se pak syntetizuje do zvukového souboru v odpovídajícím neurálním jazyce.

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

Další informace o syntéze řeči najdete v tématu Základy syntézy řeči.

Vícejazyčný překlad s identifikací jazyka

V mnoha scénářích možná nevíte, které vstupní jazyky je třeba zadat. Pomocí identifikace jazyka můžete zadat až deset možných vstupních jazyků a automaticky je přeložit do cílových jazyků.

Následující příklad používá průběžný překlad ze zvukového souboru a automaticky rozpozná vstupní jazyk, i když se mluvený jazyk mění. Když spustíte ukázku a automaticky se en-US detekuje, zh-CN protože jsou definované v AutoDetectSourceLanguageConfig . Potom se řeč přeloží na a , de jak je uvedeno ve fr voláních metody AddTargetLanguage() .

Důležité

Tato funkce je aktuálně ve verzi Preview.

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

Překlad řeči na text
Překlad řeči do více cílových jazyků
Provádění přímého překladu řeči na řeč

Pokud chcete přeskočit přímo na ukázkový kód, podívejte se na ukázky rychlého startu pro C++ na GitHub.

Požadavky

Tento článek předpokládá, že máte účet Azure a předplatné služby Speech. Pokud nemáte účet a předplatné, vyzkoušejte si službu Speech zdarma.

Instalace sady Speech SDK

Import závislostí

Příklady v tomto článku spustíte tak, že na začátek souboru kódu C++ zahrníte #include using následující příkazy a .

#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;

Citlivá data a proměnné prostředí

Příklad zdrojového kódu v tomto článku závisí na proměnných prostředí pro ukládání citlivých dat, jako je klíč předplatného prostředků služby Speech a oblast. Soubor kódu C++ obsahuje dvě řetězcové hodnoty, které jsou přiřazeny z proměnných prostředí hostitelských počítačů, konkrétně a SPEECH__SUBSCRIPTION__KEY SPEECH__SERVICE__REGION . Obě tato pole jsou v oboru třídy, takže jsou přístupná v tělech metody třídy. Další informace o proměnných prostředí najdete v tématu proměnné prostředí a konfiguraci aplikace.

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

Vytvoření konfigurace překladu řeči

Tip

Bez ohledu na to, jestli provádíte rozpoznávání řeči, syntézu řeči, překlad nebo rozpoznávání záměru, vždy vytvoříte konfiguraci.

Existuje několik způsobů, jak můžete inicializovat SpeechTranslationConfig :

S předplatným: Předejte klíč a přidruženou oblast.
S koncovým bodem: Předání koncového bodu služby Speech Klíč nebo autorizační token je volitelný.
S hostitelem: předejte adresu hostitele. Klíč nebo autorizační token je volitelný.
S autorizačním tokenem: předejte autorizační token a přidruženou oblast.

Pojďme se podívat, jak se vytvoří SpeechTranslationConfig objekt pomocí klíče a oblasti. Získejte tyto přihlašovací údaje podle pokynů v článku Vyzkoušejte si službu Speech zdarma.

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

Změna zdrojového jazyka

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

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

Přidání jazyka překladu

Dalším běžným úkolem překladu řeči je určení cílových jazyků překladu. Vyžaduje se alespoň jeden, ale podporují se násobky. Následující fragment kódu nastaví jako cíle jazyka překladu francouzštinu i němčinu.

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

Inicializace rozpoznávání překladu

Pokud rozpoznáte řeč pomocí výchozího mikrofonu vašeho zařízení, měl by vypadat TranslationRecognizer tento kód:

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

Pokud chcete zadat vstupní zvukové zařízení, budete muset při inicializaci objektu vytvořit a zadat AudioConfig audioConfig parametr TranslationRecognizer .

Tip

Zjistěte, jak získat ID zařízení pro vstupní zvukové zařízení.

Nejprve budete odkazovat na AudioConfig objekt následujícím způsobem:

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

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

Překlad řeči

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

Další informace o převodu řeči na text najdete v základech rozpoznávání řeči.

Syntetizovat překlady

Syntéza na základě událostí

Objekt TranslationRecognizer zpřístupňuje Synthesizing událost. Událost se několikrát shodí a poskytuje mechanismus pro načtení syntetizovaného zvuku z výsledku rozpoznávání překladu. Pokud překládáte do více jazyků, podívejte se na ruční syntézu. Určení syntézy hlasu přiřazením a poskytnutím obslužné rutiny události pro SetVoiceName Synthesizing událost, získání zvuku. Následující příklad uloží přeložený zvuk jako soubor .wav.

Důležité

Syntéza založená na událostech funguje pouze s jedním překladem, nepřidá více cílových jazyků překladu. Kromě toho by měl být stejný jazyk jako cílový jazyk překladu, například by SetVoiceName "de" se mohl namapovat na "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;
        }
    }
}

Ruční syntéza

Slovník Translations lze použít k syntetizovat zvuk z textu překladu. Iteruje jednotlivými překlady a syntetizuje překlad. Při vytváření SpeechSynthesizer instance musí mít objekt vlastnost SpeechConfig SetSpeechSynthesisVoiceName nastavenou na požadovaný hlas. Následující příklad se přeloží do pěti jazyků a každý překlad se pak syntetizuje do zvukového souboru v odpovídajícím neurálním jazyce.

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

Další informace o syntéze řeči najdete v tématu Základy syntézy řeči.

Vícejazyčný překlad s identifikací jazyka

Důležité

Tato funkce je aktuálně ve verzi Preview.

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

Překlad řeči na text
Překlad řeči do více cílových jazyků
Provádění přímého překladu řeči na řeč

Pokud chcete přeskočit přímo na ukázkový kód, podívejte se na ukázky rychlého startu pro Javu na GitHub.

Požadavky

Tento článek předpokládá, že máte účet Azure a předplatné služby Speech. Pokud nemáte účet a předplatné, vyzkoušejte si službu Speech zdarma.

Instalace sady Speech SDK

Import závislostí

Příklady v tomto článku spustíte tak, že na začátek * zahrníte import následující příkazy. Soubor kódu 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.*;

Citlivá data a proměnné prostředí

Příklad zdrojového kódu v tomto článku závisí na proměnných prostředí pro ukládání citlivých dat, jako je klíč předplatného prostředků služby Speech a oblast. Soubor kódu Java obsahuje dvě static final String hodnoty, které jsou přiřazené z proměnných prostředí hostitelských počítačů, konkrétně SPEECH__SUBSCRIPTION__KEY a SPEECH__SERVICE__REGION . Obě tato pole jsou v oboru třídy, takže jsou přístupná v tělech metody třídy. Další informace o proměnných prostředí najdete v tématu proměnné prostředí a konfiguraci aplikace.

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

Vytvoření konfigurace překladu řeči

Tip

Bez ohledu na to, jestli provádíte rozpoznávání řeči, syntézu řeči, překlad nebo rozpoznávání záměru, vždy vytvoříte konfiguraci.

Existuje několik způsobů, jak můžete inicializovat SpeechTranslationConfig :

S předplatným: Předejte klíč a přidruženou oblast.
S koncovým bodem: Předání koncového bodu služby Speech Klíč nebo autorizační token je volitelný.
S hostitelem: předejte adresu hostitele. Klíč nebo autorizační token je volitelný.
S autorizačním tokenem: předejte autorizační token a přidruženou oblast.

Pojďme se podívat, jak se vytvoří SpeechTranslationConfig objekt pomocí klíče a oblasti. Získejte tyto přihlašovací údaje podle pokynů v článku Vyzkoušejte si službu Speech zdarma.

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

Změna zdrojového jazyka

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

Funkce setSpeechRecognitionLanguage očekává řetězec formátu národního prostředí jazyka. Ve sloupci Národní prostředí v seznamu podporovaných národního prostředí nebo jazyků můžete zadat libovolnou hodnotu.

Přidání jazyka překladu

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

Při každém volání addTargetLanguage metody je zadán nový cílový jazyk překladu. Jinými slovy, když je řeč rozpoznána ze zdrojového jazyka, je každý cílový překlad dostupný jako součást výsledné operace překladu.

Inicializace rozpoznávání překladu

Pokud rozpoznáte řeč pomocí výchozího mikrofonu vašeho zařízení, měl by vypadat TranslationRecognizer tento kód:

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

Pokud chcete zadat vstupní zvukové zařízení, budete muset při inicializaci objektu vytvořit a zadat AudioConfig audioConfig parametr TranslationRecognizer .

Tip

Zjistěte, jak získat ID zařízení pro vstupní zvukové zařízení.

Nejprve budete odkazovat na AudioConfig objekt následujícím způsobem:

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

Pokud místo mikrofonu chcete zadat zvukový soubor, budete pořád muset zadat audioConfig . Když ale vytvoříte objekt , místo abyste volali , zavoláte a AudioConfig fromDefaultMicrophoneInput fromWavFileInput předáte filename parametr .

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

Překlad řeči

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

Další informace o převodu řeči na text najdete v základech rozpoznávání řeči.

Syntetizovat překlady

Po úspěšném rozpoznávání a překladu řeči obsahuje výsledek všechny překlady ve slovníku. Funkce getTranslations vrátí slovník s klíčem jako cílovým jazykem překladu a hodnotou je přeložený text. Rozpoznanou řeč lze přeložit a pak syntetizovat v jiném jazyce (převod řeči na řeč).

Syntéza na základě událostí

Objekt TranslationRecognizer zpřístupňuje synthesizing událost. Událost se několikrát vyhodí a poskytuje mechanismus pro načtení syntetizovaného zvuku z výsledku rozpoznávání překladu. Pokud překládáte do více jazyků, podívejte se na ruční syntézu. Určení syntézy hlasu přiřazením a poskytnutím obslužné rutiny události pro setVoiceName synthesizing událost, získání zvuku. Následující příklad uloží přeložený zvuk jako soubor .wav.

Důležité

Syntéza založená na událostech funguje pouze s jedním překladem, nepřidá více cílových jazyků překladu. Kromě toho by měl být stejný jazyk jako cílový jazyk překladu, například by setVoiceName "de" se mohl namapovat na "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);
            }
        }
    }
}

Ruční syntéza

Funkce getTranslations vrátí slovník, který lze použít k syntetizovat zvuk z textu překladu. Iteruje jednotlivými překlady a syntetizuje překlad. Při vytváření SpeechSynthesizer instance musí mít objekt vlastnost SpeechConfig setSpeechSynthesisVoiceName nastavenou na požadovaný hlas. Následující příklad se přeloží do pěti jazyků a každý překlad se pak syntetizuje do zvukového souboru v odpovídajícím neurálním jazyce.

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

Další informace o syntéze řeči najdete v tématu Základy syntézy řeči.

Jednou ze základních funkcí služby Speech je schopnost rozpoznávat lidské rozpoznávání a překládat ho do jiných jazyků. V tomto rychlém startu se naučíte používat sadu Speech SDK ve vašich aplikacích a produktech k provádění vysoce kvalitního překladu řeči. Tento rychlý Start popisuje témata, včetně:

Převod řeči na text
Překlad řeči na více cílových jazyků
Přímá překlady řeči na řeč

Pokud chcete přeskočit přímý na vzorový kód, přečtěte si ukázky rychlý Start JavaScriptu na GitHub.

Požadavky

V tomto článku se předpokládá, že máte účet Azure a předplatné služby Speech. Pokud účet a předplatné nemáte, Vyzkoušejte službu Speech Service zdarma.

Instalace sady Speech SDK

Předtím, než můžete cokoli udělat, musíte nainstalovat sadu Speech SDK pro JavaScript . V závislosti na vaší platformě postupujte podle následujících pokynů:

V závislosti na cílovém prostředí navíc použijte jednu z následujících možností:

Stáhněte a extrahujte sadu Speech SDK pro JavaScript microsoft.cognitiveservices.speech.sdk.bundle.js soubor a umístěte ji do složky přístupné pro váš soubor HTML.

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

Tip

Pokud cílíte na webový prohlížeč a použijete <script> značku; sdk Předpona není nutná. sdkPředpona je alias použitý k pojmenování require modulu.

import * from "microsoft-cognitiveservices-speech-sdk";

Další informace o najdete v import tématu Export a import .

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

Další informace o najdete v require tématu co je potřeba? .

Vytvořit konfiguraci překladu

Chcete-li volat službu překladu pomocí sady Speech SDK, je nutné vytvořit SpeechTranslationConfig . Tato třída obsahuje informace o vašem předplatném, jako je klíč a přidružená oblast, koncový bod, hostitel nebo autorizační token.

Poznámka

Bez ohledu na to, jestli provádíte rozpoznávání řeči, syntézu řeči, překlad nebo rozpoznávání záměrů, vždy vytvoříte konfiguraci. Existuje několik způsobů, jak můžete inicializovat SpeechTranslationConfig :

S předplatným: předejte klíč a přidruženou oblast.
S koncovým bodem: předejte koncový bod služby řeči. Klíč nebo autorizační token jsou volitelné.
S hostitelem: předejte adresu hostitele. Klíč nebo autorizační token jsou volitelné.
Pomocí autorizačního tokenu: předejte autorizační token a přidruženou oblast.

Pojďme se podívat, jak SpeechTranslationConfig se vytvoří pomocí klíče a oblasti. Tyto přihlašovací údaje můžete získat podle kroků v části Vyzkoušejte si službu Speech Service zdarma.

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

Inicializovat překladatele

Po vytvoření SpeechTranslationConfig je dalším krokem inicializace TranslationRecognizer . Když inicializujete TranslationRecognizer , budete ho muset předat speechTranslationConfig . To poskytuje přihlašovací údaje, které služba překladu vyžaduje k ověření vaší žádosti.

Pokud překládáte řeč poskytované prostřednictvím výchozího mikrofonu vašeho zařízení, TranslationRecognizer mělo by to vypadat takto:

const translator = new TranslationRecognizer(speechTranslationConfig);

Pokud chcete zadat vstupní zvukové zařízení, budete muset vytvořit AudioConfig a zadat audioConfig parametr při inicializaci TranslationRecognizer .

Tip

Přečtěte si, Jak získat ID zařízení pro vstupní zvukové zařízení. Odkazujte na AudioConfig objekt následujícím způsobem:

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

Pokud chcete místo používání mikrofonu zadat zvukový soubor, budete ho muset ještě zadat audioConfig . To však lze provést pouze v případě cílení na Node.js a při vytváření AudioConfig namísto volání fromDefaultMicrophoneInput volání fromWavFileOutput a předání filename parametru.

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

Překlad řeči

Třída TranslationRecognizer pro sadu Speech SDK pro JavaScript zpřístupňuje několik metod, které můžete použít pro překlad řeči.

Při počátečním překladu (asynchronní) – provádí převod v neblokujícím (asynchronním) režimu. Tím se přeloží jeden utterance. Konec jednoho utterance se určuje tak, že naslouchá tichému ukončení na konci nebo dokud se nezpracovává po dobu 15 sekund zvuku.
Průběžný překlad (asynchronní) – asynchronně iniciuje operaci průběžného překladu. Uživatel zaregistruje události do událostí a zpracuje různé stavy aplikací. Pro zastavení asynchronního průběžného překladu volejte stopContinuousRecognitionAsync .

Poznámka

Přečtěte si další informace o tom, jak zvolit režim rozpoznávání řeči.

Zadejte cílový jazyk.

Chcete-li přeložit, je nutné zadat zdrojový jazyk a alespoň jeden cílový jazyk. Můžete zvolit zdrojový jazyk pomocí národního prostředí uvedeného v tabulce překladu řeči. Možnosti pro přeložený jazyk najdete na stejném odkazu. Možnosti pro cílové jazyky se liší v případě, že chcete zobrazit text nebo chcete slyšet syntetizované rozpoznávání řeči. Chcete-li přeložit z angličtiny na němčinu, upravte objekt konfigurace překladu:

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

Rozpoznávání při spuštění

Tady je příklad asynchronního překladu při spuštění pomocí recognizeOnceAsync :

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

Pro zpracování výsledku budete muset napsat nějaký kód. Tato ukázka vyhodnocuje result.reason pro překlad do němčiny:

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

Váš kód může také zpracovávat aktualizace poskytované během zpracování překladu. Pomocí těchto aktualizací můžete poskytnout vizuální zpětnou vazbu k průběhu překladu. Podívejte se na Tento JavaScript Node.js příklad pro vzorový kód, který zobrazuje aktualizace poskytované během procesu překladu. Následující kód obsahuje také informace vytvářené během procesu překladu.

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

Průběžný překlad

Průběžný překlad je trochu větší, než rozpoznávání při zahájení. Pro získání výsledků rozpoznávání se vyžaduje přihlášení k odběru recognizing recognized událostí, a canceled . Chcete-li zastavit převod, je nutné zavolat stopContinuousRecognitionAsync . Tady je příklad toho, jak se průběžné překlady provádí na vstupním souboru zvukového vstupu.

Pojďme začít definováním vstupu a inicializací TranslationRecognizer :

const translator = new TranslationRecognizer(speechTranslationConfig);

Přihlásíme se k odběru událostí odeslaných z TranslationRecognizer .

recognizing: Signál pro události obsahující mezilehlé výsledky překladu.
recognized: Signál pro události obsahující konečné výsledky překladu (indikující úspěšný pokus o překlad).
sessionStopped: Signál pro události indikující konec relace překladu (operace).
canceled: Signál pro události obsahující zrušené výsledky překladu (indikující pokus o převod, který se zrušil v důsledku výsledku nebo přímý požadavek na zrušení nebo případně i přenos nebo selhání protokolu).

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

S nastavením všeho můžeme zavolat startContinuousRecognitionAsync .

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

Zvolit zdrojový jazyk

Běžným úkolem překladu řeči je zadání vstupního (nebo zdrojového) jazyka. Pojďme se podívat, jak byste změnili vstupní jazyk na italštinu. V kódu Najděte svůj kód SpeechTranslationConfig a přidejte následující řádek přímo pod něj.

speechTranslationConfig.speechRecognitionLanguage = "it-IT";

speechRecognitionLanguageVlastnost očekává řetězec formátu národního prostředí jazyka. Můžete zadat libovolnou hodnotu ve sloupci locale (národní prostředí ) v seznamu podporovaných národních prostředí a jazyků.

Vyberte jeden nebo více cílových jazyků

Sada Speech SDK umožňuje paralelní převod na více cílových jazyků. Dostupné cílové jazyky se poněkud liší od seznamu zdrojového jazyka a místo národního prostředí určíte cílové jazyky pomocí kódu jazyka. Seznam kódů jazyka pro textové cíle v tabulce překladu řeči najdete na stránce Podpora jazyků. Můžete také vyhledat podrobnosti o překladu na syntetizované jazyky.

Následující kód přidá němčinu jako cílový jazyk:

translationConfig.addTargetLanguage("de");

Vzhledem k tomu, že je možné použít více překladů cílového jazyka, váš kód musí při zkoumání výsledku určit cílový jazyk. Následující kód získá výsledky překladu pro němčinu.

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

Převod řeči na text
Překlad řeči na více cílových jazyků
Přímá překlady řeči na řeč

Pokud chcete přeskočit přímo na vzorový kód, přečtěte si ukázky rychlý Start pro Python na GitHub.

Požadavky

V tomto článku se předpokládá, že máte účet Azure a předplatné služby Speech. Pokud účet a předplatné nemáte, Vyzkoušejte službu Speech Service zdarma.

Instalace sady Speech SDK

Předtím, než můžete cokoli udělat, musíte nainstalovat sadu Speech SDK. V závislosti na vaší platformě postupujte podle pokynů v části získání sady Speech SDK tématu o sadě Speech SDK .

Importovat závislosti

Chcete-li spustit příklady v tomto článku, přidejte následující import příkazy v horní části souboru kódu Pythonu.

import os
import azure.cognitiveservices.speech as speechsdk

Citlivá data a proměnné prostředí

Ukázkový zdrojový kód v tomto článku závisí na proměnných prostředí pro ukládání citlivých dat, jako je klíč a oblast předplatného prostředku pro rozpoznávání řeči. Soubor kódu Pythonu obsahuje dvě hodnoty, které jsou přiřazeny z proměnných prostředí hostitelských počítačů, konkrétně SPEECH__SUBSCRIPTION__KEY a SPEECH__SERVICE__REGION . Obě tyto proměnné jsou v globálním oboru, takže jsou přístupné v rámci definice funkce souboru kódu. Další informace o proměnných prostředí naleznete v tématu proměnné prostředí a konfigurace aplikace.

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

Vytvoření konfigurace překladu řeči

Chcete-li volat službu Speech pomocí sady Speech SDK, je třeba vytvořit SpeechTranslationConfig . Tato třída obsahuje informace o vašem předplatném, jako je klíč a přidružená oblast, koncový bod, hostitel nebo autorizační token.

Tip

Bez ohledu na to, jestli provádíte rozpoznávání řeči, syntézu řeči, překlad nebo rozpoznávání záměrů, vždy vytvoříte konfiguraci.

Existuje několik způsobů, jak můžete inicializovat SpeechTranslationConfig :

S předplatným: předejte klíč a přidruženou oblast.
S koncovým bodem: předejte koncový bod služby řeči. Klíč nebo autorizační token jsou volitelné.
S hostitelem: předejte adresu hostitele. Klíč nebo autorizační token jsou volitelné.
Pomocí autorizačního tokenu: předejte autorizační token a přidruženou oblast.

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

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

Změnit jazyk zdroje

Jedním z běžných úloh překladu řeči je zadání vstupu (nebo zdrojového) jazyka. Pojďme se podívat, jak byste změnili vstupní jazyk na italštinu. Ve vašem kódu můžete pracovat s SpeechTranslationConfig instancí a přiřazovat k speech_recognition_language Vlastnosti.

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

    # Source (input) language
    from_language = "it-IT"
    translation_config.speech_recognition_language = from_language

speech_recognition_languageVlastnost očekává řetězec formátu národního prostředí jazyka. Můžete zadat libovolnou hodnotu ve sloupci locale (národní prostředí ) v seznamu podporovaných národních prostředí a jazyků.

Přidat jazyk překladu

Dalším běžným úkolem překladu řeči je určit cílový jazyk překladu, minimálně jeden je povinný, ale podporují se násobení. Následující fragment kódu nastaví francouzštinu i němčinu jako cíle jazyka překladu.

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

Při každém volání na add_target_language je určen nový cílový jazyk překladu. Jinými slovy, pokud je rozpoznávání řeči rozpoznáno ze zdrojového jazyka, je každý cílový překlad k dispozici jako součást výsledné operace překladu.

Inicializovat Nástroj pro rozpoznávání překladu

Po vytvoření SpeechTranslationConfig je dalším krokem inicializace TranslationRecognizer . Když inicializujete TranslationRecognizer , budete ho muset předat translation_config . Objekt konfigurace poskytuje přihlašovací údaje, které služba Speech vyžaduje k ověření vaší žádosti.

Pokud rozpoznávání řeči rozpoznáte pomocí výchozího mikrofonu vašeho zařízení, TranslationRecognizer mělo by to vypadat takto:

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)

Pokud chcete zadat vstupní zvukové zařízení, budete muset vytvořit AudioConfig a zadat audio_config parametr při inicializaci TranslationRecognizer .

Tip

Přečtěte si, Jak získat ID zařízení pro vstupní zvukové zařízení.

Nejprve na objekt odkazujete následujícím AudioConfig způsobem:

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)

Pokud chcete místo používání mikrofonu zadat zvukový soubor, budete ho muset ještě zadat audioConfig . Pokud však vytvoříte AudioConfig místo volání pomocí use_default_microphone=True , zavoláte filename="path-to-file.wav" a uvedete filename parametr.

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)

Překlad řeči

Při překladu řeči se sada Speech SDK spoléhá na vstup z mikrofonu nebo ze zvukového souboru. Před překladem řeči probíhá rozpoznávání řeči. Po inicializaci všech objektů zavolejte funkci rozpoznávání – jednou a získejte výsledek.

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

Další informace o převodu řeči na text najdete v tématu základy rozpoznávání řeči.

Překlady pro syntetizátory

Po úspěšném rozpoznávání a překladu řeči bude výsledek obsahovat všechny překlady ve slovníku. translationsKlíč slovníku je cílový jazyk překladu a hodnota je přeložený text. Rozpoznanou řeč je možné přeložit a následně syntetizovat v jiném jazyce (překlad řeči na řeč).

Shrnutí založené na událostech

TranslationRecognizerObjekt zpřístupňuje Synthesizing událost. Událost je několikrát aktivována a poskytuje mechanismus pro načtení syntetizového zvuku z výsledku rozpoznávání překladu. Pokud překládáte do více jazyků, přečtěte si téma Ruční syntéza. Pomocí přiřazení voice_name a poskytněte obslužné rutiny události pro Synthesizing událost a Stáhněte si zvuk. V následujícím příkladu se přeložený zvuk uloží jako soubor . wav .

Důležité

Syntéza založená na událostech funguje pouze s jedním překladem , nepřidává více cílových jazyků překladu. Kromě toho voice_name by měl být stejný jazyk jako cílový jazyk překladu, například; "de" může namapovat na "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()

Ruční syntéza

translationsSlovník lze použít k syntetizování zvuku z textu překladu. Iterujte každým překladem a syntetizujte tento překlad. Při vytváření SpeechSynthesizer instance SpeechConfig musí objekt mít speech_synthesis_voice_name vlastnost nastavenou na požadovaný hlas. Následující příklad se přeloží na pět jazyků a každý překlad se pak syntetizuje do zvukového souboru v odpovídajícím neuronové jazyce.

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

Další informace o syntézě řeči najdete v tématu Základy funkce pro syntézu řeči.

Požadavky

V tomto článku se předpokládá, že máte účet Azure a předplatné služby Speech. Pokud účet a předplatné nemáte, Vyzkoušejte službu Speech Service zdarma.

Stažení a instalace

Postupujte podle těchto kroků a nainstalujte rozhraní příkazového řádku služby Speech Windows:

V Windows vaší platformě potřebujete Microsoft Visual C++ Redistributable pro Visual Studio 2019. První instalace může vyžadovat restartování.
Nainstalujte sadu .NET Core 3.1 SDK.
Nainstalujte rozhraní příkazového řádku služby Speech NuGet zadáním tohoto příkazu:
```
dotnet tool install --global Microsoft.CognitiveServices.Speech.CLI
```

Pokud spx chcete zobrazit nápovědu k rozhraní příkazového řádku služby Speech, zadejte .

Poznámka

Jako alternativu k NuGet si můžete stáhnout a extrahovat rozhraní příkazového řádku služby Speech pro Windows jako soubor ZIP.

Omezení písem

V Windows rozhraní příkazového řádku služby Speech může zobrazit pouze písma dostupná pro příkazový řádek v místním počítači. Terminál Windows podporuje všechna písma vytvořená interaktivně rozhraním příkazového řádku služby Speech.

Pokud vystupíte do souboru, může se v textovém editoru, jako je Poznámkový blok, nebo ve webovém prohlížeči, Microsoft Edge zobrazit také všechna písma.

Následující distribuce Linuxu jsou podporované pro architektury x64 pomocí rozhraní příkazového řádku služby Speech:

CentOS 7/8
Debian 9/10
Red Hat Enterprise Linux (RHEL) 7/8
Ubuntu 16.04 (do září), Ubuntu 18.04/20.04

Poznámka

Další architektury podporuje sada Speech SDK (ne Rozhraní příkazového řádku služby Speech). Další informace najdete v tématu Informace o sadě Speech SDK.

Postupujte podle těchto kroků a nainstalujte rozhraní příkazového řádku služby Speech v Linuxu na procesor x64:

Nainstalujte sadu .NET Core 3.1 SDK.
Nainstalujte rozhraní příkazového řádku služby Speech NuGet zadáním tohoto příkazu:

dotnet tool install --global Microsoft.CognitiveServices.Speech.CLI
V RHEL/CentOS Linuxu nakonfigurujte OpenSSL pro Linux.
Na Linuxu Ubunutu 20.04 nainstalujte GStreamer.

Pokud spx chcete zobrazit nápovědu k rozhraní příkazového řádku služby Speech, zadejte .

Poznámka

Jako alternativu k NuGet si binární soubory Linuxu můžete stáhnout jako soubor ZIP. spx-netcore-30-linux-x64.zipExtrahujte do nového ~/spx adresáře, zadejte do binárního souboru a sudo chmod +r+x spx přidejte ~/spx cestu k systémové proměnné PATH.

Důležité

Při spuštění rozhraní příkazového řádku služby Speech v kontejneru Dockeru nemůžete použít mikrofon počítače. Můžete ale číst a ukládat zvukové soubory v místním připojeném adresáři.

Poznámka

Následující příklad stáhne veřejnou image kontejneru z Docker Hub. Doporučujeme nejprve provést ověření pomocí Docker Hub ( ) místo vytvoření anonymní žádosti docker login o změnu. Pokud chcete zvýšit spolehlivost při používání veřejného obsahu, importujte a spravujte image v privátním registru kontejnerů Azure. Přečtěte si další informace o práci s veřejnými imagemi.

Pomocí těchto kroků nainstalujte rozhraní příkazového řádku služby Speech do kontejneru Dockeru:

Nainstalujte Docker Desktop pro vaši platformu, pokud ještě není nainstalovaný.
Do nového příkazového řádku nebo terminálu zadejte tento příkaz:
```
docker pull msftspeech/spx
```
Zadejte tento příkaz. Měli byste vidět informace nápovědy k rozhraní příkazového řádku služby Speech:
```
docker run -it --rm msftspeech/spx help
```

Připojení adresáře v kontejneru

Nástroj rozhraní příkazového řádku služby Speech ukládá nastavení konfigurace jako soubory a při provádění jakéhokoli příkazu načte tyto soubory (s výjimkou příkazů nápovědy). Při použití rozhraní příkazového řádku služby Speech v kontejneru Dockeru musíte připojit místní adresář z kontejneru, aby nástroj mohl uložit nebo najít nastavení konfigurace a také aby nástroj mohl číst nebo zapisovat jakékoli soubory vyžadované příkazem, například zvukové soubory řeči.

V Windows zadejte tento příkaz, který vytvoří místní adresář, který může rozhraní příkazového řádku služby Speech používat v rámci kontejneru:

mkdir c:\spx-data

Nebo v Linuxu nebo macOS zadejte v terminálu tento příkaz, který vytvoří adresář a zobrazí se jeho absolutní cesta:

mkdir ~/spx-data
cd ~/spx-data
pwd

Absolutní cestu použijete při volání rozhraní příkazového řádku služby Speech.

Spuštění rozhraní příkazového řádku služby Speech v kontejneru

Tato dokumentace ukazuje příkaz rozhraní příkazového řádku služby spx Speech, který se používá v instalacích mimo Docker. Při volání příkazu v kontejneru Dockeru musíte připojit adresář v kontejneru k systému souborů, kde rozhraní příkazového řádku služby Speech může ukládat a hledat konfigurační hodnoty a číst spx a zapisovat soubory.

Na Windows se vaše příkazy spustí tímto příkazem:

docker run -it -v c:\spx-data:/data --rm msftspeech/spx

V Linuxu nebo macOS budou příkazy vypadat jako v následující ukázce. Nahraďte ABSOLUTE_PATH absolutní cestou k připojenému adresáři. Tuto cestu vrátil příkaz pwd v předchozí části.

Pokud tento příkaz spustíte před nastavením klíče a oblasti, zobrazí se chyba s zprávou o nastavení klíče a oblasti:

sudo docker run -it -v ABSOLUTE_PATH:/data --rm msftspeech/spx

Pokud chcete použít příkaz nainstalovaný v kontejneru, vždy zadejte celý výše uvedený příkaz spx následovaný parametry vašeho požadavku. Například v Windows tento příkaz nastaví klíč:

docker run -it -v c:\spx-data:/data --rm msftspeech/spx config @key --set SUBSCRIPTION-KEY

Pokud chcete rozšířit interakci s nástrojem příkazového řádku, můžete kontejner spustit pomocí interaktivního prostředí Bash přidáním parametru vstupního bodu. Na Windows zadáním tohoto příkazu spusťte kontejner, který zpřístupňuje interaktivní rozhraní příkazového řádku, ve kterém můžete zadat více spx příkazů:

docker run -it --entrypoint=/bin/bash -v c:\spx-data:/data --rm msftspeech/spx

Nastavit zdrojový a cílový jazyk

Tento příkaz volá funkci Speech CLI k překladu řeči z mikrofonu z italštiny na francouzštinu.

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

Další kroky

Použití komprimovaných formátů zvukových kodeků
Podívejte se na ukázky rychlý Start pro GitHub.

Začínáme s překladem řeči

Ohodnoťte vaše zkušenosti

Přeskočit na ukázky na GitHub

Požadavky

Instalace sady Speech SDK

Import závislostí

Citlivá data a proměnné prostředí

Vytvoření konfigurace překladu řeči

Změna zdrojového jazyka

Přidání jazyka překladu

Inicializace rozpoznávání překladu

Překlad řeči

Syntetizovat překlady

Syntéza na základě událostí

Ruční syntéza

Vícejazyčný překlad s identifikací jazyka

Přeskočit na ukázky na GitHub

Požadavky

Instalace sady Speech SDK

Import závislostí

Citlivá data a proměnné prostředí

Vytvoření konfigurace překladu řeči

Změna zdrojového jazyka

Přidání jazyka překladu

Inicializace rozpoznávání překladu

Překlad řeči

Syntetizovat překlady

Syntéza na základě událostí

Ruční syntéza

Vícejazyčný překlad s identifikací jazyka

Přeskočit na ukázky na GitHub

Požadavky

Instalace sady Speech SDK

Import závislostí

Citlivá data a proměnné prostředí

Vytvoření konfigurace překladu řeči

Změna zdrojového jazyka

Přidání jazyka překladu

Inicializace rozpoznávání překladu

Překlad řeči

Syntetizovat překlady

Syntéza na základě událostí

Ruční syntéza

Přeskočit na ukázky v GitHub

Požadavky

Instalace sady Speech SDK

Vytvořit konfiguraci překladu

Inicializovat překladatele

Překlad řeči

Zadejte cílový jazyk.

Rozpoznávání při spuštění

Průběžný překlad

Zvolit zdrojový jazyk

Vyberte jeden nebo více cílových jazyků

Přeskočit na ukázky v GitHub

Požadavky

Instalace sady Speech SDK

Importovat závislosti

Citlivá data a proměnné prostředí

Vytvoření konfigurace překladu řeči

Změnit jazyk zdroje

Přidat jazyk překladu

Inicializovat Nástroj pro rozpoznávání překladu

Překlad řeči

Překlady pro syntetizátory

Shrnutí založené na událostech

Ruční syntéza

Požadavky

Stažení a instalace

Omezení písem

Nastavit zdrojový a cílový jazyk

Další kroky