Kontroll av latens
På denna sida
Kursen uppdaterad 3 november 2026 för Voxtral 3, baserat på Mistral:s guide Migrate from Voxtral 2: Voxtral 2-modeller (
voxtral-mini-2602,voxtral-mini-transcribe-realtime-2602,voxtral-mini-tts-2603), avvecklade 31 oktober 2026 och helt borttagna 30 april 2027, ersätts i exemplen medvoxtral-mini-transcribe-3,voxtral-mini-transcribe-realtime-3ochvoxtral-mini-tts-3-0. Viktiga ändringar: tidsstämpling endast per segment (wordreturnerar ett 400-fel), talardifferentiering i realtid är möjlig, inställningar för realtidssession låses efter första ljudklumpen, ochcontext_bias-inmatningar är fritext (fraser med mellanslag). Källor: Migrate from Voxtral 2 · Speech to Text.
Avvägningen mellan latens och noggrannhet
Transkribering i realtid bygger på en avvägning du inte kan undvika: svarshastighet går ut över noggrannheten. Ju längre modellen väntar innan den skickar ut ett ord, desto mer kontext har den för att skilja mellan liknande akustiska hypoteser – och desto längre får din användare vänta. En fras som “he took the sea” kontra “he took the bitter” kanske bara blir tydlig utifrån det som följer; en förhastad modell väljer ibland fel.
Voxtral Realtime döljer inte denna avvägning bakom en automatisk inställning: den lämnar över den till dig explicit via parametern target_streaming_delay_ms. Du bestämmer balanspunkten, fall för fall.
Parametern target_streaming_delay_ms
Detta värde anger i millisekunder målfördröjningen mellan mottaget ljud och utskickad text. Med Voxtral 3 accepteras heltal från 80 till 1 200, eller 2 400; alla andra värden utlöser ett felmeddelande. Du skickar det direkt till strömningsanropet, precis som modell och ljudformat, och liksom alla sessionsinställningar låses det efter första ljudklumpen:
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)
# Låg latens: snabbt svar, mindre noggrant
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ärdeintervall täcker nästan alla användningsfall. Mellan 200 och 300 millisekunder är transkriberingen extremt responsiv: detta är inställningen för röstassistenter där omedelbarhet är viktigast och texten kan innehålla fler korrigeringar. Mellan 500 och 1 000 millisekunder får du en bra balans, lämplig för live-undertextning och diktering. Därutöver, mellan 2 000 och 3 000 millisekunder, arbetar modellen med betydligt mer kontext och producerar avsevärt renare text, till priset av en fördröjning som användaren tydligt märker.
Mönstret Dual Delay
Måste du verkligen välja? Voxtral Realtime erbjuder en lösning: starta två strömmar parallellt på samma ljud, med olika latenser, och vägra därmed avvägningen. Den snabba strömmen, inställd på exempelvis 240 millisekunder, ger omedelbar visuell återkoppling som lugnar användaren och visar att systemet lyssnar. Den långsamma strömmen, inställd på 2 400 millisekunder, producerar en mer noggrann transkribering som gradvis ersätter den preliminära texten.
Du känner igen detta beteende även om du inte gett det ett namn: det är så live-undertexter fungerar på YouTube eller Google Meet, där text dyker upp nästan omedelbart för att sedan korrigeras några ögonblick senare. Implementeringen innebär att du definierar två korutiner som är identiska utom vad gäller fördröjningen, och sedan kör dem tillsammans 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ör två transkriberingar parallellt med olika latenser."""
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)
# Visa omedelbart (ersätts av långsam ström)
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)
# Visa korrigerad version
print(f"\n[ACCURATE] {''.join(results['slow'][-10:])}",
flush=True)
# Kör båda strömmarna parallellt
await asyncio.gather(fast_stream(), slow_stream())
return {
"fast": "".join(results["fast"]),
"slow": "".join(results["slow"])
}
Observera att funktionen tar emot två separata ljudkällor, inte en: en asynkron generator kan bara konsumeras en gång, så du måste duplicera strömmen uppströms för att mata båda transkriberingarna.
Hantering av utbyte på skärmen
I en terminal räcker den dubbla utmatningen från koden ovan för att förstå mekanismen, men ett riktigt gränssnitt måste slå samman de två strömmarna till en enda, läsbar text. Den etablerade konventionen är att visa preliminär text i en subtil nyans – grått – och bekräftad text i vitt, där gränsen mellan dem flyttas framåt allt eftersom den långsamma strömmen ikapp den snabba. Klassen nedan implementerar denna gräns med final_position: allt före den kommer från den långsamma strömmen och ändras inte, allt efter kommer från den snabba strömmen och är fortfarande föremål för korrigering.
class DualLatencyDisplay:
"""Hanterar visning med dubbel latens."""
def __init__(self):
self.fast_text = ""
self.final_text = ""
self.final_position = 0
def on_fast_text(self, text: str):
"""Ny text från den snabba strömmen (preliminär)."""
self.fast_text += text
self._display()
def on_slow_text(self, text: str):
"""Ny text från den långsamma strömmen (final)."""
self.final_text += text
self.final_position = len(self.final_text)
self._display()
def _display(self):
"""Visar final text + snabb text som ännu inte bekräftats."""
provisional_text = self.fast_text[self.final_position:]
display = self.final_text + provisional_text
print(f"\r{display}", end="", flush=True)
Denna komfort har ett pris som det vore oärligt att ignorera: två strömmar innebär två anslutningar och dubbelt så mycket ljudvolym som bearbetas. Använd Dual Delay endast för gränssnitt där användaren läser texten medan den sker; för bakgrundsbearbetning räcker en enda väl avstämd ström mer än väl.
Välja rätt latens för ditt användningsfall
| Användningsfall | Rekommenderad latens | Anledning |
|---|---|---|
| Röstassistent | 200–300 ms | Användaren förväntar sig omedelbar reaktion |
| Röstdiktering | 500–800 ms | Balans mellan responsivitet och noggrannhet |
| Live-undertexter | 800–1 200 ms | Noggrannhet viktigt, liten fördröjning acceptabel |
| Konferenstranskribering | 1 200 eller 2 400 ms | Maximal noggrannhet, fördröjning inte kritisk |
Mätning av faktisk uppnådd latens
Värdet du begär är ett mål, ingen garanti: nätverksavstånd, belastning på tjänsten och storleken på dina klumpar adderar alla till den. Innan du uppger ett tal för dina användare, mät det från den plats där din applikation faktiskt körs. Funktionen nedan tidtar fördröjningen tills det första fragmentet anländer och jämför den med det begärda målet.
import time
async def measure_latency(source_audio, delay_ms):
"""Mäter den faktiska latensen för transkribering."""
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örsta texten efter {latency:.0f} ms "
f"(mål: {delay_ms} ms)")
print(event.text, end="", flush=True)
elif isinstance(event, TranscriptionStreamDone):
break
print(f"\nTotal varaktighet: {time.time() - start:.1f}s")
Kör denna mätning med 240, sedan 800 och slutligen 2 400 millisekunder på samma utdrag, och läs de tre transkriberingarna sida vid sida. Kvalitetsskillnaden mellan den första och den sista kommer att berätta för dig, bättre än någon generell rekommendation, vilken latens din applikation har råd med.
Viktiga punkter
target_streaming_delay_msstyr avvägningen mellan latens och noggrannhet- Låga värden (80 till 300 ms): responsiva men mindre noggranna
- Höga värden (1 200 ms eller 2 400 ms): noggranna men med märkbar fördröjning; endast värden från 80 till 1 200 och 2 400 accepteras
- Mönstret Dual Delay kombinerar två strömmar för både responsivitet OCH noggrannhet
- Den snabba strömmen ger omedelbar återkoppling, den långsamma strömmen korrigerar texten
- Välj latens baserat på ditt användningsfall (röstassistent kontra undertexter)