Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Optimering af ventetid

Lektion 13 af 14 Opdateret 3. november 2026 Udvikler
På denne side
  1. Ventetid: Samtalens naturlige fjende
  2. Anatomien af samlet ventetid
  3. Streaming vs. Batch: Tallene
  4. Tre server-side løftestænger
  5. To klient-side løftestænger
  6. Mål før du optimerer
  7. Vigtige pointer

Kurset opdateret 3. november 2026 til Voxtral TTS 3, baseret på guiden Migrate from Voxtral 2 og Mistrals sider om Text to Speech: voxtral-mini-tts-2603, som blev afskrevet 31. oktober 2026 og udfaset 30. april 2027, erstattes i eksemplerne af voxtral-mini-tts-3-0. Voxtral 2’s foruddefinerede stemmer (gb_jane_neutral…) understøttes stadig; Voxtral 3 tilføjer [emotion=…]- og [pace=…]-tags i teksten, indstillingen expressiveness, brugerdefineret udtale (phoneme_hints) og 35 sprog. Mistral anbefaler, at du genmåler ventetiden efter migrationen. Kilder: Migrate from Voxtral 2 · Speech generation.

Ventetid: Samtalens naturlige fjende

I menneskelig samtale ligger den gennemsnitlige svartid omkring 200 millisekunder. Ved over 500 ms opfatter modparten en forsinkelse; ved over ét sekund antager de, at du ikke hørte dem, og gentager deres spørgsmål. For at en stemmeassistent skal føles naturlig, skal tiden mellem slutningen på spørgsmålet og starten på svaret holdes under ét sekund.

Voxtral annoncerer en modelventetid på ca. 90 ms, og her begår mange teams en fejl: dette tal beskriver kun ét led i en meget længere kæde. Det, brugeren oplever, er summen af alle led. Optimering kræver derfor, at du kender omkostningen ved hver enkelt komponent.

Anatomien af samlet ventetid

Rejsen starter med det udgående netværk: den tid, det tager at rute din anmodning til Mistrals servere. Dette afhænger af din placering og forbindelseskvalitet; fra Europa skal du forvente 20 til 80 ms. Dernæst kommer modelventetiden, de berømte 90 ms behandling før det første lydfragment – den eneste del, du ikke har kontrol over, da den tilhører Mistrals infrastruktur.

Næste trin er kodning, og her lurer de værste overraskelser. PCM koster ingenting, eller næsten ingenting, fordi der ikke er noget at kode. Opus tilføjer 5 til 10 ms, hvilket forbliver ubetydeligt. MP3 kræver derimod 200 til 500 ms: codec’en skal akkumulere nok data, før den kan producere den første ramme. Med andre ord: en udvikler, der af vane lader response_format="mp3" stå til, tilføjer mere forsinkelse på egen hånd, end hele modellen gør.

Endelig vejer det returnerende netværk lidt i streaming, da fragmenterne er små. Det, der resterer, er klientens buffer: dit program akkumulerer generelt to eller tre fragmenter, før afspilningen starter, for at undgå mikro-afbrydelser. Læg 50 til 150 ms til – en bevidst omkostning, der køber glidende afspilning.

Streaming vs. Batch: Tallene

MålepunktBatch (ingen streaming)Streaming PCMStreaming MP3
Første lyd1-3 sekunder~0,7 sekunder~2 sekunder
Oplevet ventetidHøjMeget lavMellem
BåndbreddeEnkelt spikeDistribueretDistribueret

Disse størrelsesordener blev registreret med Voxtral 2. Mistral annoncerer ca. 90 ms før den første lyd for Voxtral TTS 3 på modelsiden og anbefaler, at du genmåler ventetiden fra dit program efter migrationen: gentag disse målinger med dit netværk og dit format.

At skifte fra batch til PCM-streaming reducerer den oplevede ventetid med en faktor tre til fire. Ingen anden optimering i denne lektion vil have en tilsvarende effekt: dette er det første, du skal ændre, selv før du måler.

Tre server-side løftestænger

Den første løftestang er formatet. Til enhver samtaleapplikation er streaming PCM referenceindstillingen, og skiftet sker uden at du skal omskrive din logik.

