Jak rozpoznawać i tłumaczyć mowę

Artykuł
01/21/2024

Dokumentacja referencyjna | Package (NuGet) | Dodatkowe przykłady w usłudze GitHub

W tym przewodniku z instrukcjami dowiesz się, jak rozpoznawać ludzką mowę i tłumaczyć ją na inny język.

Aby uzyskać więcej informacji na temat tłumaczenia mowy, zobacz omówienie tłumaczenia mowy:

Tłumaczenie mowy na tekst
Tłumaczenie mowy na wiele języków docelowych
Wykonywanie tłumaczenia mowy bezpośredniej na mowę

Poufne dane i zmienne środowiskowe

Przykładowy kod źródłowy w tym artykule zależy od zmiennych środowiskowych do przechowywania poufnych danych, takich jak klucz i region zasobu usługi Mowa. Klasa Program zawiera dwie static readonly string wartości przypisane ze zmiennych środowiskowych maszyny hosta: SPEECH__SUBSCRIPTION__KEY i SPEECH__SERVICE__REGION. Oba te pola znajdują się w zakresie klasy, więc są dostępne w obrębie treści metod klasy:

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

Aby uzyskać więcej informacji na temat zmiennych środowiskowych, zobacz Zmienne środowiskowe i konfiguracja aplikacji.

Tworzenie konfiguracji tłumaczenia mowy

Aby wywołać usługę Rozpoznawanie mowy przy użyciu zestawu SPEECH SDK, należy utworzyć SpeechTranslationConfig wystąpienie. Ta klasa zawiera informacje o subskrypcji, takie jak klucz i skojarzony region, punkt końcowy, host lub token autoryzacji.

Napiwek

Niezależnie od tego, czy wykonujesz rozpoznawanie mowy, syntezę mowy, tłumaczenie, czy rozpoznawanie intencji, zawsze utworzysz konfigurację.

Możesz zainicjować SpeechTranslationConfig na kilka sposobów:

Z subskrypcją: przekaż klucz i skojarzony region.
Za pomocą punktu końcowego: przekaż punkt końcowy usługi Rozpoznawanie mowy. Klucz lub token autoryzacji jest opcjonalny.
Za pomocą hosta: przekaż adres hosta. Klucz lub token autoryzacji jest opcjonalny.
Za pomocą tokenu autoryzacji: przekaż token autoryzacji i skojarzony region.

Przyjrzyjmy się, jak utworzyć SpeechTranslationConfig wystąpienie przy użyciu klucza i regionu. Pobierz klucz zasobu usługi Mowa i region w witrynie Azure Portal.

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 speechTranslationConfig =
            SpeechTranslationConfig.FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    }
}

Zmienianie języka źródłowego

Jednym z typowych zadań tłumaczenia mowy jest określenie języka wejściowego (lub źródłowego). W poniższym przykładzie pokazano, jak zmienić język wejściowy na włoski. W kodzie należy wchodzić w interakcję SpeechTranslationConfig z wystąpieniem, przypisując je do SpeechRecognitionLanguage właściwości:

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

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

Właściwość SpeechRecognitionLanguage oczekuje ciągu formatu ustawień regionalnych języka. Zapoznaj się z listą obsługiwanych ustawień regionalnych tłumaczenia mowy.

Dodawanie języka tłumaczenia

Innym typowym zadaniem tłumaczenia mowy jest określenie docelowych języków tłumaczenia. Co najmniej jeden jest wymagany, ale obsługiwane są wielokrotnie. Poniższy fragment kodu ustawia zarówno język francuski, jak i niemiecki jako cele języka tłumaczenia:

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

    speechTranslationConfig.SpeechRecognitionLanguage = "it-IT";
    
    speechTranslationConfig.AddTargetLanguage("fr");
    speechTranslationConfig.AddTargetLanguage("de");
}

W przypadku każdego wywołania metody AddTargetLanguageokreślono nowy docelowy język tłumaczenia. Innymi słowy, gdy mowa jest rozpoznawana z języka źródłowego, każde tłumaczenie docelowe jest dostępne w ramach wynikowej operacji tłumaczenia.

Inicjowanie rozpoznawania tłumaczenia

Po utworzeniu wystąpienia następnym krokiem SpeechTranslationConfig jest zainicjowanie TranslationRecognizerelementu . Podczas inicjowania TranslationRecognizernależy przekazać je do speechTranslationConfig wystąpienia. Obiekt konfiguracji udostępnia poświadczenia wymagane przez usługę Rozpoznawanie mowy w celu zweryfikowania żądania.

Jeśli rozpoznajesz mowę przy użyciu domyślnego mikrofonu urządzenia, oto jak TranslationRecognizer powinno wyglądać wystąpienie:

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

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

    using var translationRecognizer = new TranslationRecognizer(speechTranslationConfig);
}

Jeśli chcesz określić urządzenie wejściowe audio, musisz utworzyć AudioConfig wystąpienie klasy i podać audioConfig parametr podczas inicjowania TranslationRecognizer.

Napiwek

Dowiedz się, jak uzyskać identyfikator urządzenia dla urządzenia wejściowego audio.

Najpierw odwołaj AudioConfig się do obiektu w następujący sposób:

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

    using var audioConfig = AudioConfig.FromDefaultMicrophoneInput();
    using var translationRecognizer = new TranslationRecognizer(speechTranslationConfig, audioConfig);
}

Jeśli chcesz podać plik audio zamiast używać mikrofonu, nadal musisz podać audioConfig parametr. Jednak podczas tworzenia AudioConfig wystąpienia klasy zamiast wywoływania metody należy wywołać FromDefaultMicrophoneInputFromWavFileInput parametr i przekazać filename go:

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

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

Tłumaczenie mowy

Aby przetłumaczyć mowę, zestaw SDK usługi Mowa korzysta z danych wejściowych mikrofonu lub pliku audio. Przed tłumaczeniem mowy odbywa się rozpoznawanie mowy. Po zainicjowaniu wszystkich obiektów wywołaj funkcję recognize-once i uzyskaj wynik:

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

    using var translationRecognizer = new TranslationRecognizer(speechTranslationConfig);

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

Aby uzyskać więcej informacji na temat zamiany mowy na tekst, zobacz podstawy rozpoznawania mowy.

Tłumaczenie oparte na zdarzeniach

