Styring af latenstid
På denne side
Kurset opdateret 3. november 2026 til Voxtral 3, baseret på Mistrals guide Migrate from Voxtral 2: Voxtral 2-modellerne (
voxtral-mini-2602,voxtral-mini-transcribe-realtime-2602,voxtral-mini-tts-2603), der blev udfaset 31. oktober 2026 og trukket tilbage 30. april 2027, erstattes i eksemplerne afvoxtral-mini-transcribe-3,voxtral-mini-transcribe-realtime-3ogvoxtral-mini-tts-3-0. Vigtige ændringer: Tidsstempling kun pr. segment (wordreturnerer en 400-fejl), realtids-diarrisering er mulig, indstillinger for realtidssessioner låses efter det første lydchunk, ogcontext_bias-input er frit format (sætninger med mellemrum). Kilder: Migrate from Voxtral 2 · Speech to Text.
Afvejningen mellem latenstid og nøjagtighed
Transskription i realtid hviler på en afvejning, du ikke kan undgå: svarhastighed går på bekostning af nøjagtighed. Jo længere modellen venter, før den udsender et ord, desto mere kontekst har den til at skelne mellem lignende akustiske hypoteser – og desto længere må din bruger vente. En sætning som „he took the sea” kontra „he took the bitter” bliver måske først tydelig ud fra det, der følger; en model, der skynder sig, vil nogle gange vælge forkert.
Voxtral Realtime skjuler ikke denne afvejning bag en automatisk indstilling: den overlader den eksplicit til dig via parameteren target_streaming_delay_ms. Du beslutter balancen fra sag til sag.
Parameteren target_streaming_delay_ms
Denne værdi angiver i millisekunder den målrettede forsinkelse mellem modtagelse af lyd og udsendelse af den tilsvarende tekst. Med Voxtral 3 accepterer den ethvert heltal fra 80 til 1.200 eller 2.400; enhver anden værdi udløser en fejlhændelse. Du sender den direkte til streaming-kaldet, ligesom modellen og lydformatet, og ligesom alle sessionsindstillinger låses den efter det første lydchunk:
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)
# Lav latenstid: Hurtigt svar, mindre nøjagtigt
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)
Tre værdiintervaller dækker næsten alle brugstilfælde. Mellem 200 og 300 millisekunder er transskriptionen ultra-responsiv: dette er indstillingen til taleassistenter, hvor øjeblikkelighed er vigtigst, og teksten kan indeholde flere korrektioner. Mellem 500 og 1.000 millisekunder får du en god balance, der egner sig til live-undertekster og diktering. Derudover, mellem 2.000 og 3.000 millisekunder, arbejder modellen med meget mere kontekst og producerer betydeligt renere tekst, men på bekostning af en forsinkelse, som brugeren tydeligt mærker.
Dual Delay-mønsteret
Skal du virkelig vælge? Voxtral Realtime tilbyder en omvej: start to streams parallelt på samme lyd med forskellig latenstid, og afvis dermed afvejningen. Den hurtige stream, indstillet til f.eks. 240 millisekunder, giver øjeblikkelig visuel feedback, der beroliger brugeren og viser, at systemet lytter. Den langsomme stream, indstillet til 2.400 millisekunder, producerer en mere nøjagtig transskription, der gradvist erstatter den midlertidige tekst.
Du kender denne adfærd, selvom du ikke har givet den et navn: det er sådan, live-undertekster fungerer på YouTube eller Google Meet, hvor tekst vises næsten øjeblikkeligt og derefter korrigerer sig selv få øjeblikke senere. Implementeringen indebærer at definere to coroutiner, der er identiske bortset fra forsinkelsen, og derefter køre dem sammen med 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):
"""Kører to transskriptioner parallelt med forskellig latenstid."""
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)
# Vis straks (vil blive erstattet af langsom stream)
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)
# Vis korrigeret version
print(f"\n[ACCURATE] {''.join(results['slow'][-10:])}",
flush=True)
# Kør begge streams parallelt
await asyncio.gather(fast_stream(), slow_stream())
return {
"fast": "".join(results["fast"]),
"slow": "".join(results["slow"])
}
Bemærk, at funktionen modtager to separate lydkilder, ikke én: en async-generator kan kun forbruges én gang, så du skal duplikere strømmen upstream for at fodre begge transskriptioner.
Håndtering af udskiftning på skærmen
I en terminal er dobbelt-outputtet fra koden ovenfor nok til at forstå mekanismen, men en rigtig grænseflade skal flette de to streams sammen til én enkelt, læsbar tekst. Den etablerede konvention er at vise midlertidig tekst i en subtil nuance – grå – og bekræftet tekst i hvidt, hvor grænsen mellem dem rykker frem, efterhånden som den langsomme stream indhenter den hurtige. Klassen nedenfor implementerer denne grænse med final_position: alt før denne position kommer fra den langsomme stream og ændrer sig ikke, alt efter kommer fra den hurtige stream og er stadig underlagt korrektion.
class DualLatencyDisplay:
"""Administrerer visning med dual latenstid."""
def __init__(self):
self.fast_text = ""
self.final_text = ""
self.final_position = 0
def on_fast_text(self, text: str):
"""Ny tekst fra den hurtige stream (midlertidig)."""
self.fast_text += text
self._display()
def on_slow_text(self, text: str):
"""Ny tekst fra den langsomme stream (endelig)."""
self.final_text += text
self.final_position = len(self.final_text)
self._display()
def _display(self):
"""Viser endelig tekst + hurtig tekst, der endnu ikke er bekræftet."""
provisional_text = self.fast_text[self.final_position:]
display = self.final_text + provisional_text
print(f"\r{display}", end="", flush=True)
Denne komfort har en omkostning, det ville være uærligt at ignorere: to streams betyder to forbindelser og dobbelt så stort lydvolumen, der behandles. Reserver Dual Delay til grænseflader, hvor brugeren læser teksten, mens den sker; til baggrundsbehandling er én enkelt, velindstillet stream mere end rigelig.
Valg af den rigtige latenstid til dit brugstilfælde
| Brugstilfælde | Anbefalet latenstid | Årsag |
|---|---|---|
| Taleassistent | 200-300 ms | Brugeren forventer øjeblikkelig reaktion |
| Talediktering | 500-800 ms | Balance mellem responsivitet og nøjagtighed |
| Live-undertekster | 800-1.200 ms | Nøjagtighed er vigtig, lille forsinkelse acceptabel |
| Konference-transskription | 1.200 eller 2.400 ms | Maksimal nøjagtighed, forsinkelse ikke kritisk |
Måling af den faktiske opnåede latenstid
Den værdi, du anmoder om, er et mål, ikke en garanti: netværksafstand, servicelast og din chunk-størrelse lægger alle til den. Før du citerer et tal over for dine brugere, skal du måle det dér, hvor din applikation faktisk kører. Funktionen nedenfor tidsmåler forsinkelsen, indtil det første fragment ankommer, og sammenligner det med det ønskede mål.
import time
async def measure_latency(source_audio, delay_ms):
"""Måler den effektive latenstid for transskription."""
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"Første tekst efter {latency:.0f} ms "
f"(mål: {delay_ms} ms)")
print(event.text, end="", flush=True)
elif isinstance(event, TranscriptionStreamDone):
break
print(f"\nSamlet varighed: {time.time() - start:.1f}s")
Kør denne måling med 240, derefter 800 og derefter 2.400 millisekunder på samme uddrag, og læs de tre transskriptioner side om side. Kvalitetsforskellen mellem den første og den sidste vil fortælle dig bedre end enhver generel anbefaling, hvilken latenstid din applikation har råd til.
Vigtige pointer
target_streaming_delay_msstyrer afvejningen mellem latenstid og nøjagtighed- Lave værdier (80 til 300 ms): responsiv, men mindre nøjagtig
- Høje værdier (1.200 ms eller 2.400 ms): nøjagtig, men med mærkbar forsinkelse; kun værdier fra 80 til 1.200 og 2.400 accepteres
- Dual Delay-mønsteret kombinerer to streams for både responsivitet OG nøjagtighed
- Den hurtige stream giver øjeblikkelig feedback, den langsomme stream korrigerer teksten
- Vælg latenstid baseret på dit brugstilfælde (taleassistent kontra undertekster)