Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Latenssin hallinta

Oppitunti 12 / 16 Päivitetty 3. marraskuuta 2026 Kehittäjä
Tällä sivulla
  1. Latenssin ja tarkkuuden välinen kompromissi
  2. Parametri target_streaming_delay_ms
  3. Dual Delay -malli
  4. Näytöllä tapahtuvan korvaamisen käsittely
  5. Oikean latenssin valinta käyttötapaukseesi
  6. Todellisen saavutetun latenssin mittaaminen
  7. Keskeiset asiat

Kurssi päivitetty 3. marraskuuta 2026 Voxtral 3:ta varten Mistralin Migrate from Voxtral 2 -oppaan pohjalta: Voxtral 2 -mallit (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603) poistettiin käytöstä 31. lokakuuta 2026 ja ne lopetetaan kokonaan 30. huhtikuuta 2027. Esimerkeissä ne on korvattu malleilla voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 ja voxtral-mini-tts-3-0. Keskeiset muutokset: aikaleimat vain segmenttitasolla (word palauttaa 400-virheen), reaaliaikainen puhujanerottelu on mahdollista, reaaliaikaisten istuntojen asetukset lukittuvat ensimmäisen äänipaketin jälkeen, ja context_bias-syötteet ovat vapaamuotoisia (välilyönnillä erotettuja fraaseja). Lähteet: Migrate from Voxtral 2 · Speech to Text.

Latenssin ja tarkkuuden välinen kompromissi

Reaaliaikainen litterointi perustuu väistämättömään kompromissiin: vasteen nopeus vaatii tarkkuudesta tinkimistä. Mitä kauemmin malli odottaa ennen sanan tuottamista, sitä enemmän kontekstia sillä on erottaa toisistaan samankaltaiset akustiset hypoteesit – ja sitä kauemmin käyttäjäsi joutuu odottamaan. Fraasi kuten “he took the sea” versus “he took the bitter” saattaa selvitä vasta seuraavien sanojen perusteella; liian kiireinen malli valitsee joskus väärän vaihtoehdon.

Voxtral Realtime ei piilota tätä kompromissia automaattisen asetuksen taakse, vaan antaa sen suoraan haltuusi parametrin target_streaming_delay_ms kautta. Sinä päätät tasapainopisteen tapauskohtaisesti.

Parametri target_streaming_delay_ms

Tämä arvo ilmaisee millisekunteina tavoiteviiveen äänen vastaanottamisen ja vastaavan tekstin tuottamisen välillä. Voxtral 3:ssa se hyväksyy minkä tahansa kokonaisluvun väliltä 80–1 200 tai arvon 2 400; mikä tahansa muu arvo laukaisee virhetapahtuman. Välität sen suoraan suoratoistokutsuun aivan kuten mallin ja äänimuodonkin, ja kuten kaikki istuntoasetukset, se lukittuu ensimmäisen äänipaketin jälkeen:

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)

# Matala latenssi: nopea vaste, vähemmän tarkka
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)

Kolme arvoväliä kattaa lähes kaikki käyttötapaukset. Välillä 200–300 millisekuntia litterointi on erittäin reagoiva: tämä asetus sopii ääniavustajiin, joissa välittömyys on tärkeintä ja teksti saattaa sisältää enemmän korjauksia. Välillä 500–1 000 millisekuntia saat hyvän tasapainon, joka sopii live-tekstitykseen ja saneluun. Tätä pidemmällä viiveellä, 2 000–3 000 millisekunnin välillä, malli työskentelee paljon laajemman kontekstin pohjalta ja tuottaa huomattavasti siistimpää tekstiä, mutta käyttäjä havaitsee viiveen selvästi.

Dual Delay -malli

Onko sinun todella pakko valita? Voxtral Realtime tarjoaa kiertotien: käynnistä kaksi suoratoistoa rinnakkain samalle äänelle eri latensseilla, ja kieltäydy siten kompromissista. Nopea suoratoisto, asetettuna esimerkiksi 240 millisekuntiin, tarjoaa välitöntä visuaalista palautetta, joka rauhoittaa käyttäjää ja osoittaa järjestelmän kuuntelevan. Hidas suoratoisto, asetettuna 2 400 millisekuntiin, tuottaa tarkemman litteroinnin, joka korvaa vähitellen alustavan tekstin.

Tunnet tämän toiminnan, vaikka et olisi antanut sille nimeä: näin live-tekstitys toimii YouTubessa tai Google Meetissä, jossa teksti ilmestyy lähes välittömästi ja korjautuu itseään hetken kuluttua. Toteutus edellyttää kahden korutiinin määrittelyä niin, että ne ovat identtisiä viivettä lukuun ottamatta, ja niiden suorittamista yhdessä komennolla 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):
    """Suorittaa kaksi litterointia rinnakkain eri latensseilla."""
    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)
                # Näytä välittömästi (hidas suoratoisto korvaa tämän)
                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)
                # Näytä korjattu versio
                print(f"\n[ACCURATE] {''.join(results['slow'][-10:])}",
                      flush=True)

    # Suorita molemmat suoratoistot rinnakkain
    await asyncio.gather(fast_stream(), slow_stream())

    return {
        "fast": "".join(results["fast"]),
        "slow": "".join(results["slow"])
    }

