Optimalisatie van latentie
Op deze pagina
Cursus bijgewerkt op 3 november 2026 voor Voxtral TTS 3, gebaseerd op de gids Migrate from Voxtral 2 en de pagina’s Text to Speech van Mistral:
voxtral-mini-tts-2603, verouderd op 31 oktober 2026 en buiten gebruik gesteld op 30 april 2027, wordt in voorbeelden vervangen doorvoxtral-mini-tts-3-0. Vooraf gedefinieerde stemmen van Voxtral 2 (gb_jane_neutral…) blijven ondersteund; Voxtral 3 voegt tags[emotion=…]en[pace=…]in tekst toe, evenals de instellingexpressiveness, aangepaste uitspraak (phoneme_hints) en 35 talen. Mistral raadt aan de latentie opnieuw te meten na migratie. Bronnen: Migrate from Voxtral 2 · Speech generation.
Latentie: de vijand van een natuurlijk gesprek
Bij menselijke conversatie ligt de gemiddelde reactietijd rond de 200 milliseconden. Bij meer dan 500 ms merkt uw gesprekspartner vertraging op; bij meer dan één seconde denkt deze dat u niets hebt gehoord en herhaalt hij of zij de vraag. Voor een natuurlijk aanvoelende spraakassistent moet de tijd tussen het einde van de vraag en het begin van het antwoord onder de één seconde blijven.
Voxtral adverteert met een modellatentie van ongeveer 90 ms, en hier maken veel teams de fout: dat cijfer beschrijft slechts één schakel in een veel langere keten. Wat de gebruiker ervaart, is de som van alle schakels. Optimalisatie vereist daarom inzicht in de kosten van elke component.
Anatomie van de totale latentie
De reis begint bij het uitgaande netwerk: de tijd die nodig is om uw verzoek naar de servers van Mistral te routeren. Dit hangt af van uw locatie en de kwaliteit van uw verbinding; reken vanuit Europa op 20 tot 80 ms. Daarna volgt de modellatentie, die beroemde 90 ms verwerkingstijd voordat het eerste audiofragment beschikbaar is. Dit is het enige onderdeel waarover u geen controle heeft, omdat het tot de infrastructuur van Mistral behoort.
De volgende stap is codering (encoding), en hier schuilen de vervelendste verrassingen. PCM kost niets, of vrijwel niets, omdat er niets gecodeerd hoeft te worden. Opus voegt 5 tot 10 ms toe, wat verwaarloosbaar blijft. MP3 daarentegen eist 200 tot 500 ms: de codec moet voldoende gegevens verzamelen voordat het eerste frame kan worden geproduceerd. Met andere woorden: een ontwikkelaar die uit gewoonte response_format="mp3" laat staan, voegt meer vertraging toe dan het volledige model zelf.
Tot slot weegt het terugkerende netwerk bij streaming weinig, omdat de fragmenten klein zijn. Wat overblijft, is de buffer aan de clientzijde: uw applicatie verzamelt doorgaans twee of drie fragmenten voordat het afspelen start om micro-onderbrekingen te voorkomen. Tel hier 50 tot 150 ms bij op – een bewuste kostprijs voor soepelheid.
Streaming versus batch: de cijfers
| Metriek | Batch (geen streaming) | Streaming PCM | Streaming MP3 |
|---|---|---|---|
| Eerste geluid | 1-3 seconden | ~0,7 seconde | ~2 seconden |
| Waargenomen latentie | Hoog | Zeer laag | Gemiddeld |
| Bandbreedte | Enkele piek | Gedistribueerd | Gedistribueerd |
Deze ordes van grootte zijn vastgesteld met Voxtral 2. Mistral kondigt ongeveer 90 ms aan voordat het eerste geluid klinkt voor Voxtral TTS 3 aan de modelzijde, en raadt aan de latentie vanuit uw applicatie opnieuw te meten na migratie: voer deze metingen opnieuw uit met uw netwerk en uw indeling.
De overstap van batch naar PCM-streaming verlaagt de waargenomen latentie met een factor drie tot vier. Geen enkele andere optimalisatie in deze les heeft een vergelijkbaar effect: dit is het eerste wat u moet wijzigen, nog vóór het meten.
Drie hefbomen aan serverzijde
De eerste hefboom is de indeling. Voor elke conversationele applicatie is streaming PCM de referentie-instelling, en de omschakeling gebeurt zonder herschrijven van uw logica.
with client.audio.speech.complete(
model="voxtral-mini-tts-3-0",
input=text,
voice_id=voice_id,
response_format="pcm", # Minimum latentie
stream=True,
) as stream:
for event in stream:
if event.event == "speech.audio.delta":
play_audio(base64.b64decode(event.data.audio_data))
De tweede hefboom ligt in de keuze tussen een opgeslagen stem en cloning on-the-fly. Een voice_id duidt op een stem die reeds serverzijde is verwerkt, terwijl ref_audio forceert dat het bij elke aanvraag opnieuw wordt verwerkt. Voor een agent die honderd keer per uur antwoordt met dezelfde stem, bespaart dit detail 50 tot 100 ms per spreekbeurt.
De derde hefboom is het verkorten van uw aanvraag. Hoe korter de tekst, hoe sneller het eerste fragment arriveert: het genereren van een antwoord van vijf zinnen in één blok betekent dat de gebruiker moet wachten op inhoud die hij of zij pas over vijftien seconden hoort. De volgende generator splitst het antwoord per zin en produceert audio voor de eerste zin terwijl de anderen wachten.
def generate_by_sentence(full_text, voice_id):
"""Genereer audio zin voor zin om latentie te minimaliseren."""
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)
Twee hefbomen aan clientzijde
Een vaste buffer is altijd een slecht geplaatst compromis: te klein, en micro-onderbrekingen sluipen erdoorheen op een belast netwerk; te groot, en het voegt onnodige vertraging toe op een goede verbinding. De onderstaande klasse start het afspelen zodra twee fragmenten beschikbaar zijn, laat vervolgens de volgende erdoorheen gaan naarmate ze binnenkomen, en accumuleert nooit meer dan vijf.
class AdaptiveBuffer:
def __init__(self):
self.buffer = []
self.min_threshold = 2 # Minimum chunks voordat afspelen start
self.max_threshold = 5 # Niet meer accumuleren
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
De tweede hefboom kost slechts een paar regels: stuur een testaanvraag wanneer uw applicatie start. Hiermee wordt de TCP-verbinding en TLS-handshake eenmalig tot stand gebracht, en dankzij HTTP keep-alive profiteren alle daaropvolgende aanvragen van deze voorbereiding. Zonder deze ‘warm-up’ betaalt uw eerste gebruiker van de dag de prijs.
Meten voordat u optimaliseert
Al deze schattingen moeten worden gevalideerd tegen uw daadwerkelijke opstelling. De minimale meting bestaat uit het timen van de vertraging tot het eerste fragment is ontvangen, waarna u de lus verlaat: het is dit cijfer, en niet de totale duur, dat overeenkomt met wat de gebruiker ervaart.
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
Voer deze meting uit vanaf uw productieserver, niet vanaf uw werkstation: het netwerkverschil is vaak groot genoeg om de kloof te verklaren tussen een overtuigende demo en een teleurstellende implementatie.
Belangrijkste punten
- Totale latentie omvat netwerk, model (~90 ms), codering en clientbuffer
- PCM-indeling biedt de laagste latentie omdat er geen codering nodig is
- Streaming verlaagt de waargenomen latentie met een factor 3 tot 4 vergeleken met batch
- Gebruik een
voice_idin plaats vanref_audioom 50-100 ms te besparen - Genereer zin voor zin om de tijd tot het eerste geluid te minimaliseren