Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Kontroll tal-Latenza

Lezzjoni 12 / 16 Aġġornat 3 ta’ Novembru 2026 Zviluppatur
F'din il-paġna
  1. Il-kompromess bejn il-latenza u l-preċiżjoni
  2. Il-parametru target_streaming_delay_ms
  3. Il-mudell Dual Delay
  4. Immaniġġjar tas-sostituzzjoni fuq l-iskrin
  5. Għażla tal-latenza t-tajba għall-każ ta’ użu tiegħek
  6. Kejl tal-latenza attwali miksuba
  7. Punti Ewlenin

Kors aġġornat fit-3 ta’ Novembru, 2026 għal Voxtral 3, ibbażat fuq il-gwida Migrate from Voxtral 2 ta’ Mistral: Il-mudelli Voxtral 2 (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603, skaduti fil-31 ta’ Ottubru, 2026 u rtirati fit-30 ta’ April, 2027, huma sostitwiti fl-eżempji minn voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3, u voxtral-mini-tts-3-0. Bidliet ewlenin: it-timbrar tal-ħin isir biss skont is-segment (word jirritorna żball 400), id-dijarizzazzjoni f’ħin reali hija possibbli, is-settings tas-sessjoni f’ħin reali jingħalqu wara l-ewwel biċċa awdjo, u l-inputs ta’ context_bias huma f’forma libera (frażijiet b’spazji). Sorsi: Migrate from Voxtral 2 · Speech to Text.

Il-kompromess bejn il-latenza u l-preċiżjoni

It-traskrizzjoni f’ħin reali tiddependi fuq kompromess li ma tistax tevita: il-veloċità tar-risposta tiġi bi prezz ta’ preċiżjoni. It-tul ta’ żmien li l-mudell jistenna qabel ma jemetti kelma, iktar kuntest ikollu biex jiddistingwi bejn ipoteżijiet akustiċi simili—u it-tul ta’ żmien li l-utent tiegħek jistenna. Frażi bħal “he took the sea” kontra “he took the bitter” tista’ ssir ċara biss minn dak li jmiss; mudell imħaffef xi kultant jagħżel dik ħażina.

Voxtral Realtime ma taħbix dan il-kompromess wara setting awtomatiku: jagħtiholek b’mod espliċitu permezz tal-parametru target_streaming_delay_ms. Inti tiddeċiedi l-punt ta’ bilanċ, każ b’każ.

Il-parametru target_streaming_delay_ms

Dan il-valur jesprimi f’millisekondi d-dewmien fil-mira bejn ir-riċeviment tal-awdjo u l-emissjoni tat-test korrispondenti. Ma’ Voxtral 3, jaċċetta kwalunkwe numru sħiħ minn 80 sa 1,200, jew 2,400; kwalunkwe valur ieħor jipprovoka avveniment ta’ żball. tgħaddih direttament għas-sejħa tat-trażmissjoni (streaming), eżattament bħall-mudell u l-format tal-awdjo, u bħas-settings kollha tas-sessjoni, jingħalaq wara l-ewwel biċċa awdjo:

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)

# Latenza baxxa: rispons mgħaġġel, inqas preċiż
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)

Tliet firxiet ta’ valuri jkopru kważi l-każijiet kollha ta’ użu. Bejn 200 u 300 millisekonda, it-traskrizzjoni hija ultra-reattiva: dan huwa s-setting għall-assistenti vokali, fejn l-immedjatezza hija l-aktar importanti u t-test jista’ jkun fih aktar korrezzjonijiet. Bejn 500 u 1,000 millisekonda, tikseb bilanċ tajjeb, adattat għas-sottotitoli f’dirett u d-dettatura. Lil hinn minn hekk, bejn 2,000 u 3,000 millisekonda, il-mudell jaħdem b’ħafna aktar kuntest u jipproduċi test ferm aktar nadif, bi prezz ta’ dewmien li l-utent jinduna bih b’mod ċar.

Il-mudell Dual Delay

Verament trid tagħżel? Voxtral Realtime joffri soluzzjoni alternattiva: neddi żewġ flussi (streams) paralleli fuq l-istess awdjo, b’latenzi differenti, u b’hekk tirrifjuta l-kompromess. Il-fluss mgħaġġel, issettjat pereżempju għal 240 millisekonda, jagħti feedback viżiv immedjat li jisserraħ lill-utent u juri li s-sistema qed tisma’. Il-fluss bil-mod, issettjat għal 2,400 millisekonda, jipproduċi traskrizzjoni aktar preċiża li gradwalment tissostitwixxi t-test provviżorju.

Taf dan l-imġiba anke jekk ma smajtx isimha: hekk jaħdmu s-sottotitoli f’dirett fuq YouTube jew Google Meet, fejn it-test jidher kważi immedjatament imbagħad jikkoreġi ruħu ftit mumenti wara. L-implimentazzjoni tinvolvi d-definizzjoni ta’ żewġ koroutini identiċi ħlief għad-dewmien, imbagħad it-tħaddim tagħhom flimkien b’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):
    """Itħaddem żewġ traskrizzjonijiet paralleli b'latenzi differenti."""
    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)
                # Uri immedjatament (se jiġi sostitwit mill-fluss bil-mod)
                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)
                # Uri l-verżjoni kkoreġuta
                print(f"\n[ACCURATE] {''.join(results['slow'][-10:])}",
                      flush=True)

    # Ħaddem iż-żewġ flussi paralleli
    await asyncio.gather(fast_stream(), slow_stream())

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

