Erkennen und Übersetzen von Sprache

Artikel
09/20/2024

Referenzdokumentation | Paket (NuGet) | Zusätzliche Beispiele auf GitHub

In dieser Schrittanleitung erfahren Sie, wie Sie menschliche Sprache erkennen und in eine andere Sprache übersetzen.

Weitere Informationen finden Sie in der Übersicht zur Sprachübersetzung.

Übersetzen von Sprache in Text
Übersetzen von Sprache in mehrere Zielsprachen
Durchführen einer direkten Übersetzung von Sprache in Sprache

Vertrauliche Daten und Umgebungsvariablen

Der Beispielquellcode in diesem Artikel benötigt Umgebungsvariablen zum Speichern vertraulicher Daten, z. B. den Schlüssel und die Region der Speech-Ressource. Die Program-Klasse enthält zwei static readonly string-Werte, die von den Umgebungsvariablen des Hostcomputers zugewiesen werden: SPEECH__SUBSCRIPTION__KEY und SPEECH__SERVICE__REGION. Beide Felder befinden sich im Klassenbereich, sodass sie innerhalb vom Methodentext der Klasse zugänglich sind.

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

Weitere Informationen zu Umgebungsvariablen finden Sie unter Umgebungsvariablen und Anwendungskonfiguration.

Wichtig

Wenn Sie einen API-Schlüssel verwenden, speichern Sie ihn an einer anderen Stelle sicher, z. B. in Azure Key Vault. Fügen Sie den API-Schlüssel nicht direkt in Ihren Code ein, und machen Sie ihn nicht öffentlich zugänglich.

Weitere Informationen zur Sicherheit von KI Services finden Sie unter Authentifizieren von Anforderungen an Azure KI Services.

Erstellen einer Sprachübersetzungskonfiguration

Um den Speech-Dienst über das Speech SDK aufrufen zu können, muss eine SpeechTranslationConfig-Instanz erstellt werden. Diese Klasse enthält Informationen zu Ihrem Abonnement. Hierzu zählen etwa Ihr Schlüssel und die zugeordnete Region, der Endpunkt, der Host oder das Autorisierungstoken.

Tipp

Eine Konfiguration ist immer erforderlich. Dabei spielt es keine Rolle, ob Sie eine Spracherkennung, eine Sprachsynthese, eine Übersetzung oder eine Absichtserkennung durchführen möchten.

Sie können SpeechTranslationConfig auf verschiedene Arten initialisieren:

Mit einem Abonnement: Übergeben Sie einen Schlüssel und die zugeordnete Region.
Mit einem Endpunkt: Übergeben Sie einen Endpunkt für den Speech-Dienst. Ein Schlüssel oder Autorisierungstoken ist optional.
Mit einem Host: Übergeben Sie eine Hostadresse. Ein Schlüssel oder Autorisierungstoken ist optional.
Mit einem Autorisierungstoken: Übergeben Sie ein Autorisierungstoken und die zugeordnete Region.

Sehen wir uns an, wie Sie eine SpeechTranslationConfig-Instanz mithilfe eines Schlüssels und einer Region erstellen. Rufen Sie den Sprach-Ressourcenschlüssel und die Region im Azure-Portal ab.

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

Ändern der Quellsprache

Eine häufige Aufgabe bei der Sprachübersetzung ist die Angabe der Eingabesprache (Quellsprache). Das folgende Beispiel zeigt, wie Sie die Eingabesprache in Italienisch ändern. Interagieren Sie in Ihrem Code mit der SpeechTranslationConfig-Instanz, und weisen Sie die SpeechRecognitionLanguage-Eigenschaft zu:

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

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

Von der Eigenschaft SpeechRecognitionLanguage wird eine Zeichenfolge im Format „Sprache-Gebietsschema“ erwartet. Weitere Informationen finden Sie in der Liste der unterstützten Spracherkennungs-Gebietsschemas.

Hinzufügen der Übersetzungssprache

Eine weitere häufige Aufgabe der Sprachübersetzung ist die Angabe von Zielsprachen für die Übersetzung. Mindestens eine ist erforderlich, aber es werden mehrere unterstützt. Im folgenden Codeausschnitt sind sowohl Französisch als auch Deutsch als Zielsprachen für die Übersetzung angegeben:

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

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

Mit jedem Aufruf von AddTargetLanguage wird eine neue Zielübersetzungssprache angegeben. Anders ausgedrückt: Wenn für die Ausgangssprache eine Spracherkennung erfolgt, wird im Rahmen des daraus resultierenden Übersetzungsvorgangs eine Zielübersetzung bereitgestellt.

Initialisieren einer Übersetzungserkennung

Nach der Erstellung einer SpeechTranslationConfig-Instanz muss TranslationRecognizer initialisiert werden. Wenn Sie die TranslationRecognizer-Klasse initialisieren, müssen Sie ihr Ihre speechTranslationConfig-Instanz übergeben. Das Konfigurationsobjekt stellt Anmeldeinformationen bereit, die der Speech-Dienst zur Überprüfung Ihrer Anforderung benötigt.

Wenn Sie für die Spracherkennung das Standardmikrofon Ihres Geräts verwenden, sollte die TranslationRecognizer-Instanz wie folgt aussehen:

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

Wenn Sie das Audioeingabegerät angeben möchten, müssen Sie eine AudioConfig-Klasseninstanz erstellen und beim Initialisieren von TranslationRecognizer den Parameter audioConfig angeben.

Tipp

Informationen zum Abrufen der Geräte-ID für Ihr Audioeingabegerät finden Sie hier.

Verweisen Sie zunächst wie folgt auf das AudioConfig-Objekt:

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

Ein audioConfig-Parameter ist auch erforderlich, wenn Sie anstelle eines Mikrofons eine Audiodatei verwenden möchten. In diesem Fall rufen Sie beim Erstellen der AudioConfig-Klasseninstanz allerdings FromWavFileInput (anstelle von FromDefaultMicrophoneInput) auf und übergeben den Parameter filename:

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

Übersetzen von gesprochener Sprache

Zum Übersetzen von Sprache benötigt das Speech SDK eine Audioeingabe von einem Mikrofon oder einer Audiodatei. Die Spracherkennung erfolgt vor der Sprachübersetzung. Nachdem alle Objekte initialisiert wurden, verwenden Sie die Funktion „recognize-once“, und rufen Sie das Ergebnis ab:

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