Obiekt TranslationRecognizer uwidacznia Recognizing zdarzenie. Zdarzenie jest uruchamiane kilka razy i zapewnia mechanizm pobierania wyników tłumaczenia pośredniego.

Uwaga

Wyniki tłumaczenia pośredniego nie są dostępne w przypadku korzystania z tłumaczenia mowy wielojęzycznej.

W poniższym przykładzie wyniki tłumaczenia pośredniego są wyświetlane w konsoli programu :

using (var audioInput = AudioConfig.FromWavFileInput(@"whatstheweatherlike.wav"))
{
    using (var translationRecognizer = new TranslationRecognizer(config, audioInput))
    {
        // Subscribes to events.
        translationRecognizer.Recognizing += (s, e) =>
        {
            Console.WriteLine($"RECOGNIZING in '{fromLanguage}': Text={e.Result.Text}");
            foreach (var element in e.Result.Translations)
            {
                Console.WriteLine($"    TRANSLATING into '{element.Key}': {element.Value}");
            }
        };

        translationRecognizer.Recognized += (s, e) => {
            if (e.Result.Reason == ResultReason.TranslatedSpeech)
            {
                Console.WriteLine($"RECOGNIZED in '{fromLanguage}': 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.");
            }
        };

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

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

        // Stops translation.
        await translationRecognizer.StopContinuousRecognitionAsync().ConfigureAwait(false);
    }
}

Syntetyzowanie tłumaczeń

Po pomyślnym rozpoznaniu i przetłumaczeniu mowy wszystkie tłumaczenia są umieszczane w słowniku. Klucz słownika Translations jest docelowym językiem tłumaczenia, a wartość jest przetłumaczonym tekstem. Rozpoznaną mowę można przetłumaczyć, a następnie zsyntetyzować w innym języku (zamiana mowy na mowę).

Synteza oparta na zdarzeniach

Obiekt TranslationRecognizer uwidacznia Synthesizing zdarzenie. Zdarzenie jest uruchamiane kilka razy i zapewnia mechanizm pobierania syntetyzowanego dźwięku z wyniku rozpoznawania tłumaczenia. Jeśli tłumaczysz na wiele języków, zobacz Synteza ręczna.

Określ głos syntezy, przypisując VoiceName wystąpienie, i podaj program obsługi zdarzeń dla Synthesizing zdarzenia w celu pobrania dźwięku. Poniższy przykład zapisuje przetłumaczony dźwięk jako plik .wav.

Ważne

Synteza oparta na zdarzeniach działa tylko z pojedynczym tłumaczeniem. Nie należy dodawać wielu docelowych języków tłumaczenia. VoiceName Ponadto wartość powinna być tym samym językiem co docelowy język tłumaczenia. Na przykład "de" można mapować na "de-DE-Hedda".

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

    speechTranslationConfig.VoiceName = "de-DE-Hedda";

    using var translationRecognizer = new TranslationRecognizer(speechTranslationConfig);

    translationRecognizer.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 translationRecognizer.RecognizeOnceAsync();
    if (result.Reason == ResultReason.TranslatedSpeech)
    {
        Console.WriteLine($"Recognized: \"{result.Text}\"");
        Console.WriteLine($"Translated into '{toLanguage}': {result.Translations[toLanguage]}");
    }
}

Synteza ręczna

Słownik umożliwia Translations syntetyzowanie dźwięku z tekstu tłumaczenia. Iteruj przez każde tłumaczenie i syntetyzuje je. Podczas tworzenia SpeechSynthesizer wystąpienia SpeechConfig obiekt musi mieć jego SpeechSynthesisVoiceName właściwość ustawioną na żądany głos.

Poniższy przykład tłumaczy się na pięć języków. Każde tłumaczenie jest następnie syntetyzowane do pliku audio w odpowiednim języku neuronowym.

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

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

    using var translationRecognizer = new TranslationRecognizer(speechTranslationConfig);

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

    var result = await translationRecognizer.RecognizeOnceAsync();
    if (result.Reason == ResultReason.TranslatedSpeech)
    {
        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 speechSynthesizer = new SpeechSynthesizer(speechConfig, audioConfig);
            
            await speechSynthesizer.SpeakTextAsync(translation);
        }
    }
}

Aby uzyskać więcej informacji na temat syntezy mowy, zobacz podstawy syntezy mowy.

Tłumaczenie wielojęzyczne z identyfikacją języka

W wielu scenariuszach możesz nie wiedzieć, które języki wejściowe mają być określone. Przy użyciu identyfikacji języka można wykrywać maksymalnie 10 możliwych języków wejściowych i automatycznie tłumaczyć je na języki docelowe.

Poniższy przykład przewiduje, że en-US lub zh-CN powinien zostać wykryty, ponieważ są one zdefiniowane w pliku AutoDetectSourceLanguageConfig. Następnie mowa jest tłumaczona na de i fr określona w wywołaniach metody AddTargetLanguage().

speechTranslationConfig.AddTargetLanguage("de");
speechTranslationConfig.AddTargetLanguage("fr");
var autoDetectSourceLanguageConfig = AutoDetectSourceLanguageConfig.FromLanguages(new string[] { "en-US", "zh-CN" });
var translationRecognizer = new TranslationRecognizer(speechTranslationConfig, autoDetectSourceLanguageConfig, audioConfig);

Aby zapoznać się z kompletnym przykładem kodu, zobacz identyfikację języka.

Tłumaczenie mowy wielojęzycznej bez kandydatów do języka źródłowego

Tłumaczenie mowy wielojęzycznej implementuje nowy poziom technologii tłumaczenia mowy, która odblokowuje różne możliwości, w tym bez określonego języka wejściowego i obsługuje przełączniki języka w ramach tej samej sesji. Te funkcje umożliwiają nowy poziom uprawnień tłumaczenia mowy, które można zaimplementować w produktach.

Obecnie w przypadku używania identyfikatora języka z tłumaczeniem mowy należy utworzyć SpeechTranslationConfig obiekt z punktu końcowego w wersji 2. Zastąp ciąg "YourServiceRegion" regionem zasobu usługi Mowa (na przykład "westus"). Zastąp ciąg "YourSubscriptionKey" kluczem zasobu usługi Mowa.

