Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Moill agus Feabhsúchán Fíor-Ama

Ceacht 17 as 18 Nuashonraithe 3 Samhain 2026 Forbróir
Ar an leathanach seo
  1. Moill agus Feabhsúchán Fíor-Ama
  2. Anatamaíocht na Moille
  3. Feabhsúchán ar Bhrath VAD
  4. Feabhsúchán ar Threoracha an Chórais
  5. Laghdú ar Mhoill an Líonra
  6. Feabhsúchán ar Ghlaonna Feidhme
  7. Monatóireacht Moille
  8. Príomhphointí

Nuashonraithe 2 Samhain, 2026 — Múnlaí fuaime. Tá roinnt múnlaí sa chúrsa seo tar éis dul in éag: stopfaidh tts-1, tts-1-hd, agus gpt-4o-mini-tts ar 6 Eanáir, 2027 (an t-ionadaí: gpt-realtime-2.1-mini, a deir treoir TTS OpenAI nach dtacaítear leis le /v1/audio/speech: aistrítear sintéis gutha chuig an API Fíor-Ama); stopfaidh gpt-realtime, gpt-4o-realtime, agus múnlaí fuaime oidhreachta ar 20 Eanáir, 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); stopfaidh whisper-1, gpt-4o-transcribe, agus /v1/audio/translations ar 26 Feabhra, 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Maidir le guth lán-dúbailte, tá GPT-Live 1 ar fáil san API ón 10 Meán Fómhair, 2026.

Ceartaithe 3 Samhain, 2026. Ní raibh foinsí leis na réimsí ama a sannadh do gach céim (“VAD 300-700 ms”, “líonra 20-100 ms”, “múnla 200-800 ms”) ná leis na tairseacha braite (“thar 500 ms”): ní fhoilsíonn OpenAI figiúirí den sórt sin, agus múineann an ceacht seo duit conas iad a thomhas. Baineadh an treoir chun do fhreastalaí a chur “sa réigiún céanna le freastalaithe OpenAI (US East)” de bharr easpa foinsí. Breiseáin dhoiciméadaithe: semantic_vad, WARP chun bunú seisiún WebRTC a luasghéarú. Foinsí: Braith gníomhaíochta gutha · WebRTC le WARP · Feabhsú costais.

Moill agus Feabhsúchán Fíor-Ama

Is é an mhoill an namhaid is measa do ghníomhaire gutha: tá an tost a leanann deireadh ceiste inaitheanta láithreach ar an nguthán nó in aip. Mionsonraíonn an ceacht seo foinseacha na moille, conas iad a thomhas, agus teicnící chun iad a laghdú.

Anatamaíocht na Moille

Is suim roinnt comhpháirteanna í moill iomlán gníomhaire gutha:

VAD
Ag fanacht leis an tost a chríochnaíonn an casadh (`silence_duration_ms`)
Líonra
Turais chuairt idir an t-úsáideoir, do fhreastalaí, agus an API
Múnla
Próiseáil comhthéacs, ansin an chéad smután fuaime

Ag brath ar do ailtireacht, cuir leis na huirlisí a ghlaonn an gníomhaire agus an t-am socraithe seisiúna. Níl aon cheann de na réimsí ama seo seasta: braitheann siad ar do shocruithe, fad an chomhrá, agus conair an líonra. Is é an t-aon bhealach chun a fháil amach cá bhfuil an t-am ag dul ná gach céim a uainiú, mar a dhéanann an monatóir atá curtha i láthair thíos.

Feabhsúchán ar Bhrath VAD

Le server_vad, ní féidir leis an bhfreagairt tosú sula gcríochnaíonn an tost a shainítear le silence_duration_ms: is socruithe díreacha é seo don mhoill a bhraitear, agus caithfear é a chothromú i gcoinne an riosca go gcuirfear isteach ar an úsáideoir. Is pointí tosaigh iad na luachanna thíos le tástáil, ní moltaí ó OpenAI:

# Cumraíocht ionsaitheach (freagairt tapa, riosca an t-úsáideoir a ghearradh)
fast_vad = {
    "type": "server_vad",
    "threshold": 0.6,           # Tairseach níos airde = níos lú dearbh-bhréagach
    "prefix_padding_ms": 200,
    "silence_duration_ms": 400  # Freagairt tapa
}

# Cumraíocht foighneach (níos lú cur isteach, níos mó moille)
patient_vad = {
    "type": "server_vad",
    "threshold": 0.4,
    "prefix_padding_ms": 400,
    "silence_duration_ms": 800
}

# Rogha eile: VAD shéimeantach, a mheasann deireadh abairte bunaithe ar fhocail;
# freagraíonn eagerness "high" chomh luath agus is féidir, ligeann "low" don úsáideoir críochnú
semantic_vad = {"type": "semantic_vad", "eagerness": "high"}

# Cumraíocht oiriúnaitheach bunaithe ar chomhthéacs
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
    }

Feabhsúchán ar Threoracha an Chórais

