Real-Time Speech Translation Pipeline mit Open-Source-KI erstellen
Die Echtzeitübersetzung gesprochener Sprache gehört seit dem starken Aufschwung von Deep Learning Anfang der 2020er-Jahre zu den spannendsten Zielen dieser Technologie. Inspiriert von Science-Fiction-Ideen wie dem Universalübersetzer aus Star Trek wirkte die sofortige Übersetzung von Sprache schon immer faszinierend und zugleich wirtschaftlich sehr vielversprechend. Allein aus Effizienzgründen kann Echtzeitübersetzung mehrsprachige Kommunikation und geschäftliche Abstimmungen deutlich beschleunigen.
Nach vielen Fortschritten bei Text-to-Speech, Übersetzungsmodellen und automatischer Spracherkennung ist es heute möglich, einen Echtzeit-Workflow für Sprachübersetzung mit Open-Source-Technologien aufzubauen. In diesem Tutorial wird eine Python-basierte Übersetzungspipeline vorgestellt, die schneller als gesprochene Sprache arbeiten kann. Die Lösung kombiniert Whisper ASR, das Übersetzungsmodell Hunyuan MT und das TTS-System Soprano 80M. Abschließend wird gezeigt, wie diese drei Komponenten in einer Gradio-Anwendung verbunden werden können, um eine funktionsfähige Demo für Echtzeit-Sprachübersetzung zu erstellen.
Wichtige Erkenntnisse
End-to-End-Echtzeitübersetzung ist mit Open-Source-Werkzeugen möglich: Durch die Kombination von Whisper Large-v3 für automatische Spracherkennung, Hunyuan MT für Übersetzungen und Soprano 80M für Text-to-Speech können Entwickler eine Pipeline erstellen, die mehrere Sekunden Audio in unter einer Sekunde transkribiert, übersetzt und wieder als Sprache ausgibt, sofern moderne GPU-Hardware verwendet wird.
Modelleffizienz ist genauso wichtig wie Genauigkeit: Whisper bietet starke mehrsprachige Zero-Shot-Spracherkennung, Hunyuan MT liefert skalierbare und hochwertige Übersetzungen mit Modellen von 1,8B bis 7B Parametern, und Soprano ermöglicht besonders latenzarme Sprachsynthese. Zusammengenommen machen diese effizient ausgewählten Modelle Echtzeitverarbeitung möglich, ohne auf proprietäre Plattformen angewiesen zu sein.
Produktionsnahe Demos lassen sich mit wenig Integrationscode erstellen: Eine kompakte Python-Anwendung mit einer Gradio-Oberfläche reicht aus, um ASR, Übersetzung und TTS zu koordinieren. Dadurch wird deutlich, wie zugänglich Echtzeit-Sprachübersetzung inzwischen für Entwickler und Unternehmen geworden ist.
Whisper Large v3
Whisper ist ein fortschrittliches Modell für automatische Spracherkennung und Sprachübersetzung. Es wurde von OpenAI im Paper Robust Speech Recognition via Large-Scale Weak Supervision von Alec Radford und weiteren Autoren vorgestellt. Das Modell wurde mit mehr als fünf Millionen Stunden gelabelter Audiodaten trainiert und zeigt eine starke Zero-Shot-Leistung über zahlreiche Datensätze, Sprachen und reale Anwendungsszenarien hinweg.
Whisper Large-v3 unterstützt mehr als 99 Sprachen und bringt gezielte Verbesserungen gegenüber Whisper Large v2 mit. Dazu gehören ein eigener Kantonesisch-Token sowie deutlich bessere Ergebnisse, insbesondere bei Englisch. Das Modell verarbeitet Akzente, Hintergrundgeräusche und technische Fachbegriffe zuverlässiger, reduziert Fehler im Vergleich zu v2 um etwa 10–20 % und bietet gleichzeitig eine schnellere Verarbeitung in unterschiedlichen Audioumgebungen und für viele Sprachen, darunter Afrikaans, Arabisch, Chinesisch, Französisch, Deutsch, Hindi, Japanisch, Spanisch und viele weitere.
Mit Whisper Large v3 als ASR-Grundlage lässt sich gesprochene Eingabe aus nahezu jeder Quelle präzise in nutzbaren Text umwandeln, der anschließend für Übersetzung und Text-to-Speech verwendet werden kann.
Hunyuan MT
Das Hunyuan Translation Model in Version 1.5 besteht aus zwei Modellvarianten: HY-MT1.5-1.8B mit 1,8 Milliarden Parametern und HY-MT1.5-7B mit 7 Milliarden Parametern. Beide Modelle sind für bidirektionale Übersetzungen in 33 Sprachen ausgelegt und unterstützen zusätzlich fünf ethnische und dialektale Varianten.
HY-MT1.5-7B basiert auf Tencents WMT25-Championship-Modell und ist für erklärende Übersetzungen sowie Szenarien mit gemischten Sprachen optimiert. Zusätzlich unterstützt es Funktionen wie Terminologiekontrolle, kontextbezogene Übersetzung und strukturierte Ausgabeformate.
Obwohl das 1.8B-Modell weniger als ein Drittel der Parameter des 7B-Modells besitzt, erreicht es eine vergleichbare Übersetzungsqualität bei deutlich höherer Geschwindigkeit. Nach einer Quantisierung kann es zudem auf Edge-Geräten für Echtzeitübersetzungen eingesetzt werden, wodurch es flexibel und vielseitig nutzbar ist.
Für diese Demo wird das vollständige 7B-Modell genutzt. Das liegt vor allem an der verfügbaren GPU-Leistung. Das 1.8B-Modell kann jedoch einfach ersetzt werden, indem die Modellreferenz im folgenden Code angepasst wird.
Soprano 1.1 80M
Die letzte Komponente ist das Text-to-Speech-Modell. Soprano ist ein besonders leichtgewichtiges On-Device-TTS-Modell, das für ausdrucksstarke und hochwertige Sprachgenerierung bei sehr hoher Geschwindigkeit entwickelt wurde. Es erreicht bis zu 2000-fache Echtzeitgenerierung auf einer GPU und 20-fache Echtzeitgenerierung auf einer CPU, unterstützt verlustfreies Streaming und arbeitet mit sehr niedriger Latenz von weniger als 15 ms auf der GPU beziehungsweise weniger als 250 ms auf der CPU.
Die kompakte Architektur mit 80 Millionen Parametern benötigt weniger als 1 GB Speicher und unterstützt dank automatischer Textaufteilung die Generierung beliebig langer Inhalte. Dabei erzeugt das Modell klare und ausdrucksstarke Audiodaten mit 32 kHz, die sich für Echtzeit-Sprachanwendungen eignen.
Demo: Echtzeit-Sprachübersetzung
Nachdem die wichtigsten Komponenten der Pipeline vorgestellt wurden, können sie zu einer funktionierenden Anwendung kombiniert werden. Für dieses Projekt ist ein GitHub-Repository verfügbar. Die README-Datei beschreibt, wie die Demo ausgeführt wird. Zu Beginn wird ein GPU-fähiger Server anhand der Anleitung aus dem zugehörigen Setup-Tutorial gestartet. Dadurch kann vom lokalen Terminal aus auf den GPU-Server zugegriffen und die Gradio-Webanwendung anschließend über einen Browser oder eine Vorschaufunktion der Entwicklungsumgebung geöffnet werden.
Fügen Sie anschließend die folgenden Befehle in das Terminalfenster des GPU-Servers ein:
git clone https://github.com/Jameshskelton/realtime_speech_translation
cd realtime_speech_translation
python3 -m venv venv
source venv/bin/activate
pip3 install -r requirements.txt
python3 realtime_speech_translation.py
Damit wird die Webanwendung gestartet. Standardmäßig werden sowohl ein öffentlicher Freigabelink als auch ein lokaler Link erstellt.
Auf der Demo-Seite können Nutzer eine Audiodatei hochladen oder über das Gradio-Audiomodul eine Aufnahme erstellen. Nach dem Hinzufügen der Audiodaten wird über den Run-Button am unteren Rand der Anwendung der Übersetzungsprozess gestartet. Je nach Länge der eingereichten Audiodatei dauert die Verarbeitung weniger als eine Sekunde oder einige Sekunden.
Der vollständige Code sieht folgendermaßen aus:
# -----------------------------
# Imports
# -----------------------------
import os
import torch
import numpy as np
import gradio as gr
from transformers import (
AutoModelForSpeechSeq2Seq,
AutoProcessor,
AutoModelForCausalLM,
AutoTokenizer,
pipeline,
)
from soprano import SopranoTTS
from scipy.io.wavfile import write
from pydub import AudioSegment
# -----------------------------
# Device and dtype configuration
# -----------------------------
device = "cuda:0" if torch.cuda.is_available() else "cpu"
torch_dtype = torch.float16 if torch.cuda.is_available() else torch.float32
# -----------------------------
# Whisper ASR setup
# -----------------------------
model_id = "openai/whisper-large-v3-turbo"
model = AutoModelForSpeechSeq2Seq.from_pretrained(
model_id,
torch_dtype=torch_dtype,
low_cpu_mem_usage=True,
use_safetensors=True,
)
model.to(device)
processor = AutoProcessor.from_pretrained(model_id)
pipe = pipeline(
"automatic-speech-recognition",
model=model,
tokenizer=processor.tokenizer,
feature_extractor=processor.feature_extractor,
torch_dtype=torch_dtype,
device=device,
return_timestamps=True,
chunk_length_s=5.0,
)
# -----------------------------
# Translation model setup
# -----------------------------
model_name_or_path = "tencent/HY-MT1.5-1.8B"
tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)
model_tr = AutoModelForCausalLM.from_pretrained(
model_name_or_path,
device_map="auto",
)
# -----------------------------
# TTS setup
# -----------------------------
model_tts = SopranoTTS()
# -----------------------------
# Audio utilities
# -----------------------------
def convert_to_mono_pydub(input_file, output_file, output_format="wav"):
"""
Converts a stereo or multi-channel audio file to mono using pydub.
"""
audio = AudioSegment.from_file(input_file)
mono_audio = audio.set_channels(1)
mono_audio.export(output_file, format=output_format)
print(f"Converted '{input_file}' to mono file '{output_file}'")
# -----------------------------
# ASR → Translation → TTS pipeline
# -----------------------------
def tts_translate(sample_audio):
output_filename = "out1.wav"
sample_rate, audio_array = sample_audio
write(output_filename, sample_rate, audio_array)
convert_to_mono_pydub("out1.wav", "out1.wav")
result = pipe("out1.wav")
messages = [
{
"role": "user",
"content": (
"Translate the following segment into English, "
"without additional explanation.\n\n"
f"{result['text']}"
),
}
]
tokenized_chat = tokenizer.apply_chat_template(
messages,
tokenize=True,
add_generation_prompt=False,
return_tensors="pt",
)
outputs = model_tr.generate(
tokenized_chat.to(model_tr.device),
max_new_tokens=2048,
)
output_text = tokenizer.decode(outputs[0])
innie = output_text.split("hy_place▁holder▁no▁8｜>")[1]
clean_text = innie.split("<")[0]
model_tts.infer(clean_text, "out.wav")
return "out.wav", clean_text
# -----------------------------
# Gradio UI
# -----------------------------
with gr.Blocks() as demo:
gr.Markdown("# Submit or record your audio for faster-than-speech translation!")
with gr.Column():
inp = gr.Audio(label="Input Audio to be Translated")
with gr.Column():
with gr.Row():
out_audio = gr.Audio(label="Translated Audio")
with gr.Row():
out_text = gr.Textbox(label="Translated Text", lines=8)
btn = gr.Button("Run")
btn.click(fn=tts_translate, inputs=inp, outputs=[out_audio, out_text])
demo.launch(share = True)
Wie oben zu sehen ist, lädt die Anwendung zuerst die benötigten Modelldateien. Anschließend nutzt sie Hilfsfunktionen und eine zentrale Orchestrierungsfunktion, um das eingegebene Audio zu transkribieren, den erzeugten Text ins Englische zu übersetzen und den übersetzten Text per TTS wieder in gesprochene englische Sprache umzuwandeln. Auf einem leistungsstarken GPU-Server mit NVIDIA H200 kann dieser Workflow beispielsweise fünf Sekunden Audio in weniger als einer Sekunde verarbeiten.
Fazit
Dieses Tutorial zeigt, dass Echtzeit-Sprachübersetzung heute durch die Kombination einzelner Deep-Learning-Modelle in einer gemeinsamen Pipeline umgesetzt werden kann. Diese Entwicklung bietet großes Potenzial für zahlreiche Übersetzungsszenarien, etwa in der geschäftlichen Kommunikation und in Unterhaltungsanwendungen. Während sich ASR, TTS und sprachmodellbasierte Übersetzung weiterentwickeln, kann eine solche Pipeline künftig noch leistungsfähiger werden. Ein sinnvoller nächster Schritt ist die Ergänzung des Prozesses um Voice Cloning.