Weitere Informationen zur Spracherkennung finden Sie unter Grundlegendes zur Spracherkennung.

Ereignisbasierte Übersetzung

Das TranslationRecognizer-Objekt macht ein einzelnes Recognizing-Ereignis verfügbar. Das Ereignis wird mehrmals ausgelöst und bietet einen Mechanismus, um Zwischenübersetzungsergebnisse abzurufen.

Hinweis

Zwischenübersetzungsergebnisse sind nicht verfügbar, wenn Sie mehrsprachige Sprachübersetzung verwenden.

Im folgenden Beispiel werden die Zwischenübersetzungsergebnisse in der Konsole gedruckt:

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

Synthetisieren von Übersetzungen

Nach erfolgreicher Spracherkennung und -übersetzung werden alle Übersetzungen in einem Wörterbuch bereitgestellt. Der Wörterbuchschlüssel Translations ist die Zielübersetzungssprache, und der Wert ist der übersetzte Text. Erkannte Sprache kann übersetzt und dann in einer anderen Sprache synthetisiert werden (Sprache-zu-Sprache).

Ereignisbasierte Synthese

Das TranslationRecognizer-Objekt macht ein einzelnes Synthesizing-Ereignis verfügbar. Das Ereignis wird mehrmals ausgelöst und bietet einen Mechanismus, mit dem das synthetische Audioformat aus dem Übersetzungserkennungsergebnis abgerufen werden kann. Weitere Informationen zum Übersetzen in mehrere Sprachen finden Sie unter Manuelle Synthese.

Geben Sie die Synthesestimme an, indem Sie eine VoiceName-Instanz zuweisen und einen Ereignishandler für das Synthesizing-Ereignis zum Abrufen der Audioinhalte bereitstellen. Im folgenden Beispiel wird die übersetzte Audiodatei als WAV-Datei gespeichert.

Wichtig

Die ereignisbasierte Synthese funktioniert nur mit einer einzelnen Übersetzung. Fügen Sie nicht mehrere Zielsprachen für die Übersetzung hinzu. Zudem muss die Sprache im Wert VoiceName mit der Zielübersetzungssprache übereinstimmen. Beispielsweise kann "de" dann "de-DE-Hedda" zugeordnet werden.

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

Manuelle Synthese

Sie können das Translations-Wörterbuch verwenden, um Audiodaten aus dem Übersetzungstext zu synthetisieren. Durchlaufen Sie die Übersetzungen, und synthetisieren Sie sie. Beim Erstellen einer SpeechSynthesizer-Instanz muss die SpeechSynthesisVoiceName-Eigenschaft des SpeechConfig-Objekts auf die gewünschte Stimme festgelegt werden.

Im folgenden Beispiel werden fünf Sprachen übersetzt. Jede Übersetzung wird dann in eine Audiodatei in der entsprechenden neuronalen Sprache synthetisiert.

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

Weitere Informationen zur Sprachsynthese finden Sie unter Grundlegendes zur Sprachsynthese.

Mehrsprachige Übersetzung mit Sprachidentifikation

In vielen Szenarios wissen Sie möglicherweise nicht, welche Eingabesprachen angegeben werden sollen. Mithilfe der Sprachenerkennung können Sie bis zu zehn mögliche Eingabesprachen erkennen und automatisch in Ihre Zielsprachen übersetzen.

Im folgenden Beispiel wird erwartet, dass en-US oder zh-CN erkannt werden, da sie in AutoDetectSourceLanguageConfig definiert sind. Anschließend wird die Sprache wie in den Aufrufen von AddTargetLanguage() angegeben in de und fr übersetzt.

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

Ein vollständiges Codebeispiel finden Sie unter Sprachenerkennung.

Mehrsprachige Sprachübersetzung ohne Quellsprachkandidaten

Die mehrsprachige Sprachübersetzung implementiert eine neue Ebene der Sprachübersetzungstechnologie, die verschiedene Funktionen entsperrt, einschließlich der Fehlenden Eingabesprache und der Behandlung von Sprachschaltern innerhalb derselben Sitzung. Diese Features ermöglichen eine neue Ebene von Sprachübersetzungsfunktionen, die in Ihre Produkte implementiert werden können.

Wenn Sie derzeit Sprach-ID mit Sprachübersetzung verwenden, müssen Sie das SpeechTranslationConfig-Objekt vom v2-Endpunkt erstellen. Ersetzen Sie die Zeichenfolge „YourServiceRegion“ durch Ihre Sprachressourcenregion (z. B. „westus“). Ersetzen Sie „YourSubscriptionKey“ durch Ihren Sprachressourcenschlüssel.

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

Geben Sie die Übersetzungszielsprachen an. Ersetzen Sie durch Sprachen Ihrer Wahl. Sie können weitere Zeilen hinzufügen.

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

Ein wichtiges Unterscheidungsmerkmal bei der mehrsprachigen Sprachübersetzung ist, dass Sie die Quellsprache nicht angeben müssen. Dies liegt daran, dass der Dienst die Quellsprache automatisch erkennt. Erstellen Sie das AutoDetectSourceLanguageConfig-Objekt mit der fromOpenRange-Methode, um dem Dienst mitzuteilen, dass Sie die mehrsprachige Sprachübersetzung ohne Angabe der Quellsprache verwenden möchten.

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

Ein vollständiges Codebeispiel mit dem Speech SDK finden Sie in den Sprachübersetzungsbeispielen auf GitHub.

Verwenden einer benutzerdefinierten Übersetzung in der Sprachübersetzung

Das Feature für benutzerdefinierte Übersetzungen in der Sprachübersetzung ist nahtlos in den Azure-Dienst für benutzerdefinierte Übersetzungen integriert, sodass Sie präzisere und maßgeschneiderte Übersetzungen erhalten. Da die Integration die Funktionen des Azure-Diensts für benutzerdefinierte Übersetzungen direkt nutzt, müssen Sie eine Ressource für mehrere Dienste verwenden, um die ordnungsgemäße Funktionsweise der gesamten Funktionen sicherzustellen. Ausführliche Anweisungen finden Sie im Leitfaden zum Erstellen einer Ressource für mehrere Dienste für Azure KI Services.

