Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Latenzkontrolle

Lektion 12 von 16 Aktualisiert am 3. November 2026 Entwickler
Auf dieser Seite
  1. Das Kompromiss zwischen Latenz und Genauigkeit
  2. Der Parameter target_streaming_delay_ms
  3. Das Dual-Delay-Muster
  4. Handhabung von On-Screen-Ersetzungen
  5. Auswahl der richtigen Latenz für Ihren Anwendungsfall
  6. Messung der tatsächlich erzielten Latenz
  7. Kernaussagen

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 durch voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 und voxtral-mini-tts-3-0 ersetzt. Wesentliche Änderungen: Zeitstempelung nur auf Segmentebene (word gibt einen 400-Fehler zurück), Echtzeit-Diarisierung ist möglich, Echtzeit-Sitzungseinstellungen werden nach dem ersten Audio-Chunk gesperrt, und context_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

AnwendungsfallEmpfohlene LatenzGrund
Sprachassistent200-300 msNutzer erwartet sofortige Reaktion
Sprachdiktat500-800 msAusgleich zwischen Reaktionsfähigkeit und Genauigkeit
Live-Untertitel800-1.200 msGenauigkeit wichtig, geringe Verzögerung akzeptabel
Konferenz-Transkription1.200 oder 2.400 msMaximale 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_ms steuert 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)