Laghdaíonn treoracha gonta an comhthéacs le próiseáil. Cuimhnigh freisin go gcuireann an API Fíor-Ama taisce leid i bhfeidhm go huathoibríoch: athúsáidtear treoracha agus uirlisí cobhsaí, a chuirtear ar an mbarr agus nach ndéantar athrú orthu le linn seisiúna, ó chasadh go casadh.

# Treoracha fada (níos mó token le próiseáil)
bad_instructions = """
Is tú cúntóir gutha cliste inniúil ag obair
do Corsen AI, cuideachta Fhrancach atá speisialaithe in
intleacht shaorga. Caithfidh tú freagairt do cheisteanna úsáideoirí
go gairmiúil, go gonta, agus i bhFraincis.
Tá rochtain agat ar uirlisí éagsúla chun coinne a chomhairliú,
infhaighteacht a sheiceáil, agus áirithintí a dhéanamh.
Ná bíodh leisce ort soiléiriú a iarraidh mura bhfuil an t-iarratas soiléir.
"""

# Treoracha optamaithe (an éifeacht chéanna, níos lú token)
good_instructions = """
Cúntóir gutha Corsen AI. Fraincis, gonta, gairmiúil.
Úsáid uirlisí do choinní agus d'áirithintí.
Iarr soiléiriú más gá.
"""

Laghdú ar Mhoill an Líonra

Tomhas ar an Turas Cuairt

Cuir do athsheoladóir WebSocket chomh gar do d’úsáideoirí agus is féidir, agus tomhais an chonair seachas glacadh leis. Is leor imeacht simplí, mar shampla an tascmhéarchlár ionchuir a ghlanadh, chun turas cuairt a uainiú:

import time

async def measure_roundtrip(ws):
    """Tomhaiseann sé moill an líonra chuig an API Fíor-Ama."""
    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  # déan neamhaird d'imeachtaí eile a thagann isteach eatarthu
    roundtrip_ms = (time.monotonic() - start) * 1000
    print(f"Moill líonra: {roundtrip_ms:.0f} ms")
    return roundtrip_ms

Keepalive agus Athcheangal

import asyncio
import websockets

async def robust_connection(api_key: str, max_retries: int = 5):
    """Ceangal láidir le hathcheangal uathoibríoch."""
    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 gach 20s
                ping_timeout=10,       # Teorainn ama ping 10s
                close_timeout=5        # Teorainn ama dúnta 5s
            ) as ws:
                retry_count = 0  # Athshocraigh ar cheangal rathúil
                yield ws

        except websockets.exceptions.ConnectionClosed:
            retry_count += 1
            wait = min(2 ** retry_count, 30)
            print(f"Athcheangal i gceann {wait}s...")
            await asyncio.sleep(wait)

Osclaíonn athcheangal seisiún nua: níl an comhrá roimhe sin ann a thuilleadh, agus mairfidh seisiún 60 nóiméad ar a mhéad ar aon nós. Mar sin, coinnigh do thaifead féin ar mhalartuithe (tras-scríbhinní, torthaí uirlisí) agus athinstill na rudaí riachtanacha le conversation.item.create tar éis athcheangail.

Bunú WebRTC a Luasghéarú: WARP

Ar thaobh an bhrabhsálaí nó na haipe dúchasaí, doiciméadaíonn OpenAI WARP (WebRTC Abridged Roundtrip Protocol), a laghdaíonn am bunaithe seisiúna WebRTC trí thrí fheabhsúchán iompair a chomhcheangal: DTLS 1.3, SPED, agus SNAP. Dréachtaí IETF iad seo, a dtacaítear leo le leaganacha le déanaí de libwebrtc; is féidir leat na cinn a dtacaíonn do chliant leo a chumasú, ceann ar cheann. Mionsonraíonn an treoir WebRTC with WARP an chumraíocht.

Feabhsúchán ar Ghlaonna Feidhme

Cuireann glaonna feidhme moill leis. Déan a n-eisfheidhmiú a optamú:

import asyncio

async def execute_functions_parallel(function_calls: list) -> list:
    """Feidhmíonn sé glaonna feidhme go comhthreomhar."""
    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

# Taisce do fheidhmeanna minic
from functools import lru_cache

@lru_cache(maxsize=100)
def get_cached_data(key: str) -> dict:
    """Taisceann sé torthaí iarratas minic."""
    # Iarratas bunachair sonraí nó API
    return {"data": "..."}

Monatóireacht Moille

Comhtháthaigh córas tomhais chun bacainní a aithint:

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)

Príomhphointí

  • Cuireann moill iomlán VAD, líonra, múnla, agus uirlisí le chéile: tomhais gach céim, ní fhoilsíonn OpenAI réimsí ama tipiciúla
  • Rialaíonn silence_duration_ms go díreach an fanacht roimh fhreagairt; is é semantic_vad agus a eagerness an luamhán eile
  • Laghdaíonn treoracha córais gonta am próiseála an mhúnla
  • Laghdaíonn eisfheidhmiú comhthreomhar glaonna feidhme agus taisce moill an fheidhmchláir
  • Tá córas monatóireachta le TTFA (Time-to-First-Audio) riachtanach le haghaidh feabhsúcháin leanúnaigh