Sehen Sie sich darüber hinaus für das Offlinetraining von „Benutzerdefinierter Translator“ und den Abruf einer Kategorie-ID das ausführliche Skript unter Schnellstart: Erstellen, Bereitstellen und Verwenden eines benutzerdefinierten Modells: Benutzerdefinierter Translator an.

// Creates an instance of a translation recognizer using speech translation configuration
// You should use the same subscription key, which you used to generate the custom model before.
// V2 endpoint is required for the “Custom Translation” feature. Example: "wss://westcentralus.stt.speech.microsoft.com/speech/universal/v2"

try (SpeechTranslationConfig config = SpeechTranslationConfig.fromEndpoint(URI.create(endpointUrl), speechSubscriptionKey)) {

            // Sets source and target language(s).
           ….

            // Set the category id
            config.setCustomModelCategoryId("yourCategoryId");

       ….
}

Referenzdokumentation | Paket (NuGet) | Zusätzliche Beispiele auf GitHub

In dieser Schrittanleitung erfahren Sie, wie Sie menschliche Sprache erkennen und in eine andere Sprache übersetzen.

Weitere Informationen finden Sie in der Übersicht zur Sprachübersetzung.

Übersetzen von Sprache in Text
Übersetzen von Sprache in mehrere Zielsprachen
Durchführen einer direkten Übersetzung von Sprache in Sprache

Vertrauliche Daten und Umgebungsvariablen

Der Beispielquellcode in diesem Artikel benötigt Umgebungsvariablen zum Speichern vertraulicher Daten, z. B. den Schlüssel und die Region der Speech-Ressource. Die C++-Codedatei enthält zwei Zeichenfolgenwerte, die von den Umgebungsvariablen des Hostcomputers zugewiesen werden: SPEECH__SUBSCRIPTION__KEY und SPEECH__SERVICE__REGION. Beide Felder befinden sich im Klassenbereich, sodass sie innerhalb vom Methodentext der Klasse zugänglich sind.

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

Weitere Informationen zu Umgebungsvariablen finden Sie unter Umgebungsvariablen und Anwendungskonfiguration.

Wichtig

Weitere Informationen zur Sicherheit von KI Services finden Sie unter Authentifizieren von Anforderungen an Azure KI Services.

Erstellen einer Sprachübersetzungskonfiguration

Tipp

Eine Konfiguration ist immer erforderlich. Dabei spielt es keine Rolle, ob Sie eine Spracherkennung, eine Sprachsynthese, eine Übersetzung oder eine Absichtserkennung durchführen möchten.

Sie können SpeechTranslationConfig auf verschiedene Arten initialisieren:

Mit einem Abonnement: Übergeben Sie einen Schlüssel und die zugeordnete Region.
Mit einem Endpunkt: Übergeben Sie einen Endpunkt für den Speech-Dienst. Ein Schlüssel oder Autorisierungstoken ist optional.
Mit einem Host: Übergeben Sie eine Hostadresse. Ein Schlüssel oder Autorisierungstoken ist optional.
Mit einem Autorisierungstoken: Übergeben Sie ein Autorisierungstoken und die zugeordnete Region.

Sehen wir uns an, wie Sie eine SpeechTranslationConfig-Instanz mithilfe eines Schlüssels und einer Region erstellen. Rufen Sie den Sprach-Ressourcenschlüssel und die Region im Azure-Portal ab.

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

Ändern der Quellsprache

Eine häufige Aufgabe bei der Sprachübersetzung ist die Angabe der Eingabesprache (Quellsprache). Das folgende Beispiel zeigt, wie Sie die Eingabesprache in Italienisch ändern. Interagieren Sie in Ihrem Code mit der SpeechTranslationConfig-Instanz, und rufen Sie die SetSpeechRecognitionLanguage-Methode auf.

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

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

Hinzufügen der Übersetzungssprache

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

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

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

Initialisieren einer Übersetzungserkennung

Nach der Erstellung einer SpeechTranslationConfig-Instanz muss TranslationRecognizer initialisiert werden. Wenn Sie die TranslationRecognizer-Klasse initialisieren, müssen Sie ihr Ihre translationConfig-Instanz übergeben. Das Konfigurationsobjekt stellt Anmeldeinformationen bereit, die der Speech-Dienst zur Überprüfung Ihrer Anforderung benötigt.

Wenn Sie für die Spracherkennung das Standardmikrofon Ihres Geräts verwenden, sollte TranslationRecognizer wie folgt aussehen:

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

Wenn Sie das Audioeingabegerät angeben möchten, müssen Sie eine AudioConfig-Klasseninstanz erstellen und beim Initialisieren von TranslationRecognizer den Parameter audioConfig angeben.

Tipp

Informationen zum Abrufen der Geräte-ID für Ihr Audioeingabegerät finden Sie hier.

Verweisen Sie zunächst wie folgt auf das AudioConfig-Objekt:

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

Übersetzen von gesprochener Sprache

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

Weitere Informationen zur Spracherkennung finden Sie unter Grundlegendes zur Spracherkennung.

Synthetisieren von Übersetzungen

Ereignisbasierte Synthese

Geben Sie die Synthesestimme an, indem Sie eine SetVoiceName-Instanz zuweisen und einen Ereignishandler für das Synthesizing-Ereignis zum Abrufen der Audioinhalte bereitstellen. Im folgenden Beispiel wird die übersetzte Audiodatei als WAV-Datei gespeichert.

Wichtig

Die ereignisbasierte Synthese funktioniert nur mit einer einzelnen Übersetzung. Fügen Sie nicht mehrere Zielsprachen für die Übersetzung hinzu. Zudem muss die Sprache im Wert SetVoiceName mit der Zielübersetzungssprache übereinstimmen. Beispielsweise kann "de" dann "de-DE-Hedda" zugeordnet werden.

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

Manuelle Synthese

Sie können das Translations-Wörterbuch verwenden, um Audiodaten aus dem Übersetzungstext zu synthetisieren. Durchlaufen Sie die Übersetzungen, und synthetisieren Sie sie. Beim Erstellen einer SpeechSynthesizer-Instanz muss die SetSpeechSynthesisVoiceName-Eigenschaft des SpeechConfig-Objekts auf die gewünschte Stimme festgelegt werden.

