Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Styring af latenstid

Lektion 12 af 16 Opdateret 3. november 2026 Udvikler
På denne side
  1. Afvejningen mellem latenstid og nøjagtighed
  2. Parameteren target_streaming_delay_ms
  3. Dual Delay-mønsteret
  4. Håndtering af udskiftning på skærmen
  5. Valg af den rigtige latenstid til dit brugstilfælde
  6. Måling af den faktiske opnåede latenstid
  7. Vigtige pointer

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 af voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 og voxtral-mini-tts-3-0. Vigtige ændringer: Tidsstempling kun pr. segment (word returnerer en 400-fejl), realtids-diarrisering er mulig, indstillinger for realtidssessioner låses efter det første lydchunk, og context_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ældeAnbefalet latenstidÅrsag
Taleassistent200-300 msBrugeren forventer øjeblikkelig reaktion
Talediktering500-800 msBalance mellem responsivitet og nøjagtighed
Live-undertekster800-1.200 msNøjagtighed er vigtig, lille forsinkelse acceptabel
Konference-transskription1.200 eller 2.400 msMaksimal 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_ms styrer 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)