Innota li l-funzjoni tirċievi żewġ sorsi tal-awdjo separati, mhux wieħed: ġeneratur asinkronu (async generator) jista’ jiġi kkunsmat darba biss, allura trid tidduplika l-fluss ‘il fuq biex titma’ ż-żewġ traskrizzjonijiet.

Immaniġġjar tas-sostituzzjoni fuq l-iskrin

F’terminal, id-doppju output mill-kodiċi hawn fuq huwa biżżejjed biex tifhem il-mekkaniżmu, iżda interfaċċa reali trid tgħaqqad iż-żewġ flussi f’test wieħed li jinqara. Il-konvenzjoni stabbilita hija li turi t-test provviżorju f’dell sottili—griż—u t-test ikkonfermat abjad, bil-fruntiera bejniethom timxi ‘l quddiem hekk kif il-fluss bil-mod jaqbad mal-fluss mgħaġġel. Il-klassi hawn taħt timplimenta din il-fruntiera b’final_position: kollox qabelha ġej mill-fluss bil-mod u mhux se jinbidel, kollox wara ġej mill-fluss mgħaġġel u jibqa’ soġġett għal korrezzjoni.

class DualLatencyDisplay:
    """Timmaniġġja d-display b'latenza doppja."""

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

    def on_fast_text(self, text: str):
        """Test ġdid mill-fluss mgħaġġel (provviżorju)."""
        self.fast_text += text
        self._display()

    def on_slow_text(self, text: str):
        """Test ġdid mill-fluss bil-mod (finali)."""
        self.final_text += text
        self.final_position = len(self.final_text)
        self._display()

    def _display(self):
        """Juri t-test finali + it-test mgħaġġel li għadu ma ġiex ikkonfermat."""
        provisional_text = self.fast_text[self.final_position:]
        display = self.final_text + provisional_text
        print(f"\r{display}", end="", flush=True)

Dan il-kumfort għandu prezz li ma jkunx onest li tinjora: żewġ flussi jfissru żewġ konnessjonijiet u d-doppju tal-volum tal-awdjo pproċessat. Irriżerva d-Dual Delay għal interfaċċi fejn l-utent jaqra t-test hekk kif iseħħ; għall-ipproċessar fl-isfond, fluss wieħed imwaqqaf sew huwa aktar minn biżżejjed.

Għażla tal-latenza t-tajba għall-każ ta’ użu tiegħek

Każ ta’ użuLatenza rrakkomandataRaġuni
Assistent vokali200-300 msL-utent jistenna reazzjoni immedjata
Dettatura vokali500-800 msBilanċ bejn ir-reattività u l-preċiżjoni
Sottotitoli f’dirett800-1,200 msIl-preċiżjoni hija importanti, dewmien żgħir aċċettabbli
Traskrizzjoni ta’ konferenzi1,200 jew 2,400 msPreċiżjoni massima, id-dewmien mhuwiex kritiku

Kejl tal-latenza attwali miksuba

Il-valur li titlob huwa mira, mhux garanzija: id-distanza tan-netwerk, it-tagħbija tas-servizz, u d-daqs tal-biċċiet (chunks) tiegħek kollha jżidu miegħu. Qabel ma tiċċita numru lill-utenti tiegħek, kejjlu minn fejn l-applikazzjoni tiegħek se taħdem fil-fatt. Il-funzjoni hawn taħt tkejjel id-dewmien sakemm jasla l-ewwel framment u tqabblu mal-mira mitluba.

import time

async def measure_latency(source_audio, delay_ms):
    """Tkejjel il-latenza effettiva tat-traskrizzjoni."""
    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"First text after {latency:.0f} ms "
                      f"(target: {delay_ms} ms)")
            print(event.text, end="", flush=True)
        elif isinstance(event, TranscriptionStreamDone):
            break

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

Ħaddem dan il-kejl b’240, imbagħad 800, imbagħad 2,400 millisekonda fuq l-istess estratt, u aqra t-tliet traskrizzjonijiet ħdejn xulxin. Id-differenza fil-kwalità bejn l-ewwel u l-aħħar tgħidlek, aħjar minn kwalunkwe rakkomandazzjoni ġenerali, liema latenza l-applikazzjoni tiegħek tista’ taffordja.

Punti Ewlenin

  • target_streaming_delay_ms jikkontrolla l-kompromess bejn il-latenza u l-preċiżjoni
  • Valuri baxxi (80 sa 300 ms): reattivi iżda inqas preċiżi
  • Valuri għoljin (1,200 ms, jew 2,400 ms): preċiżi iżda b’dewmien perċettibbli; biss valuri minn 80 sa 1,200 u 2,400 huma aċċettati
  • Il-mudell Dual Delay jgħaqqad żewġ flussi għar-reattività U l-preċiżjoni flimkien
  • Il-fluss mgħaġġel jagħti feedback immedjat, il-fluss bil-mod jikkoreġi t-test
  • Agħżel il-latenza abbażi tal-każ ta’ użu tiegħek (assistent vokali vs sottotitoli)