Im folgenden Beispiel werden fünf Sprachen übersetzt. Jede Übersetzung wird dann in eine Audiodatei in der entsprechenden neuronalen Sprache synthetisiert.

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

Weitere Informationen zur Sprachsynthese finden Sie unter Grundlegendes zur Sprachsynthese.

Mehrsprachige Übersetzung mit Sprachidentifikation

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

Ein vollständiges Codebeispiel finden Sie unter Sprachenerkennung.

Referenzdokumentation | Paket (Go) | Zusätzliche Beispiele auf GitHub

Das Speech SDK für Go unterstützt die Sprachübersetzung nicht. Wählen Sie eine andere Programmiersprache aus, oder verwenden Sie die Go-Referenz und -Beispiele unter dem entsprechenden Link am Anfang dieses Artikels.

Referenzdokumentation | Zusätzliche Beispiele auf GitHub

In dieser Schrittanleitung erfahren Sie, wie Sie menschliche Sprache erkennen und in eine andere Sprache übersetzen.

Weitere Informationen finden Sie in der Übersicht zur Sprachübersetzung.

Übersetzen von Sprache in Text
Übersetzen von Sprache in mehrere Zielsprachen
Durchführen einer direkten Übersetzung von Sprache in Sprache

Vertrauliche Daten und Umgebungsvariablen

Der Beispielquellcode in diesem Artikel benötigt Umgebungsvariablen zum Speichern vertraulicher Daten, z. B. den Schlüssel und die Region der Speech-Ressource. Die Java-Codedatei enthält zwei static final String-Werte, die von den Umgebungsvariablen des Hostcomputers zugewiesen werden: SPEECH__SUBSCRIPTION__KEY und SPEECH__SERVICE__REGION. Beide Felder befinden sich im Klassenbereich, sodass sie innerhalb vom Methodentext der Klasse zugänglich sind.

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

Weitere Informationen zu Umgebungsvariablen finden Sie unter Umgebungsvariablen und Anwendungskonfiguration.

Wichtig

Weitere Informationen zur Sicherheit von KI Services finden Sie unter Authentifizieren von Anforderungen an Azure KI Services.

Erstellen einer Sprachübersetzungskonfiguration

Tipp

Eine Konfiguration ist immer erforderlich. Dabei spielt es keine Rolle, ob Sie eine Spracherkennung, eine Sprachsynthese, eine Übersetzung oder eine Absichtserkennung durchführen möchten.

Sie können eine SpeechTranslationConfig-Instanz auf verschiedene Arten initialisieren:

Mit einem Abonnement: Übergeben Sie einen Schlüssel und die zugeordnete Region.
Mit einem Endpunkt: Übergeben Sie einen Endpunkt für den Speech-Dienst. Ein Schlüssel oder Autorisierungstoken ist optional.
Mit einem Host: Übergeben Sie eine Hostadresse. Ein Schlüssel oder Autorisierungstoken ist optional.
Mit einem Autorisierungstoken: Übergeben Sie ein Autorisierungstoken und die zugeordnete Region.

Sehen wir uns an, wie Sie eine SpeechTranslationConfig-Instanz mithilfe eines Schlüssels und einer Region erstellen. Rufen Sie den Sprach-Ressourcenschlüssel und die Region im Azure-Portal ab.

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

Ändern der Quellsprache

Eine häufige Aufgabe bei der Sprachübersetzung ist die Angabe der Eingabesprache (Quellsprache). Das folgende Beispiel zeigt, wie Sie die Eingabesprache in Italienisch ändern. Interagieren Sie in Ihrem Code mit der SpeechTranslationConfig-Instanz, und rufen Sie die setSpeechRecognitionLanguage-Methode auf.

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

Von der Funktion setSpeechRecognitionLanguage wird eine Zeichenfolge im Format „Sprache-Gebietsschema“ erwartet. Weitere Informationen finden Sie in der Liste der unterstützten Spracherkennungs-Gebietsschemas.

Hinzufügen der Übersetzungssprache

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

Mit jedem Aufruf von addTargetLanguage wird eine neue Zielübersetzungssprache angegeben. Anders ausgedrückt: Wenn für die Ausgangssprache eine Spracherkennung erfolgt, wird im Rahmen des daraus resultierenden Übersetzungsvorgangs eine Zielübersetzung bereitgestellt.

Initialisieren einer Übersetzungserkennung

Wenn Sie für die Spracherkennung das Standardmikrofon Ihres Geräts verwenden, sollte TranslationRecognizer wie folgt aussehen:

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

Wenn Sie das Audioeingabegerät angeben möchten, müssen Sie eine AudioConfig-Klasseninstanz erstellen und beim Initialisieren von TranslationRecognizer den Parameter audioConfig angeben.

Tipp

Informationen zum Abrufen der Geräte-ID für Ihr Audioeingabegerät finden Sie hier.

Verweisen Sie zunächst wie folgt auf das AudioConfig-Objekt:

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

Ein audioConfig-Parameter ist auch erforderlich, wenn Sie anstelle eines Mikrofons eine Audiodatei verwenden möchten. In diesem Fall rufen Sie beim Erstellen der AudioConfig-Klasseninstanz allerdings fromWavFileInput (anstelle von fromDefaultMicrophoneInput) auf und übergeben den Parameter filename:

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

Übersetzen von gesprochener Sprache

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 translationRecognitionResult = translationRecognizer.recognizeOnceAsync().get();
        if (translationRecognitionResult.getReason() == ResultReason.TranslatedSpeech) {
            System.out.printf("Recognized: \"%s\"\n", translationRecognitionResult.getText());
            for (Map.Entry<String, String> pair : translationRecognitionResult.getTranslations().entrySet()) {
                System.out.printf("Translated into '%s': %s\n", pair.getKey(), pair.getValue());
            }
        }
    }
}

Weitere Informationen zur Spracherkennung finden Sie unter Grundlegendes zur Spracherkennung.

Synthetisieren von Übersetzungen

Nach erfolgreicher Spracherkennung und -übersetzung werden alle Übersetzungen in einem Wörterbuch bereitgestellt. Die getTranslations-Funktion gibt ein Wörterbuch mit dem Schlüssel als Zielübersetzungssprache zurück, und der Wert ist der übersetzte Text. Erkannte Sprache kann übersetzt und dann in einer anderen Sprache synthetisiert werden (Sprache-zu-Sprache).

