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

Il-Latenza u l-Ottimizzazzjoni f'Ħin Reali

Lezzjoni 17 / 18 Aġġornat 3 ta’ Novembru 2026 Zviluppatur
F'din il-paġna
  1. Il-Latenza u l-Ottimizzazzjoni f’Ħin Reali
  2. L-Anatomija tal-Latenza
  3. Ottimizzazzjoni tad-Detezzjoni VAD
  4. Ottimizzazzjoni tal-Istruzzjonijiet tas-Sistema
  5. Tnaqqis tal-Latenza tan-Network
  6. Ottimizzazzjoni tas-Sejħa tal-Funzjonijiet
  7. Monitoraġġ tal-Latenza
  8. Punti Ewlenin

Aġġornat fit-2 ta’ Novembru, 2026 — Mudelli tal-awdjo. Diversi mudelli f’dan il-kors huma skaduti: tts-1, tts-1-hd, u gpt-4o-mini-tts se jieqfu jaħdmu fis-6 ta’ Jannar, 2027 (is-suċċessur: gpt-realtime-2.1-mini, li l-gwida tat-TTS ta’ OpenAI tiddikjara li mhix appoġġjata minn /v1/audio/speech: il-migrazzjoni tas-sinteżi tal-vuċi qed timxi lejn l-API f’Ħin Reali); gpt-realtime, gpt-4o-realtime, u mudelli tal-awdjo antiki fit-20 ta’ Jannar, 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe, u /v1/audio/translations fis-26 ta’ Frar, 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Għall-vuċi full-duplex, GPT-Live 1 kien disponibbli fl-API mill-10 ta’ Settembru, 2026.

Imkorreġut fit-3 ta’ Novembru, 2026. Id-durati assenjati għal kull pass (“VAD 300-700 ms”, “network 20-100 ms”, “model 200-800 ms”) u l-limiti tal-perċezzjoni (“lil hinn minn 500 ms”) ma kellhomx sorsi: OpenAI ma tippubblikax ċifri bħal dawn, u l-lezzjoni issa tgħallmek kif tkejjilhom. L-istruzzjoni biex tpoġġi s-server tiegħek “fl-istess reġjun tas-servers ta’ OpenAI (US East)” tneħħiet minħabba nuqqas ta’ sorsi. Żidiet iddokumentati: semantic_vad, WARP biex taċċellera l-istabbiliment tas-sessjoni WebRTC. Sorsi: Detezzjoni tal-attività tal-vuċi · WebRTC ma’ WARP · Ottimizzazzjoni tal-ispejjeż.

Il-Latenza u l-Ottimizzazzjoni f’Ħin Reali

Il-latenza hija l-għadu numru wieħed ta’ aġent tal-vuċi: is-skiet wara t-tmiem ta’ mistoqsija jinnota immedjatament fuq it-telefon jew f’applikazzjoni. Din il-lezzjoni tiddettalja s-sorsi tal-latenza, kif tkejjilha, u t-tekniki biex tnaqqasha.

L-Anatomija tal-Latenza

Il-latenza totali ta’ aġent tal-vuċi hija s-somma ta’ diversi komponenti:

VAD
Stennija għas-skiet li jtemm id-dawra (`silence_duration_ms`)
Network
Vjaġġi 'l quddiem u lura bejn l-utent, is-server tiegħek, u l-API
Mudell
Ipproċessar tal-kuntest, imbagħad l-ewwel biċċa awdjo

Skont l-arkitettura tiegħek, żid l-għodod li l-aġent isejjaħ u l-ħin tal-issettjar tas-sessjoni. L-ebda waħda minn dawn id-durati mhija fissa: jiddependu fuq il-konfigurazzjonijiet tiegħek, it-tul tal-konversazzjoni, u l-mogħdija tan-network. L-uniku mod biex tkun fejn qed imur il-ħin huwa li tkejjel kull pass, kif jagħmel il-monitor ippreżentat hawn taħt.

Ottimizzazzjoni tad-Detezzjoni VAD

Ma’ server_vad, ir-risposta ma tistax tibda qabel ma jintemm is-skiet definit minn silence_duration_ms: għalhekk din hija konfigurazzjoni diretta għall-latenza perċepita, li trid tiġi bbilanċjata kontra r-riskju li taqta’ lill-utent. Il-valuri hawn taħt huma punti tat-tluq biex tittestjahom, mhux rakkomandazzjonijiet ta’ OpenAI:

# Konfigurazzjoni aggressiva (risposta mgħaġġla, riskju li taqta' lill-utent)
fast_vad = {
    "type": "server_vad",
    "threshold": 0.6,           # Limitu ogħla = inqas pożittivi foloz
    "prefix_padding_ms": 200,
    "silence_duration_ms": 400  # Reazzjoni mgħaġġla
}

# Konfigurazzjoni paċjenti (inqas interruzzjonijiet, aktar latenza)
patient_vad = {
    "type": "server_vad",
    "threshold": 0.4,
    "prefix_padding_ms": 400,
    "silence_duration_ms": 800
}

# Alternattiva: VAD semantiku, li jivvaluta t-tmiem tas-sentenza abbażi tal-kliem;
# eagerness "high" iwieġeb malajr kemm jista' jkun, "low" iħalli lill-utent jispiċċa
semantic_vad = {"type": "semantic_vad", "eagerness": "high"}

# Konfigurazzjoni adattiva bbażata fuq il-kuntest
def get_vad_config(context: str) -> dict:
    configs = {
        "menu_ivr": {"threshold": 0.6, "silence_duration_ms": 400},
        "conversation": {"threshold": 0.5, "silence_duration_ms": 600},
        "dictation": {"threshold": 0.3, "silence_duration_ms": 1200},
    }
    config = configs.get(context, configs["conversation"])
    return {
        "type": "server_vad",
        "prefix_padding_ms": 300,
        **config
    }

Ottimizzazzjoni tal-Istruzzjonijiet tas-Sistema

Istruzzjonijiet konċiżi jnaqqsu l-kuntest li għandu jiġi pproċessat. Ftakar ukoll li l-API f’Ħin Reali tapplika l-caching tal-prompt awtomatikament: istruzzjonijiet u għodod stabbli, imqiegħda fil-quċċata u qatt mhux modifikati matul sessjoni, jiġu riutilizzati minn dawra għal oħra.

# Istruzzjonijiet verbużi (aktar tokens biex jiġu pproċessati)
bad_instructions = """
Int assistent tal-vuċi intelliġenti u kompetenti li taħdem
għal Corsen AI, kumpanija Franċiża speċjalizzata fl-
intelliġenza artifiċjali. Trid twieġeb mistoqsijiet tal-utent
b'mod professjonali, konċiż, u bil-Franċiż.
Għandek aċċess għal għodod varji biex tikkonsulta appuntamenti,
tiċċekkja d-disponibbiltà, u tagħmel riservazzjonijiet.
Tistenniex titlob kjarifika jekk it-talba mhix ċara.
"""

# Istruzzjonijiet ottimizzati (l-istess effett, inqas tokens)
good_instructions = """
Assistent tal-vuċi ta' Corsen AI. Franċiż, konċiż, professjonali.
Uża għodod għal appuntamenti u riservazzjonijiet.
Itlob kjarifika jekk ikun meħtieġ.
"""

Tnaqqis tal-Latenza tan-Network

Kejl tal-Vjaġġ ‘l Quddiem u lura (Round Trip)

Poġġi r-relay WebSocket tiegħek kemm jista’ jkun qrib l-utenti tiegħek u kejjel il-mogħdija minflok ma tassumiha. Avveniment sempliċi, bħat-tindif tal-buffer tal-input, huwa biżżejjed biex tkejjel vjaġġ ‘l quddiem u lura:

import time

async def measure_roundtrip(ws):
    """Ikejjel il-latenza tan-network lejn l-API f'Ħin Reali."""
    start = time.monotonic()
    await ws.send(json.dumps({"type": "input_audio_buffer.clear"}))
    while json.loads(await ws.recv())["type"] != "input_audio_buffer.cleared":
        pass  # injora avvenimenti oħra li jaslu f'dan il-ħin
    roundtrip_ms = (time.monotonic() - start) * 1000
    print(f"Latenza tan-network: {roundtrip_ms:.0f} ms")
    return roundtrip_ms

Keepalive u Konnessjoni mill-Ġdid

import asyncio
import websockets

async def robust_connection(api_key: str, max_retries: int = 5):
    """Konnessjoni robusta b'konnessjoni mill-ġdid awtomatika."""
    retry_count = 0

    while retry_count < max_retries:
        try:
            async with websockets.connect(
                REALTIME_URL,
                additional_headers={
                    "Authorization": f"Bearer {api_key}"
                },
                ping_interval=20,     # Ping kull 20s
                ping_timeout=10,       # Timeout tal-Ping 10s
                close_timeout=5        # Timeout tal-Għeluq 5s
            ) as ws:
                retry_count = 0  # Irriżetta fuq konnessjoni b'suċċess
                yield ws

        except websockets.exceptions.ConnectionClosed:
            retry_count += 1
            wait = min(2 ** retry_count, 30)
            print(f"Qed terġa' tikkonnettja fi {wait}s...")
            await asyncio.sleep(wait)

