Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Optimalizace latence

Lekce 13 z 14 Aktualizováno 3. listopadu 2026 Vývojář
Na této stránce
  1. Latence: Nepřítel přirozené konverzace
  2. Anatomie celkové latence
  3. Streamování vs. Dávkové zpracování: Čísla
  4. Tři páky na straně serveru
  5. Dvě páky na straně klienta
  6. Měřte před optimalizací
  7. Klíčové poznatky

Kurz aktualizován 3. listopadu 2026 pro Voxtral TTS 3 na základě průvodce Migrate from Voxtral 2 a stránek Mistralu Text to Speech: voxtral-mini-tts-2603, zastaralý od 31. října 2026 a vyřazený 30. dubna 2027, je v příkladech nahrazen modelem voxtral-mini-tts-3-0. Předdefinované hlasy Voxtral 2 (gb_jane_neutral…) zůstávají podporovány; Voxtral 3 přidává do textu tagy [emotion=…] a [pace=…], nastavení expressiveness, vlastní výslovnost (phoneme_hints) a podporu 35 jazyků. Mistral doporučuje po migraci znovu změřit latenci. Zdroje: Migrate from Voxtral 2 · Speech generation.

Latence: Nepřítel přirozené konverzace

V lidské konverzaci se průměrná doba odezvy pohybuje kolem 200 milisekund. Při překročení 500 ms собеседník vnímá zpoždění; po jedné sekundě předpokládá, že jste ho neslyšeli, a otázku zopakuje. Aby hlasový asistent působil přirozeně, musí čas mezi koncem otázky a začátkem odpovědi zůstat pod jednou sekundou.

Voxtral uvádí latenci modelu přibližně 90 ms, a právě zde mnoho týmů chybuje: toto číslo popisuje pouze jeden článek mnohem delšího řetězce. To, co uživatel zažije, je součtem všech článků. Optimalizace proto vyžaduje znalost nákladů každé komponenty.

Anatomie celkové latence

Cesta začíná odchozí sítí: čas potřebný k doručení vašeho požadavku na servery Mistralu. Závisí na vaší poloze a kvalitě připojení; z Evropy počítejte s 20 až 80 ms. Následuje latence modelu, oněch proslulých 90 ms zpracování před prvním audio fragmentem – jediná část, nad kterou nemáte kontrolu, protože patří infrastruktuře Mistralu.

Dalším krokem je kódování a zde číhají ta nejhorší překvapení. PCM nic nestojí, nebo téměř nic, protože není co kódovat. Opus přidá 5 až 10 ms, což zůstává zanedbatelné. MP3 však vyžaduje 200 až 500 ms: jeho kodek musí nashromáždit dostatek dat, než vyprodukuje první snímek. Jinými slovy, vývojář, který ze zvyku nechá response_format="mp3", přidá více zpoždění sám než celý model dohromady.

Nakonec, zpětná síť váží v režimu streamování málo, protože fragmenty jsou malé. Zbývá vyrovnávací paměť na straně klienta: vaše aplikace obvykle nahromadí dva nebo tři fragmenty před spuštěním přehrávání, aby se vyhnula mikro-výpadkům. Připočítejte 50 až 150 ms – cílené náklady, které kupují plynulost.

Streamování vs. Dávkové zpracování: Čísla

MetrikaDávkové (bez streamování)Streamování PCMStreamování MP3
První zvuk1–3 sekundy~0,7 sekundy~2 sekundy
Vnímaná latenceVysokáVelmi nízkáStřední
Šířka pásmaJediný špičkaRozloženáRozložená

Tyto řády velikosti byly zaznamenány u Voxtral 2. Mistral oznamuje přibližně 90 ms před prvním zvukem pro Voxtral TTS 3 na straně modelu a doporučuje po migraci znovu změřit latenci z vaší aplikace: proveďte tato měření znovu s vaší sítí a vaším formátem.

Přepnutí z dávkového zpracování na streamování PCM sníží vnímanou latenci třikrát až čtyřikrát. Žádná jiná optimalizace v této lekci nebude mít srovnatelný efekt: toto je první věc, kterou musíte změnit, ještě před měřením.

Tři páky na straně serveru

První pákou je formát. Pro jakoukoli konverzační aplikaci je streamování PCM referenčním nastavením a přepnutí proběhne bez přepisování vaší logiky.

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

Druhá páka spočívá ve volbě mezi uloženým hlasem a klonováním za běhu. voice_id označuje hlas již zpracovaný na straně serveru, zatímco ref_audio vynucuje opětovné zpracování vzorku při každém požadavku. Pro agenta odpovídajícího stokrát za hodinu stejným hlasem tento detail ušetří 50 až 100 ms na každou řečovou obrátku.

Třetí pákou je zkrácení toho, co požadujete. Čím kratší text, tím rychleji dorazí první fragment: generování odpovědi o pěti větách v jednom bloku znamená nutit uživatele čekat na obsah, který neuslyší dalších patnáct sekund. Následující generátor rozdělí odpověď po větách a vytvoří audio pro první z nich, zatímco ostatní čekají.

def generate_by_sentence(full_text, voice_id):
    """Generuje audio větu po větě pro minimalizaci latence."""
    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)

Dvě páky na straně klienta

Pevná vyrovnávací paměť je vždy špatně umístěný kompromis: příliš malá propouští mikro-výpadky při zatížené síti; příliš velká přidává zbytečné zpoždění při dobrém připojení. Níže uvedená třída spustí přehrávání, jakmile jsou k dispozici dva fragmenty, a následné nechá projít, jak přicházejí, nikdy nehromadí více než pět.

class AdaptiveBuffer:
    def __init__(self):
        self.buffer = []
        self.min_threshold = 2   # Minimální počet chunků před přehráváním
        self.max_threshold = 5   # Nehromadit více
        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

Druhá páka stojí jen několik řádků: odešlete testovací požadavek při spuštění aplikace. Tím jednou provždy navážete TCP spojení a TLS handshake a HTTP keep-alive umožní všem následným požadavkům těžit z této přípravy. Bez tohoto „zahřátí“ zaplatí cenu váš první uživatel dne.

Měřte před optimalizací

Všechny tyto odhady je třeba ověřit proti vašemu skutečnému nastavení. Minimální měření spočívá v časování zpoždění do přijetí prvního fragmentu a následném ukončení smyčky: právě toto číslo, nikoli celková doba trvání, odpovídá tomu, co uživatel zažije.

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"První chunk přijat za {(t1 - t0)*1000:.0f} ms")
            break

Spusťte toto měření ze svého produkčního serveru, nikoli z pracovní stanice: rozdíl v síti často stačí k vysvětlení propasti mezi přesvědčivým demem a zklamávajícím nasazením.

Klíčové poznatky

  • Celková latence zahrnuje síť, model (~90 ms), kódování a klientskou vyrovnávací paměť
  • Formát PCM nabízí nejnižší latenci, protože nevyžaduje kódování
  • Streamování snižuje vnímanou latenci třikrát až čtyřikrát oproti dávkovému zpracování
  • Použijte voice_id místo ref_audio pro úsporu 50–100 ms
  • Generujte větu po větě pro minimalizaci času do prvního zvuku