Latenzkontrolle
Auf dieser Seite
Kurs aktualisiert am 3. November 2026 für Voxtral 3, basierend auf Mistrals Leitfaden Migrate from Voxtral 2: Die Voxtral 2-Modelle (
voxtral-mini-2602,voxtral-mini-transcribe-realtime-2602,voxtral-mini-tts-2603), die am 31. Oktober 2026 veraltet und am 30. April 2027 eingestellt wurden, werden in den Beispielen durchvoxtral-mini-transcribe-3,voxtral-mini-transcribe-realtime-3undvoxtral-mini-tts-3-0ersetzt. Wesentliche Änderungen: Zeitstempelung nur auf Segmentebene (wordgibt einen 400-Fehler zurück), Echtzeit-Diarisierung ist möglich, Echtzeit-Sitzungseinstellungen werden nach dem ersten Audio-Chunk gesperrt, undcontext_bias-Eingaben sind frei formatiert (Phrasen mit Leerzeichen). Quellen: Migrate from Voxtral 2 · Speech to Text.
Das Kompromiss zwischen Latenz und Genauigkeit
Echtzeit-Transkription basiert auf einem Kompromiss, den Sie nicht vermeiden können: Die Reaktionsgeschwindigkeit geht zu Lasten der Genauigkeit. Je länger das Modell wartet, bevor es ein Wort ausgibt, desto mehr Kontext hat es, um zwischen ähnlichen akustischen Hypothesen zu unterscheiden – und desto länger wartet Ihr Nutzer. Ein Satz wie „he took the sea” gegenüber „he took the bitter” kann erst durch das Folgende eindeutig werden; ein hastiges Modell wird manchmal die falsche Variante wählen.
Voxtral Realtime versteckt diesen Kompromiss nicht hinter einer automatischen Einstellung: Es stellt ihn Ihnen explizit über den Parameter target_streaming_delay_ms zur Verfügung. Sie entscheiden den Abwägungspunkt von Fall zu Fall.
Der Parameter target_streaming_delay_ms
Dieser Wert gibt in Millisekunden die Zielverzögerung zwischen dem Empfang von Audio und der Ausgabe des entsprechenden Textes an. Mit Voxtral 3 akzeptiert er jede ganze Zahl von 80 bis 1.200 oder 2.400; jeder andere Wert löst ein Fehlerereignis aus. Sie übergeben ihn direkt an den Streaming-Aufruf, genau wie Modell und Audioformat, und wie alle Sitzungseinstellungen wird er nach dem ersten Audio-Chunk gesperrt:
import asyncio
import os
from mistralai.client import Mistral
from mistralai.client.models import (
AudioFormat,
TranscriptionStreamTextDelta,
TranscriptionStreamDone
)
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)
# Niedrige Latenz: schnelle Reaktion, geringere Genauigkeit
async for event in client.audio.realtime.transcribe_stream(
audio_stream=source_audio,
model="voxtral-mini-transcribe-realtime-3",
audio_format=audio_format,
target_streaming_delay_ms=240, # 240 ms
):
if isinstance(event, TranscriptionStreamTextDelta):
print(event.text, end="", flush=True)
Drei Wertebereiche decken fast alle Anwendungsfälle ab. Zwischen 200 und 300 Millisekunden ist die Transkription ultraschnell: Dies ist die Einstellung für Sprachassistenten, bei denen Unmittelbarkeit am wichtigsten ist und der Text möglicherweise mehr Korrekturen enthält. Zwischen 500 und 1.000 Millisekunden erhalten Sie ein gutes Gleichgewicht, das für Live-Untertitelung und Diktieren geeignet ist. Darüber hinaus, zwischen 2.000 und 3.000 Millisekunden, arbeitet das Modell mit deutlich mehr Kontext und erzeugt deutlich saubereren Text, zum Preis einer Verzögerung, die der Nutzer klar wahrnimmt.
Das Dual-Delay-Muster
Müssen Sie wirklich wählen? Voxtral Realtime bietet einen Ausweg: Starten Sie zwei Streams parallel auf demselben Audio mit unterschiedlichen Latenzen und verweigern Sie damit den Kompromiss. Der schnelle Stream, beispielsweise auf 240 Millisekunden eingestellt, liefert sofortiges visuelles Feedback, das den Nutzer beruhigt und zeigt, dass das System zuhört. Der langsame Stream, auf 2.400 Millisekunden eingestellt, erzeugt eine genauere Transkription, die den vorläufigen Text schrittweise ersetzt.
Sie kennen dieses Verhalten auch, wenn Sie es nicht so benannt haben: So funktionieren Live-Untertitel auf YouTube oder Google Meet, wo Text fast sofort erscheint und sich einige Momente später korrigiert. Die Implementierung erfordert das Definieren zweier Koroutinen, die sich nur in der Verzögerung unterscheiden, und das parallele Ausführen mit asyncio.gather.
import asyncio
import os
from mistralai.client import Mistral
from mistralai.client.models import (
AudioFormat,
TranscriptionStreamTextDelta,
TranscriptionStreamDone
)
async def dual_latency_stream(source_audio_fast, source_audio_slow):
"""Führt zwei Transkriptionen parallel mit unterschiedlichen Latenzen aus."""
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)
results = {"fast": [], "slow": []}
async def fast_stream():
async for event in client.audio.realtime.transcribe_stream(
audio_stream=source_audio_fast,
model="voxtral-mini-transcribe-realtime-3",
audio_format=audio_format,
target_streaming_delay_ms=240,
):
if isinstance(event, TranscriptionStreamTextDelta):
results["fast"].append(event.text)
# Sofortige Anzeige (wird vom langsamen Stream ersetzt)
print(f"\r[FAST] {''.join(results['fast'][-10:])}",
end="", flush=True)
async def slow_stream():
async for event in client.audio.realtime.transcribe_stream(
audio_stream=source_audio_slow,
model="voxtral-mini-transcribe-realtime-3",
audio_format=audio_format,
target_streaming_delay_ms=2400,
):
if isinstance(event, TranscriptionStreamTextDelta):
results["slow"].append(event.text)
# Anzeige der korrigierten Version
print(f"\n[ACCURATE] {''.join(results['slow'][-10:])}",
flush=True)
# Beide Streams parallel ausführen
await asyncio.gather(fast_stream(), slow_stream())
return {
"fast": "".join(results["fast"]),
"slow": "".join(results["slow"])
}
Beachten Sie, dass die Funktion zwei getrennte Audioquellen erhält, nicht eine: Ein asynchroner Generator kann nur einmal abgerufen werden, sodass Sie den Stream upstream duplizieren müssen, um beide Transkriptionen zu versorgen.
Handhabung von On-Screen-Ersetzungen
In einem Terminal reicht die doppelte Ausgabe des obigen Codes aus, um den Mechanismus zu verstehen, aber eine echte Schnittstelle muss die beiden Streams zu einem einzigen, lesbaren Text zusammenführen. Die etablierte Konvention besteht darin, vorläufigen Text in einer dezenten Farbe – Grau – und bestätigten Text in Weiß anzuzeigen, wobei die Grenze zwischen beiden voranschreitet, sobald der langsame Stream den schnellen einholt. Die Klasse unten implementiert diese Grenze mit final_position: Alles davor stammt vom langsamen Stream und wird sich nicht ändern, alles danach stammt vom schnellen Stream und bleibt der Korrektur unterworfen.
class DualLatencyDisplay:
"""Verwaltet die Anzeige mit Dual-Latenz."""
def __init__(self):
self.fast_text = ""
self.final_text = ""
self.final_position = 0
def on_fast_text(self, text: str):
"""Neuer Text vom schnellen Stream (vorläufig)."""
self.fast_text += text
self._display()
def on_slow_text(self, text: str):
"""Neuer Text vom langsamen Stream (endgültig)."""
self.final_text += text
self.final_position = len(self.final_text)
self._display()
def _display(self):
"""Zeigt endgültigen Text + noch nicht bestätigten schnellen Text an."""
provisional_text = self.fast_text[self.final_position:]
display = self.final_text + provisional_text
print(f"\r{display}", end="", flush=True)
Dieser Komfort hat einen Preis, den es unehrlich wäre zu ignorieren: Zwei Streams bedeuten zwei Verbindungen und das doppelte Audio-Volumen, das verarbeitet wird. Reservieren Sie Dual Delay für Schnittstellen, bei denen der Nutzer den Text liest, während er entsteht; für Hintergrundverarbeitung reicht ein einziger gut abgestimmter Stream mehr als genug.
Auswahl der richtigen Latenz für Ihren Anwendungsfall
| Anwendungsfall | Empfohlene Latenz | Grund |
|---|---|---|
| Sprachassistent | 200-300 ms | Nutzer erwartet sofortige Reaktion |
| Sprachdiktat | 500-800 ms | Ausgleich zwischen Reaktionsfähigkeit und Genauigkeit |
| Live-Untertitel | 800-1.200 ms | Genauigkeit wichtig, geringe Verzögerung akzeptabel |
| Konferenz-Transkription | 1.200 oder 2.400 ms | Maximale Genauigkeit, Verzögerung nicht kritisch |
Messung der tatsächlich erzielten Latenz
Der von Ihnen angeforderte Wert ist ein Ziel, keine Garantie: Netzwerkdistanz, Service-Last und Ihre Chunk-Größe tragen dazu bei. Bevor Sie eine Zahl Ihren Nutzern nennen, messen Sie sie von dort aus, wo Ihre Anwendung tatsächlich ausgeführt wird. Die Funktion unten misst die Verzögerung bis zum Eintreffen des ersten Fragments und vergleicht sie mit dem angeforderten Ziel.
import time
async def measure_latency(source_audio, delay_ms):
"""Misst die effektive Latenz der Transkription."""
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)
start = time.time()
first_text = None
async for event in client.audio.realtime.transcribe_stream(
audio_stream=source_audio,
model="voxtral-mini-transcribe-realtime-3",
audio_format=audio_format,
target_streaming_delay_ms=delay_ms,
):
if isinstance(event, TranscriptionStreamTextDelta):
if first_text is None:
first_text = time.time()
latency = (first_text - start) * 1000
print(f"Erster Text nach {latency:.0f} ms "
f"(Ziel: {delay_ms} ms)")
print(event.text, end="", flush=True)
elif isinstance(event, TranscriptionStreamDone):
break
print(f"\nGesamtdauer: {time.time() - start:.1f}s")
Führen Sie diese Messung mit 240, dann 800 und schließlich 2.400 Millisekunden am selben Auszug durch und lesen Sie die drei Transkriptionen nebeneinander. Die Qualitätslücke zwischen dem ersten und dem letzten Ergebnis wird Ihnen besser als jede allgemeine Empfehlung sagen, welche Latenz Ihre Anwendung verkraften kann.
Kernaussagen
target_streaming_delay_mssteuert das Kompromissverhältnis zwischen Latenz und Genauigkeit- Niedrige Werte (80 bis 300 ms): reaktionsschnell, aber weniger genau
- Hohe Werte (1.200 ms oder 2.400 ms): genau, aber mit wahrnehmbarer Verzögerung; nur Werte von 80 bis 1.200 und 2.400 werden akzeptiert
- Das Dual-Delay-Muster kombiniert zwei Streams für sowohl Reaktionsfähigkeit als auch Genauigkeit
- Der schnelle Stream liefert sofortiges Feedback, der langsame Stream korrigiert den Text
- Wählen Sie die Latenz basierend auf Ihrem Anwendungsfall (Sprachassistent vs. Untertitelung)