Huomaa, että funktio vastaanottaa kaksi erillistä äänilähdettä, ei yhtä: asynkroninen generaattori voidaan kuluttaa vain kerran, joten sinun on duplikoitava suoratoisto ylävirrassa syöttääksesi molemmat litteroinnit.

Näytöllä tapahtuvan korvaamisen käsittely

Päätteessä yllä olevan koodin kaksoistuloste riittää mekanismin ymmärtämiseen, mutta todellinen käyttöliittymä tarvitsee yhdistää kaksi suoratoistoa yhdeksi luettavaksi tekstiksi. Vakiintunut käytäntö on näyttää alustava teksti hillityssä sävyssä – harmaana – ja vahvistettu teksti valkoisena, niin että raja niiden välillä etenee hitaan suoratoiston saavuttaessa nopean. Alla oleva luokka toteuttaa tämän rajan muuttujalla final_position: kaikki sen edellä oleva tulee hitaasta suoratoistosta eikä muutu, kaikki sen jälkeen tuleva tulee nopeasta suoratoistosta ja on edelleen altis korjauksille.

class DualLatencyDisplay:
    """Hallitsee näyttöä kaksoislatenssilla."""

    def __init__(self):
        self.fast_text = ""
        self.final_text = ""
        self.final_position = 0

    def on_fast_text(self, text: str):
        """Uusi teksti nopeasta suoratoistosta (alustava)."""
        self.fast_text += text
        self._display()

    def on_slow_text(self, text: str):
        """Uusi teksti hitaasta suoratoistosta (lopullinen)."""
        self.final_text += text
        self.final_position = len(self.final_text)
        self._display()

    def _display(self):
        """Näyttää lopullisen tekstin plus nopean tekstin, jota ei ole vielä vahvistettu."""
        provisional_text = self.fast_text[self.final_position:]
        display = self.final_text + provisional_text
        print(f"\r{display}", end="", flush=True)

Tällä mukavuudella on hinta, jota olisi epärehellistä ignoroida: kaksi suoratoistoa tarkoittaa kahta yhteyttä ja kaksinkertaista käsitellyn äänen määrää. Varaa Dual Delay -malli käyttöliittymiin, joissa käyttäjä lukee tekstiä sen syntymishetkellä; taustasuoritukseen yksi hyvin viritetty suoratoisto riittää mainiosti.

Oikean latenssin valinta käyttötapaukseesi

KäyttötapausSuositeltu latenssiSyy
Ääniavustaja200–300 msKäyttäjä odottaa välitöntä reaktiota
Äänisanelu500–800 msTasapaino reagointinopeuden ja tarkkuuden välillä
Live-tekstitys800–1 200 msTarkkuus tärkeää, pieni viive hyväksyttävä
Konferenssilitterointi1 200 tai 2 400 msMaksimitarkkuus, viive ei kriittinen

Todellisen saavutetun latenssin mittaaminen

Pyytämäsi arvo on tavoite, ei takuu: verkkoviive, palvelimen kuormitus ja paketin kokosi kaikki lisäävät siihen viivettä. Ennen kuin ilmoitat luvun käyttäjillesi, mittaa se siitä paikasta, jossa sovelluksesi todellisuudessa pyörii. Alla oleva funktio ajoittaa viiveen ensimmäisen fragmentin saapumiseen asti ja vertaa sitä pyydettyyn tavoitteeseen.

import time

async def measure_latency(source_audio, delay_ms):
    """Mittaa litteroinnin todellisen latenssin."""
    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"Ensimmäinen teksti {latency:.0f} ms:n jälkeen "
                      f"(tavoite: {delay_ms} ms)")
            print(event.text, end="", flush=True)
        elif isinstance(event, TranscriptionStreamDone):
            break

    print(f"\nKokonaiskesto: {time.time() - start:.1f}s")

Suorita tämä mittaus arvoilla 240, sitten 800 ja lopuksi 2 400 millisekuntia samalle otteelle, ja vertaa kolmea litterointia vierekkäin. Laatuero ensimmäisen ja viimeisen välillä kertoo sinulle paremmin kuin mikään yleinen suositus, minkä latenssin sovelluksesi voi sallia.

Keskeiset asiat

  • target_streaming_delay_ms ohjaa latenssin ja tarkkuuden välistä kompromissia
  • Matalat arvot (80–300 ms): reagoiva mutta vähemmän tarkka
  • Korkeat arvot (1 200 ms tai 2 400 ms): tarkka mutta havaittavalla viiveellä; vain arvot 80–1 200 ja 2 400 hyväksytään
  • Dual Delay -malli yhdistää kaksi suoratoistoa sekä reagointinopeuden ETTÄ tarkkuuden saavuttamiseksi
  • Nopea suoratoisto antaa välitöntä palautetta, hidas suoratoisto korjaa tekstiä
  • Valitse latenssi käyttötapauksesi perusteella (ääniavustaja vs. tekstitys)