Ereignisbasierte Synthese

Das TranslationRecognizer-Objekt macht ein einzelnes synthesizing-Ereignis verfügbar. Das Ereignis wird mehrmals ausgelöst und bietet einen Mechanismus, mit dem das synthetische Audioformat aus dem Übersetzungserkennungsergebnis abgerufen werden kann. Weitere Informationen zum Übersetzen in mehrere Sprachen finden Sie unter Manuelle Synthese.

Geben Sie die Synthesestimme an, indem Sie eine setVoiceName-Instanz zuweisen und einen Ereignishandler für das synthesizing-Ereignis zum Abrufen der Audioinhalte bereitstellen. Im folgenden Beispiel wird die übersetzte Audiodatei als WAV-Datei gespeichert.

Wichtig

Die ereignisbasierte Synthese funktioniert nur mit einer einzelnen Übersetzung. Fügen Sie nicht mehrere Zielsprachen für die Übersetzung hinzu. Zudem muss die Sprache im Wert setVoiceName mit der Zielübersetzungssprache übereinstimmen. Beispielsweise kann "de" dann "de-DE-Hedda" zugeordnet werden.

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 translationRecognitionResult = translationRecognizer.recognizeOnceAsync().get();
        if (translationRecognitionResult.getReason() == ResultReason.TranslatedSpeech) {
            System.out.printf("Recognized: \"%s\"\n", translationRecognitionResult.getText());
            for (Map.Entry<String, String> pair : translationRecognitionResult.getTranslations().entrySet()) {
                String language = pair.getKey();
                String translation = pair.getValue();
                System.out.printf("Translated into '%s': %s\n", language, translation);
            }
        }
    }
}

Manuelle Synthese

Die getTranslations-Funktion gibt ein Wörterbuch zurück, das zum Synthetisieren von Audiodaten aus dem Übersetzungstext verwendet werden kann. Durchlaufen Sie die Übersetzungen, und synthetisieren Sie sie. Beim Erstellen einer SpeechSynthesizer-Instanz muss die setSpeechSynthesisVoiceName-Eigenschaft des SpeechConfig-Objekts auf die gewünschte Stimme festgelegt werden.

Im folgenden Beispiel werden fünf Sprachen übersetzt. Jede Übersetzung wird dann in eine Audiodatei in der entsprechenden neuronalen Sprache synthetisiert.

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 translationRecognitionResult = translationRecognizer.recognizeOnceAsync().get();
        if (translationRecognitionResult.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", translationRecognitionResult.getText());
            for (Map.Entry<String, String> pair : translationRecognitionResult.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();
                }
            }
        }
    }
}

Weitere Informationen zur Sprachsynthese finden Sie unter Grundlegendes zur Sprachsynthese.

Referenzdokumentation | Paket (npm) | Zusätzliche Beispiele auf GitHub | Quellcode der Bibliothek

In dieser Schrittanleitung erfahren Sie, wie Sie menschliche Sprache erkennen und in eine andere Sprache übersetzen.

Weitere Informationen finden Sie in der Übersicht zur Sprachübersetzung.

Übersetzen von Sprache in Text
Übersetzen von Sprache in mehrere Zielsprachen
Durchführen einer direkten Übersetzung von Sprache in Sprache

Erstellen einer Übersetzungskonfiguration

Um den Übersetzungsdienst über das Speech SDK aufrufen zu können, muss eine Konfiguration für die SpeechTranslationConfig-Instanz erstellt werden. Diese Klasse enthält Informationen zu Ihrem Abonnement. Hierzu zählen etwa Ihr Schlüssel und die zugeordnete Region, der Endpunkt, der Host oder das Autorisierungstoken.

Hinweis

Eine Konfiguration ist immer erforderlich. Dabei spielt es keine Rolle, ob Sie eine Spracherkennung, eine Sprachsynthese, eine Übersetzung oder eine Absichtserkennung durchführen möchten.

Sie können SpeechTranslationConfig auf verschiedene Arten initialisieren:

Mit einem Abonnement: Übergeben Sie einen Schlüssel und die zugeordnete Region.
Mit einem Endpunkt: Übergeben Sie einen Endpunkt für den Speech-Dienst. Ein Schlüssel oder Autorisierungstoken ist optional.
Mit einem Host: Übergeben Sie eine Hostadresse. Ein Schlüssel oder Autorisierungstoken ist optional.
Mit einem Autorisierungstoken: Übergeben Sie ein Autorisierungstoken und die zugeordnete Region.

Sehen wir uns an, wie Sie eine SpeechTranslationConfig-Instanz mithilfe eines Schlüssels und einer Region erstellen. Rufen Sie den Sprach-Ressourcenschlüssel und die Region im Azure-Portal ab.

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

Initialisieren eines Übersetzers

Nach der Erstellung einer SpeechTranslationConfig-Instanz muss TranslationRecognizer initialisiert werden. Wenn Sie die TranslationRecognizer-Klasse initialisieren, müssen Sie ihr Ihre speechTranslationConfig-Instanz übergeben. Das Konfigurationsobjekt stellt Anmeldeinformationen bereit, die der Übersetzungsdienst zur Überprüfung Ihrer Anforderung benötigt.

Wenn Sie gesprochene Sprache übersetzen, die über das Standardmikrofon Ihres Geräts bereitgestellt wird, sollte TranslationRecognizer wie folgt aussehen:

const translationRecognizer = new TranslationRecognizer(speechTranslationConfig);

Wenn Sie das Audioeingabegerät angeben möchten, müssen Sie eine AudioConfig-Klasseninstanz erstellen und beim Initialisieren von TranslationRecognizer den Parameter audioConfig angeben.

Tipp

Informationen zum Abrufen der Geräte-ID für Ihr Audioeingabegerät finden Sie hier.

Verweisen Sie wie folgt auf das AudioConfig-Objekt:

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

Ein audioConfig-Parameter ist auch erforderlich, wenn Sie anstelle eines Mikrofons eine Audiodatei verwenden möchten. Dies ist jedoch nur möglich, wenn Sie auf Node.js abzielen. In diesem Fall rufen Sie beim Erstellen der AudioConfig-Klasseninstanz fromWavFileOutput (anstelle von fromDefaultMicrophoneInput) auf und übergeben den Parameter filename:

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