var v2EndpointInString = String.Format("wss://{0}.stt.speech.microsoft.com/speech/universal/v2", "YourServiceRegion");
var v2EndpointUrl = new Uri(v2EndpointInString);
var speechTranslationConfig = SpeechTranslationConfig.FromEndpoint(v2EndpointUrl, "YourSubscriptionKey");

Określ języki docelowe tłumaczenia. Zastąp ciąg wybranymi językami. Możesz dodać więcej wierszy.

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

Kluczową różnicą z tłumaczeniem mowy wielojęzycznej jest to, że nie trzeba określać języka źródłowego. Dzieje się tak, ponieważ usługa automatycznie wykryje język źródłowy. AutoDetectSourceLanguageConfig Utwórz obiekt za fromOpenRange pomocą metody , aby poinformować usługę, że chcesz użyć tłumaczenia mowy wielojęzycznej bez określonego języka źródłowego.

AutoDetectSourceLanguageConfig autoDetectSourceLanguageConfig = AutoDetectSourceLanguageConfig.fromOpenRange(); 
var translationRecognizer = new TranslationRecognizer(speechTranslationConfig, autoDetectSourceLanguageConfig, audioConfig);

Pełny przykład kodu z zestawem SPEECH SDK można znaleźć w artykule Speech Translation samples on GitHub (Przykłady tłumaczenia mowy w witrynie GitHub).

Dokumentacja referencyjna | Package (NuGet) | Dodatkowe przykłady w usłudze GitHub

W tym przewodniku z instrukcjami dowiesz się, jak rozpoznawać ludzką mowę i tłumaczyć ją na inny język.

Aby uzyskać więcej informacji na temat tłumaczenia mowy, zobacz omówienie tłumaczenia mowy:

Tłumaczenie mowy na tekst
Tłumaczenie mowy na wiele języków docelowych
Wykonywanie tłumaczenia mowy bezpośredniej na mowę

Poufne dane i zmienne środowiskowe

Przykładowy kod źródłowy w tym artykule zależy od zmiennych środowiskowych do przechowywania poufnych danych, takich jak klucz i region zasobu usługi Mowa. Plik kodu C++ zawiera dwie wartości ciągu przypisane ze zmiennych środowiskowych maszyny hosta: SPEECH__SUBSCRIPTION__KEY i SPEECH__SERVICE__REGION. Oba te pola znajdują się w zakresie klasy, więc są dostępne w obrębie treści metod klasy:

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

Aby uzyskać więcej informacji na temat zmiennych środowiskowych, zobacz Zmienne środowiskowe i konfiguracja aplikacji.

Tworzenie konfiguracji tłumaczenia mowy

Napiwek

Niezależnie od tego, czy wykonujesz rozpoznawanie mowy, syntezę mowy, tłumaczenie, czy rozpoznawanie intencji, zawsze utworzysz konfigurację.

Możesz zainicjować SpeechTranslationConfig na kilka sposobów:

Z subskrypcją: przekaż klucz i skojarzony region.
Za pomocą punktu końcowego: przekaż punkt końcowy usługi Rozpoznawanie mowy. Klucz lub token autoryzacji jest opcjonalny.
Za pomocą hosta: przekaż adres hosta. Klucz lub token autoryzacji jest opcjonalny.
Za pomocą tokenu autoryzacji: przekaż token autoryzacji i skojarzony region.

Przyjrzyjmy się, jak utworzyć SpeechTranslationConfig wystąpienie przy użyciu klucza i regionu. Pobierz klucz zasobu usługi Mowa i region w witrynie Azure Portal.

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

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

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

Zmienianie języka źródłowego

Jednym z typowych zadań tłumaczenia mowy jest określenie języka wejściowego (lub źródłowego). W poniższym przykładzie pokazano, jak zmienić język wejściowy na włoski. W kodzie należy wchodzić w interakcję SpeechTranslationConfig z wystąpieniem, wywołując metodę SetSpeechRecognitionLanguage .

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

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

Właściwość SpeechRecognitionLanguage oczekuje ciągu formatu ustawień regionalnych języka. Zapoznaj się z listą obsługiwanych ustawień regionalnych tłumaczenia mowy.

Dodawanie języka tłumaczenia

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

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

    speechTranslationConfig->AddTargetLanguage("fr");
    speechTranslationConfig->AddTargetLanguage("de");
}

Inicjowanie rozpoznawania tłumaczenia

Po utworzeniu wystąpienia następnym krokiem SpeechTranslationConfig jest zainicjowanie TranslationRecognizerelementu . Podczas inicjowania TranslationRecognizernależy przekazać je do translationConfig wystąpienia. Obiekt konfiguracji udostępnia poświadczenia wymagane przez usługę Rozpoznawanie mowy w celu zweryfikowania żądania.

Jeśli rozpoznajesz mowę przy użyciu domyślnego mikrofonu urządzenia, poniżej TranslationRecognizer przedstawiono następujące elementy:

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

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

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

Jeśli chcesz określić urządzenie wejściowe audio, musisz utworzyć AudioConfig wystąpienie klasy i podać audioConfig parametr podczas inicjowania TranslationRecognizer.

Napiwek

Dowiedz się, jak uzyskać identyfikator urządzenia dla urządzenia wejściowego audio.

Najpierw odwołaj AudioConfig się do obiektu w następujący sposób:

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

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

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

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

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

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

Tłumaczenie mowy

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

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

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

    auto result = translationRecognizer->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;
        }
    }
}

Aby uzyskać więcej informacji na temat zamiany mowy na tekst, zobacz podstawy rozpoznawania mowy.

Syntetyzowanie tłumaczeń

Synteza oparta na zdarzeniach

Określ głos syntezy, przypisując SetVoiceName wystąpienie, i podaj program obsługi zdarzeń dla Synthesizing zdarzenia w celu pobrania dźwięku. Poniższy przykład zapisuje przetłumaczony dźwięk jako plik .wav.

Ważne

Synteza oparta na zdarzeniach działa tylko z pojedynczym tłumaczeniem. Nie należy dodawać wielu docelowych języków tłumaczenia. SetVoiceName Ponadto wartość powinna być tym samym językiem co docelowy język tłumaczenia. Na przykład "de" można mapować na "de-DE-Hedda".

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

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

    speechTranslationConfig->SetVoiceName("de-DE-Hedda");

    auto translationRecognizer = TranslationRecognizer::FromConfig(translationConfig);
    translationRecognizer->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 = translationRecognizer->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;
        }
    }
}