with client.audio.speech.complete(
    model="voxtral-mini-tts-3-0",
    input=text,
    voice_id=voice_id,
    response_format="pcm",  # Minimum ventetid
    stream=True,
) as stream:
    for event in stream:
        if event.event == "speech.audio.delta":
            play_audio(base64.b64decode(event.data.audio_data))

Den anden løftestang ligger i valget mellem en gemt stemme og cloning i øjeblikket. En voice_id betegner en stemme, der allerede er behandlet på serveren, hvorimod ref_audio tvinger systemet til at genbehandle prøven ved hver anmodning. Til en agent, der svarer hundrede gange i timen med samme stemme, sparer denne detalje 50 til 100 ms per taletur.

Den tredje løftestang er at forkorte det, du anmoder om. Jo kortere teksten er, jo hurtigere ankommer det første fragment: at generere et svar på fem sætninger i én blok betyder, at du får brugeren til at vente på indhold, de ikke hører før om femten sekunder. Generatoren nedenfor opdeler svaret sætning for sætning og producerer lyd til den første, mens de andre venter.

def generate_by_sentence(full_text, voice_id):
    """Generér lyd sætning for sætning for at minimere ventetid."""
    sentences = full_text.split(". ")

    for sentence in sentences:
        sentence = sentence.strip()
        if not sentence:
            continue
        if not sentence.endswith("."):
            sentence += "."

        with client.audio.speech.complete(
            model="voxtral-mini-tts-3-0",
            input=sentence,
            voice_id=voice_id,
            response_format="pcm",
            stream=True,
        ) as stream:
            for event in stream:
                if event.event == "speech.audio.delta":
                    yield base64.b64decode(event.data.audio_data)

To klient-side løftestænger

En fast buffer er altid et dårligt placeret kompromis: er den for lille, slipper mikro-afbrydelser igennem på et belastet netværk; er den for stor, tilføjer den unødvendig forsinkelse på en god forbindelse. Klassen nedenfor starter afspilningen, så snart to fragmenter er tilgængelige, og lader derefter de efterfølgende passere, efterhånden som de ankommer, uden nogensinde at akkumulere mere end fem.

class AdaptiveBuffer:
    def __init__(self):
        self.buffer = []
        self.min_threshold = 2   # Minimum chunks før afspilning
        self.max_threshold = 5   # Akkumuler ikke mere
        self.playback_started = False

    def add_chunk(self, chunk):
        self.buffer.append(chunk)

        if not self.playback_started:
            if len(self.buffer) >= self.min_threshold:
                self.playback_started = True
                return self.empty_buffer()
        else:
            return chunk
        return None

    def empty_buffer(self):
        data = b"".join(self.buffer)
        self.buffer = []
        return data

Den anden løftestang koster kun få linjer: send en testanmodning, når dit program starter. Dette etablerer TCP-forbindelsen og TLS-håndtrykket én gang for alle, og HTTP keep-alive lader alle efterfølgende anmodninger drage fordel af dette grundarbejde. Uden denne opvarmning betaler din første bruger på dagen prisen.

Mål før du optimerer

Alle disse estimater skal valideres mod dit faktiske setup. Den minimale måling består i at tage tid på forsinkelsen indtil det første fragment modtages, og derefter afslutte løkken: det er dette tal, ikke den samlede varighed, der svarer til det, brugeren oplever.

import time

t0 = time.perf_counter()

with client.audio.speech.complete(
    model="voxtral-mini-tts-3-0",
    input="Latency test.",
    voice_id=voice_id,
    response_format="pcm",
    stream=True,
) as stream:
    for event in stream:
        if event.event == "speech.audio.delta":
            t1 = time.perf_counter()
            print(f"First chunk received in {(t1 - t0)*1000:.0f} ms")
            break

Kør denne måling fra din produktionsserver, ikke din arbejdsstation: netværksforskellen er ofte nok til at forklare kløften mellem en overbevisende demo og en skuffende implementering.

Vigtige pointer

  • Samlet ventetid inkluderer netværk, model (~90 ms), kodning og klient-buffer
  • PCM-formatet tilbyder den laveste ventetid, fordi der ikke er nogen kodning
  • Streaming reducerer oplevet ventetid med en faktor 3 til 4 sammenlignet med batch
  • Brug en voice_id frem for ref_audio for at spare 50-100 ms
  • Generér sætning for sætning for at minimere tiden til første lyd