Übersetzen von gesprochener Sprache

Von der Klasse TranslationRecognizer für das Speech SDK für JavaScript werden Methoden für die Sprachübersetzung verfügbar gemacht:

Einzelübersetzung (asynchron): Führt die Übersetzung in einem nicht blockierenden (asynchronen) Modus durch. Dabei wird eine einzelne Äußerung übersetzt. Zur Erkennung des Endes einer einzelnen Äußerung wird auf Stille am Ende gelauscht oder gewartet, bis maximal 15 Sekunden an Audiodaten verarbeitet wurden.
Fortlaufende Übersetzung (asynchron): Initialisiert asynchron einen fortlaufenden Übersetzungsvorgang. Der Benutzer registriert sich für Ereignisse und behandelt verschiedene Anwendungszustände. Zum Beenden der asynchronen fortlaufenden Übersetzung muss stopContinuousRecognitionAsync aufgerufen werden.

Weitere Informationen zum Auswählen eines Spracherkennungsmodus finden Sie unter Erste Schritte mit der Spracherkennung.

Angeben einer Zielsprache

Zum Übersetzen müssen Sie eine Ausgangssprache und mindestens eine Zielsprache angeben.

Sie können eine Ausgangssprache mithilfe eines Gebietsschemas auswählen, das in der Sprachübersetzungstabelle aufgeführt ist. Suchen Sie die Optionen für die übersetzte Sprache unter demselben Link.

Die Optionen für Zielsprachen unterscheiden sich, je nachdem, ob Sie Text anzeigen oder übersetzte synthetische Sprache anhören möchten. Ändern Sie zum Übersetzen aus dem Englischen ins Deutsche das Übersetzungskonfigurationsobjekt:

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

Einzelerkennung

Das folgende Beispiel zeigt eine asynchrone Einzelübersetzung mit recognizeOnceAsync:

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

Sie müssen etwas Code schreiben, um das Ergebnis zu behandeln. In diesem Beispiel wird result.reason für eine Übersetzung ins Deutsche ausgewertet:

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

Der Code kann auch Updates verarbeiten, die während der Verarbeitung der Übersetzung bereitgestellt werden. Sie können diese Updates verwenden, um visuelles Feedback zum Übersetzungsfortschritt bereitzustellen. In diesem Node.js-Beispiel in JavaScript werden diese Arten von Updates veranschaulicht. Der folgende Code zeigt auch Details an, die während des Übersetzungsprozesses erstellt wurden:

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

Fortlaufende Übersetzung

Die fortlaufende Übersetzung ist etwas komplexer als die Einzelerkennung. Für die kontinuierliche Erkennung müssen die Ereignisse recognizing, recognized und canceled abonniert werden, um die Erkennungsergebnisse zu erhalten. Sie müssen stopContinuousRecognitionAsync aufrufen, um die Übersetzung zu beenden

Im folgenden Beispiel wird eine fortlaufende Übersetzung für eine Audioeingabedatei durchgeführt. Als Erstes wird die Eingabe definiert und TranslationRecognizer initialisiert:

const translationRecognizer = new TranslationRecognizer(speechTranslationConfig);

Im folgenden Code abonnieren Sie die von TranslationRecognizer gesendeten Ereignisse:

recognizing: Signal für Ereignisse mit Übersetzungszwischenergebnissen
recognized: Signal für Ereignisse mit finalen Übersetzungsergebnissen. Diese Ergebnisse deuten auf einen erfolgreichen Übersetzungsversuch hin.
sessionStopped: Signal für Ereignisse, die das Ende einer Übersetzungssitzung (bzw. eines Übersetzungsvorgangs) angeben
canceled: Signal für Ereignisse mit Ergebnissen einer abgebrochenen Übersetzung. Diese Ereignisse weisen auf einen Übersetzungsversuch hin, der als Ergebnis eines direkten Abbruchs abgebrochen wurde. Alternativ weisen sie auf einen Datentransport- oder Protokollfehler hin.

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

Nach Abschluss der Einrichtung kann startContinuousRecognitionAsync aufgerufen werden:

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

Auswählen einer Ausgangssprache

Eine häufige Aufgabe bei der Sprachübersetzung ist die Angabe der Eingabesprache (Ausgangssprache). Das folgende Beispiel zeigt, wie Sie die Eingabesprache in Italienisch ändern. Navigieren Sie in Ihrem Code zur SpeechTranslationConfig-Instanz, und fügen Sie direkt darunter die folgende Zeile hinzu:

speechTranslationConfig.speechRecognitionLanguage = "it-IT";

Von der Eigenschaft speechRecognitionLanguage wird eine Zeichenfolge im Format „Sprache-Gebietsschema“ erwartet. Weitere Informationen finden Sie in der Liste der unterstützten Spracherkennungs-Gebietsschemas.

Auswählen mindestens einer Zielsprache

Das Speech SDK kann parallel in mehrere Zielsprachen übersetzen. Die verfügbaren Zielsprachen unterscheiden sich etwas von der Liste der Quellsprachen. Sie geben Zielsprachen mithilfe eines Sprachcodes anstelle eines Gebietsschemas an.

Eine Liste der Sprachcodes für Textziele finden Sie in der Sprachübersetzungstabelle auf der Seite „Sprachunterstützung“. Hier finden Sie auch Details zur Übersetzung in synthetische Sprachen.

Mit dem folgenden Code wird Deutsch als Zielsprache hinzugefügt:

speechTranslationConfig.addTargetLanguage("de");

Da mehrere Zielsprachenübersetzungen möglich sind, muss der Code die Zielsprache angeben, wenn das Ergebnis untersucht wird. Der folgende Code ruft Übersetzungsergebnisse für Deutsch ab.

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

Referenzdokumentation | Paket (Download) | Zusätzliche Beispiele auf GitHub

Das Speech SDK für Objective-C unterstützt zwar die Sprachübersetzung, aber wir haben hier noch keinen Leitfaden aufgenommen. Wählen Sie eine andere Programmiersprache aus, um loszulegen und sich über die Konzepte zu informieren, oder verwenden Sie die Objective-C-Referenz und -Beispiele unter dem entsprechenden Link am Anfang dieses Artikels.

Referenzdokumentation | Paket (Download) | Zusätzliche Beispiele auf GitHub