Synteza ręczna

Słownik umożliwia Translations syntetyzowanie dźwięku z tekstu tłumaczenia. Iteruj przez każde tłumaczenie i syntetyzuje je. Podczas tworzenia SpeechSynthesizer wystąpienia SpeechConfig obiekt musi mieć jego SetSpeechSynthesisVoiceName właściwość ustawioną na żądany głos.

Poniższy przykład tłumaczy się na pięć języków. Każde tłumaczenie jest następnie syntetyzowane do pliku audio w odpowiednim języku neuronowym.

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

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

    auto translationRecognizer = TranslationRecognizer::FromConfig(translationConfig);

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

    auto result = translationRecognizer->RecognizeOnceAsync().get();
    if (result->Reason == ResultReason::TranslatedSpeech)
    {
        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 speechConfig =
                SpeechConfig::FromSubscription(SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
            speechConfig->SetSpeechSynthesisVoiceName(languageToVoiceMap[language]);

            auto audioConfig = AudioConfig::FromWavFileOutput(language + "-translation.wav");
            auto speechSynthesizer = SpeechSynthesizer::FromConfig(speechConfig, audioConfig);

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

Aby uzyskać więcej informacji na temat syntezy mowy, zobacz podstawy syntezy mowy.

Tłumaczenie wielojęzyczne z identyfikacją języka

Poniższy przykład przewiduje, że en-US lub zh-CN powinien zostać wykryty, ponieważ są one zdefiniowane w pliku AutoDetectSourceLanguageConfig. Następnie mowa zostanie przetłumaczona na de wartość i fr określona w wywołaniach metody AddTargetLanguage().

speechTranslationConfig->AddTargetLanguage("de");
speechTranslationConfig->AddTargetLanguage("fr");
auto autoDetectSourceLanguageConfig = AutoDetectSourceLanguageConfig::FromLanguages({ "en-US", "zh-CN" });
auto translationRecognizer = TranslationRecognizer::FromConfig(speechTranslationConfig, autoDetectSourceLanguageConfig, audioConfig);

Aby zapoznać się z kompletnym przykładem kodu, zobacz identyfikację języka.

Dokumentacja referencyjna Package (Go)Additional Samples on GitHub (Dodatkowe przykłady w witrynie GitHub) | |

Zestaw SPEECH SDK dla języka Go nie obsługuje tłumaczenia mowy. Wybierz inny język programowania lub odwołanie do języka Go i przykłady połączone od początku tego artykułu.

| Dokumentacja referencyjna — dodatkowe przykłady w usłudze GitHub

W tym przewodniku z instrukcjami dowiesz się, jak rozpoznawać ludzką mowę i tłumaczyć ją na inny język.

Aby uzyskać więcej informacji na temat tłumaczenia mowy, zobacz omówienie tłumaczenia mowy:

Tłumaczenie mowy na tekst
Tłumaczenie mowy na wiele języków docelowych
Wykonywanie tłumaczenia mowy bezpośredniej na mowę

Poufne dane i zmienne środowiskowe

Przykładowy kod źródłowy w tym artykule zależy od zmiennych środowiskowych do przechowywania poufnych danych, takich jak klucz i region zasobu usługi Mowa. Plik kodu Java zawiera dwie static final String wartości przypisane ze zmiennych środowiskowych maszyny hosta: SPEECH__SUBSCRIPTION__KEY i SPEECH__SERVICE__REGION. Oba te pola znajdują się w zakresie klasy, więc są dostępne w obrębie treści metod klasy:

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

Aby uzyskać więcej informacji na temat zmiennych środowiskowych, zobacz Zmienne środowiskowe i konfiguracja aplikacji.

Tworzenie konfiguracji tłumaczenia mowy

Napiwek

Niezależnie od tego, czy wykonujesz rozpoznawanie mowy, syntezę mowy, tłumaczenie, czy rozpoznawanie intencji, zawsze utworzysz konfigurację.

Wystąpienie można zainicjować SpeechTranslationConfig na kilka sposobów:

Z subskrypcją: przekaż klucz i skojarzony region.
Za pomocą punktu końcowego: przekaż punkt końcowy usługi Rozpoznawanie mowy. Klucz lub token autoryzacji jest opcjonalny.
Za pomocą hosta: przekaż adres hosta. Klucz lub token autoryzacji jest opcjonalny.
Za pomocą tokenu autoryzacji: przekaż token autoryzacji i skojarzony region.

Przyjrzyjmy się, jak utworzyć SpeechTranslationConfig wystąpienie przy użyciu klucza i regionu. Pobierz klucz zasobu usługi Mowa i region w witrynie Azure Portal.

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 speechTranslationConfig = SpeechTranslationConfig.fromSubscription(
            SPEECH__SUBSCRIPTION__KEY, SPEECH__SERVICE__REGION);
    }
}

Zmienianie języka źródłowego

Jednym z typowych zadań tłumaczenia mowy jest określenie języka wejściowego (lub źródłowego). W poniższym przykładzie pokazano, jak zmienić język wejściowy na włoski. W kodzie wchodzenie w interakcję SpeechTranslationConfig z wystąpieniem przez wywołanie setSpeechRecognitionLanguage metody :

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

Funkcja setSpeechRecognitionLanguage oczekuje ciągu formatu ustawień regionalnych języka. Zapoznaj się z listą obsługiwanych ustawień regionalnych tłumaczenia mowy.

Dodawanie języka tłumaczenia

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

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

W przypadku każdego wywołania metody addTargetLanguageokreślono nowy docelowy język tłumaczenia. Innymi słowy, gdy mowa jest rozpoznawana z języka źródłowego, każde tłumaczenie docelowe jest dostępne w ramach wynikowej operacji tłumaczenia.

Inicjowanie rozpoznawania tłumaczenia

Jeśli rozpoznajesz mowę przy użyciu domyślnego mikrofonu urządzenia, poniżej TranslationRecognizer przedstawiono następujące elementy:

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

    try (TranslationRecognizer translationRecognizer = new TranslationRecognizer(speechTranslationConfig)) {
    }
}

Jeśli chcesz określić urządzenie wejściowe audio, musisz utworzyć AudioConfig wystąpienie klasy i podać audioConfig parametr podczas inicjowania TranslationRecognizer.

