Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Kontroll av latens

Lektion 12 av 16 Uppdaterad 3 november 2026 Utvecklare
På denna sida
  1. Avvägningen mellan latens och noggrannhet
  2. Parametern target_streaming_delay_ms
  3. Mönstret Dual Delay
  4. Hantering av utbyte på skärmen
  5. Välja rätt latens för ditt användningsfall
  6. Mätning av faktisk uppnådd latens
  7. Viktiga punkter

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 med voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 och voxtral-mini-tts-3-0. Viktiga ändringar: tidsstämpling endast per segment (word returnerar ett 400-fel), talardifferentiering i realtid är möjlig, inställningar för realtidssession låses efter första ljudklumpen, och context_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ändningsfallRekommenderad latensAnledning
Röstassistent200–300 msAnvändaren förväntar sig omedelbar reaktion
Röstdiktering500–800 msBalans mellan responsivitet och noggrannhet
Live-undertexter800–1 200 msNoggrannhet viktigt, liten fördröjning acceptabel
Konferenstranskribering1 200 eller 2 400 msMaximal 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_ms styr 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)