Das Speech SDK für Swift unterstützt zwar die Sprachübersetzung, aber wir haben hier noch keinen Leitfaden aufgenommen. Wählen Sie eine andere Programmiersprache aus, um loszulegen und sich über die Konzepte zu informieren, oder verwenden Sie die Swift-Referenz und -Beispiele unter dem entsprechenden Link am Anfang dieses Artikels.

Referenzdokumentation | Paket (PyPi) | Zusätzliche Beispiele auf GitHub

In dieser Schrittanleitung erfahren Sie, wie Sie menschliche Sprache erkennen und in eine andere Sprache übersetzen.

Weitere Informationen finden Sie in der Übersicht zur Sprachübersetzung.

Übersetzen von Sprache in Text
Übersetzen von Sprache in mehrere Zielsprachen
Durchführen einer direkten Übersetzung von Sprache in Sprache

Vertrauliche Daten und Umgebungsvariablen

Der Beispielquellcode in diesem Artikel benötigt Umgebungsvariablen zum Speichern vertraulicher Daten, wie z. B. den Schlüssel und die Region des Speech-Ressourcenabonnements. Die Python-Codedatei enthält zwei Werte, die von den Umgebungsvariablen des Hostcomputers zugewiesen werden: SPEECH__SUBSCRIPTION__KEY und SPEECH__SERVICE__REGION. Beide Variablen befinden sich im globalen Bereich und sind daher innerhalb der Funktionsdefinition der Codedatei zugänglich.

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

Weitere Informationen zu Umgebungsvariablen finden Sie unter Umgebungsvariablen und Anwendungskonfiguration.

Wichtig

Weitere Informationen zur Sicherheit von KI Services finden Sie unter Authentifizieren von Anforderungen an Azure KI Services.

Erstellen einer Sprachübersetzungskonfiguration

Tipp

Eine Konfiguration ist immer erforderlich. Dabei spielt es keine Rolle, ob Sie eine Spracherkennung, eine Sprachsynthese, eine Übersetzung oder eine Absichtserkennung durchführen möchten.

Sie können SpeechTranslationConfig auf verschiedene Arten initialisieren:

Mit einem Abonnement: Übergeben Sie einen Schlüssel und die zugeordnete Region.
Mit einem Endpunkt: Übergeben Sie einen Endpunkt für den Speech-Dienst. Ein Schlüssel oder Autorisierungstoken ist optional.
Mit einem Host: Übergeben Sie eine Hostadresse. Ein Schlüssel oder Autorisierungstoken ist optional.
Mit einem Autorisierungstoken: Übergeben Sie ein Autorisierungstoken und die zugeordnete Region.

Sehen wir uns an, wie Sie eine SpeechTranslationConfig-Instanz mithilfe eines Schlüssels und einer Region erstellen können. Rufen Sie den Sprach-Ressourcenschlüssel und die Region im Azure-Portal ab.

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

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

Ändern der Quellsprache

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

Von der Eigenschaft speech_recognition_language wird eine Zeichenfolge im Format „Sprache-Gebietsschema“ erwartet. Weitere Informationen finden Sie in der Liste der unterstützten Spracherkennungs-Gebietsschemas.

Hinzufügen der Übersetzungssprache

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

Mit jedem Aufruf von add_target_language wird eine neue Zielübersetzungssprache angegeben. Anders ausgedrückt: Wenn für die Ausgangssprache eine Spracherkennung erfolgt, wird im Rahmen des daraus resultierenden Übersetzungsvorgangs eine Zielübersetzung bereitgestellt.

Initialisieren einer Übersetzungserkennung

Nach der Erstellung einer SpeechTranslationConfig-Instanz muss TranslationRecognizer initialisiert werden. Wenn Sie die TranslationRecognizer-Klasse initialisieren, müssen Sie ihr Ihre translation_config-Instanz übergeben. Das Konfigurationsobjekt stellt Anmeldeinformationen bereit, die der Speech-Dienst zur Überprüfung Ihrer Anforderung benötigt.

Wenn Sie für die Spracherkennung das Standardmikrofon Ihres Geräts verwenden, sollte TranslationRecognizer wie folgt aussehen:

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)

Wenn Sie das Audioeingabegerät angeben möchten, müssen Sie eine AudioConfig-Klasseninstanz erstellen und beim Initialisieren von TranslationRecognizer den Parameter audio_config angeben.

Tipp

Informationen zum Abrufen der Geräte-ID für Ihr Audioeingabegerät finden Sie hier.

Verweisen Sie zunächst wie folgt auf das AudioConfig-Objekt:

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)

Ein audioConfig-Parameter ist auch erforderlich, wenn Sie anstelle eines Mikrofons eine Audiodatei verwenden möchten. In diesem Fall müssen Sie beim Erstellen einer AudioConfig-Klasseninstanz für den Aufruf allerdings filename="path-to-file.wav" anstelle von use_default_microphone=True verwenden und den Parameter filename angeben:

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)

Übersetzen von gesprochener Sprache

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...')
    translation_recognition_result = translation_recognizer.recognize_once()
    print(get_result_text(reason=translation_recognition_result.reason, result=translation_recognition_result))

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

translate_speech_to_text()

Weitere Informationen zur Spracherkennung finden Sie unter Grundlegendes zur Spracherkennung.

Synthetisieren von Übersetzungen

Nach erfolgreicher Spracherkennung und -übersetzung werden alle Übersetzungen in einem Wörterbuch bereitgestellt. Der Wörterbuchschlüssel translations ist die Zielübersetzungssprache, und der Wert ist der übersetzte Text. Erkannte Sprache kann übersetzt und dann in einer anderen Sprache synthetisiert werden (Sprache-zu-Sprache).

Ereignisbasierte Synthese

Geben Sie die Synthesestimme an, indem Sie eine voice_name-Instanz zuweisen und einen Ereignishandler für das Synthesizing-Ereignis zum Abrufen der Audioinhalte bereitstellen. Im folgenden Beispiel wird die übersetzte Audiodatei als WAV-Datei gespeichert.

Wichtig