Napiwek

Dowiedz się, jak uzyskać identyfikator urządzenia dla urządzenia wejściowego audio.

Najpierw odwołaj AudioConfig się do obiektu w następujący sposób:

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

    AudioConfig audioConfig = AudioConfig.fromDefaultMicrophoneInput();
    try (TranslationRecognizer translationRecognizer = new TranslationRecognizer(speechTranslationConfig, audioConfig)) {
        
    }
}

Jeśli chcesz podać plik audio zamiast używać mikrofonu, nadal musisz podać audioConfig parametr. Jednak podczas tworzenia AudioConfig wystąpienia klasy zamiast wywoływania metody należy wywołać fromDefaultMicrophoneInputfromWavFileInput parametr i przekazać filename go:

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

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

Tłumaczenie mowy

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

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

        TranslationRecognitionResult result = translationRecognizer.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());
            }
        }
    }
}

Aby uzyskać więcej informacji na temat zamiany mowy na tekst, zobacz podstawy rozpoznawania mowy.

Syntetyzowanie tłumaczeń

Po pomyślnym rozpoznaniu i przetłumaczeniu mowy wszystkie tłumaczenia są umieszczane w słowniku. Funkcja getTranslations zwraca słownik z kluczem jako docelowy język tłumaczenia i wartość jako przetłumaczony tekst. Rozpoznaną mowę można przetłumaczyć, a następnie zsyntetyzować w innym języku (zamiana mowy na mowę).

Synteza oparta na zdarzeniach

Obiekt TranslationRecognizer uwidacznia synthesizing zdarzenie. Zdarzenie jest uruchamiane kilka razy i zapewnia mechanizm pobierania syntetyzowanego dźwięku z wyniku rozpoznawania tłumaczenia. Jeśli tłumaczysz na wiele języków, zobacz Synteza ręczna.

Określ głos syntezy, przypisując setVoiceName wystąpienie, i podaj program obsługi zdarzeń dla synthesizing zdarzenia w celu pobrania dźwięku. Poniższy przykład zapisuje przetłumaczony dźwięk jako plik .wav.

Ważne

Synteza oparta na zdarzeniach działa tylko z pojedynczym tłumaczeniem. Nie należy dodawać wielu docelowych języków tłumaczenia. setVoiceName Ponadto wartość powinna być tym samym językiem co docelowy język tłumaczenia. Na przykład "de" można mapować na "de-DE-Hedda".

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

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

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

    try (TranslationRecognizer translationRecognizer = new TranslationRecognizer(speechTranslationConfig)) {
        translationRecognizer.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 = translationRecognizer.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);
            }
        }
    }
}

Synteza ręczna

Funkcja getTranslations zwraca słownik, którego można użyć do syntezowania dźwięku z tekstu tłumaczenia. Iteruj przez każde tłumaczenie i syntetyzuje je. Podczas tworzenia SpeechSynthesizer wystąpienia SpeechConfig obiekt musi mieć jego setSpeechSynthesisVoiceName właściwość ustawioną na żądany głos.

Poniższy przykład tłumaczy się na pięć języków. Każde tłumaczenie jest następnie syntetyzowane do pliku audio w odpowiednim języku neuronowym.

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

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

        TranslationRecognitionResult result = translationRecognizer.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 speechSynthesizer = new SpeechSynthesizer(speechConfig, audioConfig)) {
                    speechSynthesizer.SpeakTextAsync(translation).get();
                }
            }
        }
    }
}

Aby uzyskać więcej informacji na temat syntezy mowy, zobacz podstawy syntezy mowy.

Dokumentacja referencyjna | Package (npm)Additional Samples on GitHub Library source code (Dodatkowe przykłady w kodzie źródłowym biblioteki GitHub) | |

W tym przewodniku z instrukcjami dowiesz się, jak rozpoznawać ludzką mowę i tłumaczyć ją na inny język.

Aby uzyskać więcej informacji na temat tłumaczenia mowy, zobacz omówienie tłumaczenia mowy:

Tłumaczenie mowy na tekst
Tłumaczenie mowy na wiele języków docelowych
Wykonywanie tłumaczenia mowy bezpośredniej na mowę

Tworzenie konfiguracji tłumaczenia

Aby wywołać usługę tłumaczenia przy użyciu zestawu SPEECH SDK, należy utworzyć SpeechTranslationConfig wystąpienie. Ta klasa zawiera informacje o subskrypcji, takie jak klucz i skojarzony region, punkt końcowy, host lub token autoryzacji.

Uwaga

Niezależnie od tego, czy wykonujesz rozpoznawanie mowy, syntezę mowy, tłumaczenie, czy rozpoznawanie intencji, zawsze utworzysz konfigurację.

Możesz zainicjować SpeechTranslationConfig na kilka sposobów:

Z subskrypcją: przekaż klucz i skojarzony region.
Za pomocą punktu końcowego: przekaż punkt końcowy usługi Rozpoznawanie mowy. Klucz lub token autoryzacji jest opcjonalny.
Za pomocą hosta: przekaż adres hosta. Klucz lub token autoryzacji jest opcjonalny.
Za pomocą tokenu autoryzacji: przekaż token autoryzacji i skojarzony region.

Przyjrzyjmy się, jak utworzyć SpeechTranslationConfig wystąpienie przy użyciu klucza i regionu. Pobierz klucz zasobu usługi Mowa i region w witrynie Azure Portal.

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

Inicjowanie tłumacza

Jeśli tłumaczysz mowę dostarczaną za pomocą domyślnego mikrofonu urządzenia, TranslationRecognizer poniżej przedstawiono następujące elementy:

const translationRecognizer = new TranslationRecognizer(speechTranslationConfig);

Jeśli chcesz określić urządzenie wejściowe audio, musisz utworzyć AudioConfig wystąpienie klasy i podać audioConfig parametr podczas inicjowania TranslationRecognizer.

Napiwek

Dowiedz się, jak uzyskać identyfikator urządzenia dla urządzenia wejściowego audio.

Odwołaj się do AudioConfig obiektu w następujący sposób:

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

Jeśli chcesz podać plik audio zamiast używać mikrofonu, nadal musisz podać audioConfig parametr. Można to jednak zrobić tylko wtedy, gdy celujesz Node.js. Podczas tworzenia AudioConfig wystąpienia klasy zamiast wywoływania fromDefaultMicrophoneInputmetody wywołujesz fromWavFileOutput i przekazujesz filename parametr :

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