Konnessjoni mill-ġdid tiftaħ sessjoni ġdida: il-konversazzjoni preċedenti ma tibqax hemm, u sessjoni ddum 60 minuta biss xorta waħda. Għalhekk żomm ir-rekord tiegħek stess ta’ skambji (traskrizzjonijiet, riżultati tal-għodod) u erġa’ daħħal l-essenzjali b’conversation.item.create wara konnessjoni mill-ġdid.

Aċċellerazzjoni tal-Setup WebRTC: WARP

Fuq in-naħa tal-browser jew tal-app nativa, OpenAI tiddokumenta WARP (WebRTC Abridged Roundtrip Protocol), li jnaqqas il-ħin tal-istabbiliment tas-sessjoni WebRTC billi jgħaqqad tliet ottimizzazzjonijiet tat-trasport: DTLS 1.3, SPED, u SNAP. Dawn huma abbozzi tal-IETF, appoġġjati minn verżjonijiet riċenti ta’ libwebrtc; tista’ tattivaha dawk li l-klijent tiegħek jappoġġja, wieħed wieħed. Il-gwida WebRTC with WARP tiddettalja l-konfigurazzjoni.

Ottimizzazzjoni tas-Sejħa tal-Funzjonijiet

Is-sejħiet tal-funzjonijiet iżidu l-latenza. Ottimizza l-eżekuzzjoni tagħhom:

import asyncio

async def execute_functions_parallel(function_calls: list) -> list:
    """Jeżegwixxi sejħiet tal-funzjonijiet b'mod parallel."""
    tasks = []
    for call in function_calls:
        task = execute_single_function(call["name"], call["arguments"])
        tasks.append(task)

    results = await asyncio.gather(*tasks, return_exceptions=True)
    return results

# Cache għal funzjonijiet frekwenti
from functools import lru_cache

@lru_cache(maxsize=100)
def get_cached_data(key: str) -> dict:
    """Jikkaxxja r-riżultati ta' talbiet frekwenti."""
    # Mistoqsija tad-database jew tal-API
    return {"data": "..."}

Monitoraġġ tal-Latenza

Integra sistema ta’ kejl biex tidentifika l-ostakli:

import time
from dataclasses import dataclass, field

@dataclass
class LatencyMetrics:
    speech_end_time: float = 0
    response_start_time: float = 0
    first_audio_time: float = 0
    response_complete_time: float = 0
    function_call_times: list = field(default_factory=list)

    @property
    def time_to_first_audio(self) -> float:
        if self.speech_end_time and self.first_audio_time:
            return (self.first_audio_time - self.speech_end_time) * 1000
        return 0

    @property
    def total_response_time(self) -> float:
        if self.speech_end_time and self.response_complete_time:
            return (self.response_complete_time - self.speech_end_time) * 1000
        return 0

    def report(self) -> dict:
        return {
            "ttfa_ms": round(self.time_to_first_audio),
            "total_ms": round(self.total_response_time),
            "function_calls_ms": [round(t * 1000) for t in self.function_call_times]
        }

class LatencyTracker:
    def __init__(self):
        self.current = LatencyMetrics()
        self.history = []

    def on_event(self, event_type: str):
        now = time.time()

        if event_type == "input_audio_buffer.speech_stopped":
            self.current.speech_end_time = now

        elif event_type == "response.output_audio.delta":
            if not self.current.first_audio_time:
                self.current.first_audio_time = now

        elif event_type == "response.done":
            self.current.response_complete_time = now
            self.history.append(self.current.report())
            self.current = LatencyMetrics()

    def average_ttfa(self) -> float:
        if not self.history:
            return 0
        return sum(h["ttfa_ms"] for h in self.history) / len(self.history)

Punti Ewlenin

  • Il-latenza totali żżid VAD, network, mudell, u għodod: kejjel kull pass, OpenAI ma tippubblikax durati tipiċi
  • silence_duration_ms jikkontrolla direttament l-istennija qabel ir-risposta; semantic_vad u l-eagerness tiegħu huma l-lever l-ieħor
  • Istruzzjonijiet konċiżi tas-sistema jnaqqsu l-ħin tal-ipproċessar tal-mudell
  • L-eżekuzzjoni parallela tas-sejħiet tal-funzjonijiet u l-caching inaqqsu l-latenza tal-applikazzjoni
  • Sistema ta’ monitoraġġ b’TTFA (Time-to-First-Audio) hija essenzjali għall-ottimizzazzjoni kontinwa