Die ereignisbasierte Synthese funktioniert nur mit einer einzelnen Übersetzung. Fügen Sie nicht mehrere Zielsprachen für die Übersetzung hinzu. Zudem muss die Sprache im Wert voice_name mit der Zielübersetzungssprache übereinstimmen. Beispielsweise kann "de" dann "de-DE-Hedda" zugeordnet werden.

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}".')

    translation_recognition_result = translation_recognizer.recognize_once()
    print(get_result_text(reason=translation_recognition_result.reason, result=translation_recognition_result))

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

translate_speech_to_text()

Manuelle Synthese

Sie können das translations-Wörterbuch verwenden, um Audiodaten aus dem Übersetzungstext zu synthetisieren. Durchlaufen Sie die Übersetzungen, und synthetisieren Sie sie. Beim Erstellen einer SpeechSynthesizer-Instanz muss die speech_synthesis_voice_name-Eigenschaft des SpeechConfig-Objekts auf die gewünschte Stimme festgelegt werden.

Im folgenden Beispiel werden fünf Sprachen übersetzt. Jede Übersetzung wird dann in eine Audiodatei in der entsprechenden neuronalen Sprache synthetisiert.

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...')
    translation_recognition_result = translation_recognizer.recognize_once()
    synthesize_translations(result=translation_recognition_result)

def synthesize_translations(translation_recognition_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: "{translation_recognition_result.text}"')

    for language in translation_recognition_result.translations:
        translation = translation_recognition_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()

Weitere Informationen zur Sprachsynthese finden Sie unter Grundlegendes zur Sprachsynthese.

Mehrsprachige Übersetzung mit Sprachidentifikation

Ein vollständiges Codebeispiel finden Sie unter Sprachenerkennung.

REST-API-Referenz zur Spracherkennung | REST-API-Referenz zur Spracherkennung für kurze Audiodaten | Zusätzliche Beispiele auf GitHub

Sie können zwar die REST-API für die Sprachübersetzung verwenden, aber wir haben hier noch keinen Leitfaden aufgenommen. Wählen Sie eine andere Programmiersprache aus, um loszulegen und sich über die Konzepte zu informieren.

In dieser Schrittanleitung erfahren Sie, wie Sie menschliche Sprache erkennen und in eine andere Sprache übersetzen.

Weitere Informationen finden Sie in der Übersicht zur Sprachübersetzung.

Übersetzen von Sprache in Text
Übersetzen von Sprache in mehrere Zielsprachen
Durchführen einer direkten Übersetzung von Sprache in Sprache

Voraussetzungen

Ein Azure-Abonnement. Sie können ein kostenloses Konto erstellen.
Erstellen Sie eine Speech-Ressource im Azure-Portal.
Abrufen des Speech-Ressourcenschlüssel und des Endpunkts. Wählen Sie nach der Bereitstellung Ihrer Speech-Ressource Zu Ressource wechseln aus, um Schlüssel anzuzeigen und zu verwalten.

Herunterladen und installieren

Befolgen Sie diese Schritte und lesen Sie die Schnellstartanleitung für Speech CLI, um weitere Anforderungen für Ihre Plattform zu erfahren.

Führen Sie den folgenden .NET CLI-Befehl aus, um die Speech CLI zu installieren:
```
dotnet tool install --global Microsoft.CognitiveServices.Speech.CLI
```
Führen Sie die folgenden Befehle aus, um Ihren Speech-Ressourcenschlüssel und Ihre Region zu konfigurieren. Ersetzen Sie SUBSCRIPTION-KEY durch den Schlüssel Ihrer Speech-Ressource und REGION durch die Region Ihrer Speech-Ressource.
- Terminal
- PowerShell
```
spx config @key --set SUBSCRIPTION-KEY
spx config @region --set REGION
```
```
spx --% config @key --set SUBSCRIPTION-KEY
spx --% config @region --set REGION
```

Festlegen der Quell- und Zielsprachen

Mit diesem Befehl wird die Speech CLI aufgerufen, um Sprache vom Mikrofon von Italienisch in Französisch zu übersetzen:

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

Freigeben über

Erkennen und Übersetzen von Sprache

Vertrauliche Daten und Umgebungsvariablen

Erstellen einer Sprachübersetzungskonfiguration

Ändern der Quellsprache

Hinzufügen der Übersetzungssprache

Initialisieren einer Übersetzungserkennung

Übersetzen von gesprochener Sprache

Ereignisbasierte Übersetzung

Synthetisieren von Übersetzungen

Ereignisbasierte Synthese

Manuelle Synthese

Mehrsprachige Übersetzung mit Sprachidentifikation

Mehrsprachige Sprachübersetzung ohne Quellsprachkandidaten

Verwenden einer benutzerdefinierten Übersetzung in der Sprachübersetzung

Vertrauliche Daten und Umgebungsvariablen

Erstellen einer Sprachübersetzungskonfiguration

Ändern der Quellsprache

Hinzufügen der Übersetzungssprache

Initialisieren einer Übersetzungserkennung

Übersetzen von gesprochener Sprache

Synthetisieren von Übersetzungen

Ereignisbasierte Synthese

Manuelle Synthese

Mehrsprachige Übersetzung mit Sprachidentifikation

Vertrauliche Daten und Umgebungsvariablen

Erstellen einer Sprachübersetzungskonfiguration

Ändern der Quellsprache

Hinzufügen der Übersetzungssprache

Initialisieren einer Übersetzungserkennung

Übersetzen von gesprochener Sprache

Synthetisieren von Übersetzungen

Ereignisbasierte Synthese

Manuelle Synthese

Erstellen einer Übersetzungskonfiguration

Initialisieren eines Übersetzers

Übersetzen von gesprochener Sprache

Angeben einer Zielsprache

Einzelerkennung

Fortlaufende Übersetzung

Auswählen einer Ausgangssprache

Auswählen mindestens einer Zielsprache

Vertrauliche Daten und Umgebungsvariablen

Erstellen einer Sprachübersetzungskonfiguration

Ändern der Quellsprache

Hinzufügen der Übersetzungssprache

Initialisieren einer Übersetzungserkennung

Übersetzen von gesprochener Sprache

Synthetisieren von Übersetzungen

Ereignisbasierte Synthese

Manuelle Synthese

Mehrsprachige Übersetzung mit Sprachidentifikation

Voraussetzungen

Herunterladen und installieren

Festlegen der Quell- und Zielsprachen

Nächste Schritte

Feedback

Zusätzliche Ressourcen