Tłumaczenie mowy

Klasa TranslationRecognizer dla zestawu SPEECH SDK dla języka JavaScript uwidacznia metody, których można użyć do tłumaczenia mowy:

Tłumaczenie jednoskrętowe (asynchroniczne): wykonuje tłumaczenie w trybie bezblokowania (asynchronicznego). Tłumaczy jedną wypowiedź. Określa koniec pojedynczej wypowiedzi, słuchając ciszy na końcu lub aż do przetworzenia maksymalnie 15 sekund dźwięku.
Translacja ciągła (asynchroniczna): Asynchronicznie inicjuje operację ciągłego tłumaczenia. Użytkownik rejestruje się w zdarzeniach i obsługuje różne stany aplikacji. Aby zatrzymać asynchroniczne ciągłe tłumaczenie, wywołaj metodę stopContinuousRecognitionAsync.

Aby dowiedzieć się więcej na temat wybierania trybu rozpoznawania mowy, zobacz Wprowadzenie do zamiany mowy na tekst.

Określanie języka docelowego

Aby przetłumaczyć, należy określić zarówno język źródłowy, jak i co najmniej jeden język docelowy.

Język źródłowy można wybrać przy użyciu ustawień regionalnych wymienionych w tabeli tłumaczenia mowy. Znajdź opcje tłumaczenia języka pod tym samym linkiem.

Opcje języków docelowych różnią się w przypadku wyświetlania tekstu lub słuchania syntetyzowanej mowy. Aby przetłumaczyć z języka angielskiego na niemiecki, zmodyfikuj obiekt konfiguracji tłumaczenia:

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

Rozpoznawanie pojedynczego strzału

Oto przykład asynchronicznego tłumaczenia jednosstrzałowego za pośrednictwem metody recognizeOnceAsync:

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

Aby obsłużyć wynik, musisz napisać kod. Ten przykład ocenia result.reason tłumaczenie na język niemiecki:

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

Kod może również obsługiwać aktualizacje udostępniane podczas przetwarzania tłumaczenia. Możesz użyć tych aktualizacji, aby przekazać wizualną opinię na temat postępu tłumaczenia. Ten przykładowy kod JavaScript Node.js pokazuje tego rodzaju aktualizacje. Poniższy kod wyświetla również szczegóły wygenerowane podczas procesu tłumaczenia:

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

Ciągłe tłumaczenie

Tłumaczenie ciągłe jest nieco bardziej zaangażowane niż rozpoznawanie pojedynczych zdjęć. Wymaga ona zasubskrybowania zdarzeń recognizing, recognizedi canceled w celu uzyskania wyników rozpoznawania. Aby zatrzymać tłumaczenie, należy wywołać metodę stopContinuousRecognitionAsync.

Oto przykład wykonywania ciągłego tłumaczenia w pliku wejściowym audio. Zacznijmy od zdefiniowania danych wejściowych i inicjowania TranslationRecognizer:

const translationRecognizer = new TranslationRecognizer(speechTranslationConfig);

W poniższym kodzie subskrybujesz zdarzenia wysyłane z elementu TranslationRecognizer:

recognizing: Sygnał dla zdarzeń zawierających wyniki tłumaczenia pośredniego.
recognized: Sygnał dla zdarzeń, które zawierają końcowe wyniki tłumaczenia. Te wyniki wskazują pomyślną próbę tłumaczenia.
sessionStopped: Sygnał dla zdarzeń, które wskazują koniec sesji tłumaczenia (operacja).
canceled: Sygnał dla zdarzeń zawierających anulowane wyniki tłumaczenia. Te zdarzenia wskazują próbę anulowania tłumaczenia w wyniku bezpośredniego anulowania. Alternatywnie wskazują one awarię transportu lub protokołu.

translationRecognizer.recognizing = (s, e) => {
    console.log(`TRANSLATING: Text=${e.result.text}`);
};
translationRecognizer.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.");
    }
};
translationRecognizer.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 set the speech resource key and region values?");
    }
    translationRecognizer.stopContinuousRecognitionAsync();
};
translationRecognizer.sessionStopped = (s, e) => {
    console.log("\n    Session stopped event.");
    translationRecognizer.stopContinuousRecognitionAsync();
};

Po skonfigurowaniu wszystkich elementów możesz wywołać metodę startContinuousRecognitionAsync:

// Starts continuous recognition. Uses stopContinuousRecognitionAsync() to stop recognition.
translationRecognizer.startContinuousRecognitionAsync();
// Something later can call. Stops recognition.
// translationRecognizer.StopContinuousRecognitionAsync();

Wybieranie języka źródłowego

Typowym zadaniem tłumaczenia mowy jest określenie języka wejściowego (lub źródłowego). W poniższym przykładzie pokazano, jak zmienić język wejściowy na włoski. W kodzie znajdź SpeechTranslationConfig wystąpienie i dodaj następujący wiersz bezpośrednio poniżej:

speechTranslationConfig.speechRecognitionLanguage = "it-IT";

Właściwość speechRecognitionLanguage oczekuje ciągu formatu ustawień regionalnych języka. Zapoznaj się z listą obsługiwanych ustawień regionalnych tłumaczenia mowy.

Wybierz co najmniej jeden język docelowy

Zestaw SPEECH SDK może być tłumaczony równolegle na wiele języków docelowych. Dostępne języki docelowe różnią się nieco od listy języków źródłowych. Języki docelowe określa się przy użyciu kodu języka, a nie ustawień regionalnych.

Aby uzyskać listę kodów języków docelowych tekstu, zobacz tabelę tłumaczenia mowy na stronie obsługi języka. Możesz również znaleźć szczegółowe informacje o tłumaczeniu na syntetyzowane języki.

Poniższy kod dodaje język niemiecki jako język docelowy:

speechTranslationConfig.addTargetLanguage("de");

Ponieważ możliwe jest wiele tłumaczeń języka docelowego, kod musi określać język docelowy podczas badania wyniku. Poniższy kod pobiera wyniki tłumaczenia dla języka niemieckiego:

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

Dokumentacja referencyjna Pakietu (Pobierz) | Dodatkowe przykłady w usłudze GitHub |

Zestaw SPEECH SDK dla języka Objective-C obsługuje tłumaczenie mowy, ale nie dołączyliśmy jeszcze tutaj przewodnika. Wybierz inny język programowania, aby rozpocząć pracę i poznać koncepcje, lub zapoznaj się z dokumentacją języka Objective-C i przykładami połączonymi od początku tego artykułu.

Dokumentacja referencyjna Pakietu (Pobierz) | Dodatkowe przykłady w usłudze GitHub |

Zestaw SPEECH SDK dla języka Swift obsługuje tłumaczenie mowy, ale jeszcze nie dołączyliśmy tutaj przewodnika. Wybierz inny język programowania, aby rozpocząć pracę i dowiedzieć się więcej o pojęciach, lub zapoznaj się z dokumentacją i przykładami usługi Swift połączonymi od początku tego artykułu.

Dokumentacja referencyjna | Package (PyPi) | Dodatkowe przykłady w witrynie GitHub

W tym przewodniku z instrukcjami dowiesz się, jak rozpoznawać ludzką mowę i tłumaczyć ją na inny język.

Aby uzyskać więcej informacji na temat tłumaczenia mowy, zobacz omówienie tłumaczenia mowy:

Tłumaczenie mowy na tekst
Tłumaczenie mowy na wiele języków docelowych
Wykonywanie tłumaczenia mowy bezpośredniej na mowę

Poufne dane i zmienne środowiskowe

Przykładowy kod źródłowy w tym artykule zależy od zmiennych środowiskowych do przechowywania poufnych danych, takich jak klucz subskrypcji i region zasobu usługi Mowa. Plik kodu języka Python zawiera dwie wartości przypisane ze zmiennych środowiskowych maszyny hosta: SPEECH__SUBSCRIPTION__KEY i SPEECH__SERVICE__REGION. Obie te zmienne znajdują się w zakresie globalnym, więc są dostępne w definicji funkcji pliku kodu:

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

Aby uzyskać więcej informacji na temat zmiennych środowiskowych, zobacz Zmienne środowiskowe i konfiguracja aplikacji.

Tworzenie konfiguracji tłumaczenia mowy

Napiwek

Niezależnie od tego, czy wykonujesz rozpoznawanie mowy, syntezę mowy, tłumaczenie, czy rozpoznawanie intencji, zawsze utworzysz konfigurację.

Możesz zainicjować SpeechTranslationConfig na kilka sposobów:

Z subskrypcją: przekaż klucz i skojarzony region.
Za pomocą punktu końcowego: przekaż punkt końcowy usługi Rozpoznawanie mowy. Klucz lub token autoryzacji jest opcjonalny.
Za pomocą hosta: przekaż adres hosta. Klucz lub token autoryzacji jest opcjonalny.
Za pomocą tokenu autoryzacji: przekaż token autoryzacji i skojarzony region.

Przyjrzyjmy się, jak utworzyć SpeechTranslationConfig wystąpienie przy użyciu klucza i regionu. Pobierz klucz zasobu usługi Mowa i region w witrynie Azure Portal.

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

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

Zmienianie języka źródłowego

Jednym z typowych zadań tłumaczenia mowy jest określenie języka wejściowego (lub źródłowego). W poniższym przykładzie pokazano, jak zmienić język wejściowy na włoski. W kodzie należy wchodzić w interakcje z SpeechTranslationConfig wystąpieniem, przypisując je do speech_recognition_language właściwości.

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

Właściwość speech_recognition_language oczekuje ciągu formatu ustawień regionalnych języka. Zapoznaj się z listą obsługiwanych ustawień regionalnych tłumaczenia mowy.

Dodawanie języka tłumaczenia

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

W przypadku każdego wywołania metody add_target_languageokreślono nowy docelowy język tłumaczenia. Innymi słowy, gdy mowa jest rozpoznawana z języka źródłowego, każde tłumaczenie docelowe jest dostępne w ramach wynikowej operacji tłumaczenia.

Inicjowanie rozpoznawania tłumaczenia

Po utworzeniu wystąpienia następnym krokiem SpeechTranslationConfig jest zainicjowanie TranslationRecognizerelementu . Podczas inicjowania TranslationRecognizernależy przekazać je do translation_config wystąpienia. Obiekt konfiguracji udostępnia poświadczenia wymagane przez usługę Rozpoznawanie mowy w celu zweryfikowania żądania.

Jeśli rozpoznajesz mowę przy użyciu domyślnego mikrofonu urządzenia, poniżej TranslationRecognizer przedstawiono następujące elementy:

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)

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

Jeśli chcesz określić urządzenie wejściowe audio, musisz utworzyć AudioConfig wystąpienie klasy i podać audio_config parametr podczas inicjowania TranslationRecognizer.

Napiwek

Dowiedz się, jak uzyskać identyfikator urządzenia dla urządzenia wejściowego audio.

Najpierw odwołaj AudioConfig się do obiektu w następujący sposób:

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)
    translation_recognizer = speechsdk.translation.TranslationRecognizer(
            translation_config=translation_config, audio_config=audio_config)

Jeśli chcesz podać plik audio zamiast używać mikrofonu, nadal musisz podać audioConfig parametr. Jednak podczas tworzenia AudioConfig wystąpienia klasy zamiast wywoływania za pomocą metody należy wywołać use_default_microphone=Truefilename="path-to-file.wav" metodę i podać 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")
    translation_recognizer = speechsdk.translation.TranslationRecognizer(
            translation_config=translation_config, audio_config=audio_config)

Tłumaczenie mowy

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)

    translation_recognizer = speechsdk.translation.TranslationRecognizer(
            translation_config=translation_config)
    
    print('Say something...')
    result = translation_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()

Aby uzyskać więcej informacji na temat zamiany mowy na tekst, zobacz podstawy rozpoznawania mowy.

Syntetyzowanie tłumaczeń

Po pomyślnym rozpoznaniu i przetłumaczeniu mowy wszystkie tłumaczenia są umieszczane w słowniku. Klucz słownika translations jest docelowym językiem tłumaczenia, a wartość jest przetłumaczonym tekstem. Rozpoznaną mowę można przetłumaczyć, a następnie zsyntetyzować w innym języku (zamiana mowy na mowę).

Synteza oparta na zdarzeniach

Określ głos syntezy, przypisując voice_name wystąpienie, i podaj program obsługi zdarzeń dla Synthesizing zdarzenia w celu pobrania dźwięku. Poniższy przykład zapisuje przetłumaczony dźwięk jako plik .wav.

Ważne

Synteza oparta na zdarzeniach działa tylko z pojedynczym tłumaczeniem. Nie należy dodawać wielu docelowych języków tłumaczenia. voice_name Ponadto wartość powinna być tym samym językiem co docelowy język tłumaczenia. Na przykład "de" można mapować 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"

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

    translation_recognizer.synthesizing.connect(synthesis_callback)

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

    result = translation_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()

Synteza ręczna

Słownik umożliwia translations syntetyzowanie dźwięku z tekstu tłumaczenia. Iteruj przez każde tłumaczenie i syntetyzuje je. Podczas tworzenia SpeechSynthesizer wystąpienia SpeechConfig obiekt musi mieć jego speech_synthesis_voice_name właściwość ustawioną na żądany głos.

Poniższy przykład tłumaczy się na pięć języków. Każde tłumaczenie jest następnie syntetyzowane do pliku audio w odpowiednim języku neuronowym.

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

Aby uzyskać więcej informacji na temat syntezy mowy, zobacz podstawy syntezy mowy.

Tłumaczenie wielojęzyczne z identyfikacją języka

Aby zapoznać się z kompletnym przykładem kodu, zobacz identyfikację języka.

Interfejs API REST zamiany mowy na tekst — dokumentacja | interfejsu API REST zamiany mowy na tekst w celu uzyskania krótkiej dokumentacji | audio — dodatkowe przykłady w usłudze GitHub

Możesz użyć interfejsu API REST do tłumaczenia mowy, ale jeszcze nie dołączyliśmy tutaj przewodnika. Wybierz inny język programowania, aby rozpocząć pracę i dowiedzieć się więcej o pojęciach.

W tym przewodniku z instrukcjami dowiesz się, jak rozpoznawać ludzką mowę i tłumaczyć ją na inny język.

Aby uzyskać więcej informacji na temat tłumaczenia mowy, zobacz omówienie tłumaczenia mowy:

Tłumaczenie mowy na tekst
Tłumaczenie mowy na wiele języków docelowych
Wykonywanie tłumaczenia mowy bezpośredniej na mowę

Wymagania wstępne

Subskrypcja platformy Azure — utwórz jedną bezpłatnie.
Utwórz zasób usługi Mowa w witrynie Azure Portal.
Klucz zasobu usługi Mowa i region. Po wdrożeniu zasobu usługi Mowa wybierz pozycję Przejdź do zasobu , aby wyświetlić klucze i zarządzać nimi. Aby uzyskać więcej informacji na temat zasobów usług Azure AI, zobacz Pobieranie kluczy dla zasobu.

Pobierz i zainstaluj

Wykonaj następujące kroki i zapoznaj się z przewodnikiem Szybki start interfejsu wiersza polecenia usługi Mowa, aby uzyskać inne wymagania dotyczące platformy.

Uruchom następujące polecenie interfejsu wiersza polecenia platformy .NET, aby zainstalować interfejs wiersza polecenia usługi Mowa:
```
dotnet tool install --global Microsoft.CognitiveServices.Speech.CLI
```
Uruchom następujące polecenia, aby skonfigurować klucz zasobu usługi Mowa i region. Zastąp SUBSCRIPTION-KEY ciąg kluczem zasobu usługi Mowa i zastąp REGION element regionem zasobu usługi Mowa.
- Terminal
- Program PowerShell
```
spx config @key --set SUBSCRIPTION-KEY
spx config @region --set REGION
```
```
spx --% config @key --set SUBSCRIPTION-KEY
spx --% config @region --set REGION
```

Ustawianie języków źródłowych i docelowych

To polecenie wywołuje interfejs wiersza polecenia usługi Mowa, aby przetłumaczyć mowę z mikrofonu z języka włoskiego na francuski:

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

Share via

Jak rozpoznawać i tłumaczyć mowę

Poufne dane i zmienne środowiskowe

Tworzenie konfiguracji tłumaczenia mowy

Zmienianie języka źródłowego

Dodawanie języka tłumaczenia

Inicjowanie rozpoznawania tłumaczenia

Tłumaczenie mowy

Tłumaczenie oparte na zdarzeniach

Syntetyzowanie tłumaczeń

Synteza oparta na zdarzeniach

Synteza ręczna

Tłumaczenie wielojęzyczne z identyfikacją języka

Tłumaczenie mowy wielojęzycznej bez kandydatów do języka źródłowego

Poufne dane i zmienne środowiskowe

Tworzenie konfiguracji tłumaczenia mowy

Zmienianie języka źródłowego

Dodawanie języka tłumaczenia

Inicjowanie rozpoznawania tłumaczenia

Tłumaczenie mowy

Syntetyzowanie tłumaczeń

Synteza oparta na zdarzeniach

Synteza ręczna

Tłumaczenie wielojęzyczne z identyfikacją języka

Poufne dane i zmienne środowiskowe

Tworzenie konfiguracji tłumaczenia mowy

Zmienianie języka źródłowego

Dodawanie języka tłumaczenia

Inicjowanie rozpoznawania tłumaczenia

Tłumaczenie mowy

Syntetyzowanie tłumaczeń

Synteza oparta na zdarzeniach

Synteza ręczna

Tworzenie konfiguracji tłumaczenia

Inicjowanie tłumacza

Tłumaczenie mowy

Określanie języka docelowego

Rozpoznawanie pojedynczego strzału

Ciągłe tłumaczenie

Wybieranie języka źródłowego

Wybierz co najmniej jeden język docelowy

Poufne dane i zmienne środowiskowe

Tworzenie konfiguracji tłumaczenia mowy

Zmienianie języka źródłowego

Dodawanie języka tłumaczenia

Inicjowanie rozpoznawania tłumaczenia

Tłumaczenie mowy

Syntetyzowanie tłumaczeń

Synteza oparta na zdarzeniach

Synteza ręczna

Tłumaczenie wielojęzyczne z identyfikacją języka

Wymagania wstępne

Pobierz i zainstaluj

Ustawianie języków źródłowych i docelowych

Następne kroki

Dodatkowe zasoby