Tomhas agus anailís ar mhoill
Ar an leathanach seo
Cén fáth gur é an mhoill do phríomhthomhas
Nuair a chuireann tú feidhmchlár atá cumhachtaithe ag LLM i mbun oibre, cinneann an mhoill a mhothaíonn do chuid úsáideoirí go díreach cé chomh mór is a bheidh an glacadh leis. Má thógann freagra 8 soicind le teacht amach, tiomáinfidh sé 70% d’úsáideoirí ar shiúl: dúnfaidh siad an cluaisín, déanfaidh siad an t-iarratas arís, nó conclúidfidh siad nach bhfuil an uirlis ag obair. Ní féidir le haon fheabhsúcháin cáilíochta an caillteanas seo a chúiteamh, toisc go dtarlaíonn sé sula léann an t-úsáideoir an freagra fiú.
Is é an dúshlán i mbun oibre ná nach ndiagnóis é “tá sé mall”. D’fhéadfadh an fhad ocht soicind chéanna teacht ó chomhartha córais atá ró-mhór, socruithe réasúnaíochta atá ró-uaillmhianach, freastalaí feidhmchláir atá suite go mícheart, nó iar-phróiseáil a fhanann don fhreagra iomlán sula dtaispeántar aon rud. Éilíonn gach cúis réiteach difriúil, agus má dhéanann tú an ceann mícheart a dheisiú, ní athróidh sé tada. Múinfidh an ceacht seo duit mhoill end-to-end a thomhas, a dhéanamh ina chodanna, agus a dhiagnóisiú ionas gur féidir leat gearán a thiontú ina uimhir inchurtha i bhfeidhm.
Comhpháirteanna na moille
Bristear moill iomlán glaonna API síos ina cheithre chuid ar chóir duit a scaradh óna chéile. Is é moill an líonra an t-am taistil idir do fhreastalaí agus API OpenAI; tá sé dofheicthe i do logaí feidhmchláir ach is féidir leis dul thar 100 milleasoicind má tá do fhreastalaí i bhfad ón bpointe deiridh. Tomhaiseann Am go dtí an Chéad Token (TTFT) an mhoill sula ngintear an chéad token: is é seo an chuid a mhothaíonn úsáideoirí mar “fanacht”, ós rud é go bhfanann an scáileán bán go dtí go gcríochnaíonn sé. Ansin, déanann Am in aghaidh gach Token Aschuir (TPOT) cur síos ar luas na giniúna do gach token ina dhiaidh sin; méadaithe ar fhad na freagra, tugann sé fad scrollaithe an téacs. Ar deireadh, clúdaíonn moill an fheidhmchláir gach rud a dhéanann do fhreastalaí féin roimh agus tar éis an glaonna: doiciméid a fháil, an comhartha a chur le chéile, JSON aschuir a bhailíochtú, agus scríobh chuig an mbunachar sonraí.
Níl an dí-chumasc seo acadúil. Má fhionnann foireann go bhfuil a TTFT ceart go leor ach go gcuireann a moill feidhmchláir dhá shoicind leis, ní athróidh sí samhlacha: scrúdóidh sí a hiarraidh SQL chun comhthéacs a fháil.
Tomhas le Python
Seo conas glao chuig an API Freagraí a ionstraimiú chun gach cuid a ghabháil:
import time
import openai
client = openai.OpenAI()
def measure_latency(prompt: str, model: str = "gpt-5.6-terra") -> dict:
"""Measure decomposed latency of an API call."""
metrics = {}
start_total = time.perf_counter()
# Stream the call to measure TTFT
stream = client.responses.create(
model=model,
input=prompt,
stream=True,
)
first_token = True
output_tokens = 0
for event in stream:
if event.type == "response.output_text.delta":
if first_token:
metrics["ttft"] = time.perf_counter() - start_total
start_generation = time.perf_counter()
first_token = False
output_tokens += 1
metrics["total_duration"] = time.perf_counter() - start_total
metrics["output_tokens"] = output_tokens
if output_tokens > 1:
metrics["tpot"] = (
(metrics["total_duration"] - metrics["ttft"]) / (output_tokens - 1)
)
return metrics
result = measure_latency("Explain Bayes' theorem in 3 sentences.")
for key, value in result.items():
print(f"{key}: {value:.4f}" if isinstance(value, float) else f"{key}: {value}")
Is é an phríomhphointe ón gcód seo ná stream=True a úsáid. Gan sruthú, ní féidir leat TTFT a scaradh: ní fhillfidh an API ach tar éis na freagra iomláine, mar sin ní thomhaisfidh tú ach iomlán. Tosaíonn an t-amadóir roimh an nglao, stopann sé ag an gcéad delta téacs, agus tugann an fhad atá fágtha roinnte ar líon na dtocanna atá fágtha TPOT. Rith an comhartha céanna in aghaidh dhá shamhail nó dhá shocrú réasúnaíochta agus, laistigh de chúpla nóiméad, beidh an comparáid chainníochtúil agat a chuirfidh tuairimí do fhoirne in ionad.
Botúil a dhiagnóisiú
Léiríonn TTFT ard, os cionn dhá shoicind, trí chúis. Is é an ceann is coitianta ná comhartha córais atá ró-fhada nach bhfuil i dtaisce: caithfidh an tsamhail na mílte token a ionghabháil sula dtosaíonn sí ag scríobh, ar gach glao. An chéad cheann eile ná socruithe réasúnaíochta arda—ard, xhigh, nó max ar GPT-5.6—a dhéanann an tsamhail a smaoineamh go hintinneach sula dtáirgeann sí aon aschur infheicthe; ní bug é seo, is iompar súilte é, ach ba chóir gur rogha chomhfhiosach é, ní socruithe a fuarthas oidhreacht ó phrótaitíopa. Ar deireadh, d’fhéadfadh buaic ualaigh ar thaobh OpenAI a bheith ann, rud nach féidir leat a rialú: sin díreach an fáth a bhfuil gá le tomhas leanúnach seachas seiceáil aonuaire, chun é a idirdhealú ón dá cheann eile.
Léitear TPOT ard, os cionn 50 ms in aghaidh an token, go difriúil. Brúíonn max_output_tokens an-ard an tsamhail chun seichimh fhada a tháirgeadh, agus méadaíonn an fhad iomlán go meicniúil fiú má thagann gach token ag gnáthluas. Cuireann glaonna feidhme casta le go leor uirlisí dearbhaithe ualach ar an nginiúint freisin. Go concreideach, íocfaidh foireann a d’fhág cúig uirlis déag ina scéama nuair nach n-úsáidtear leath acu a thuilleadh an t-ualach sin ar gach glao.
Uirlisí monatóireachta
Ní leor tomhas a dhéanamh uair amháin: ní mór duit an dáileadh a rianú le himeacht ama, toisc go ngineann eireaball an dáilte ticéid tacaíochta. Chun monatóireacht leanúnach táirgeachta, comhtháthaigh na tomhais seo i do stac inbhreathnaitheachta:
import logging
from dataclasses import dataclass, field
@dataclass
class LatencyMetrics:
"""Aggregates latency metrics over a sliding window."""
measurements: list[dict] = field(default_factory=list)
def add(self, measurement: dict) -> None:
self.measurements.append(measurement)
if len(self.measurements) > 1000:
self.measurements = self.measurements[-1000:]
@property
def ttft_p50(self) -> float:
values = sorted(m["ttft"] for m in self.measurements if "ttft" in m)
if not values:
return 0.0
return values[len(values) // 2]
@property
def ttft_p99(self) -> float:
values = sorted(m["ttft"] for m in self.measurements if "ttft" in m)
if not values:
return 0.0
idx = int(len(values) * 0.99)
return values[min(idx, len(values) - 1)]
def report(self) -> str:
return (
f"TTFT p50={self.ttft_p50:.3f}s p99={self.ttft_p99:.3f}s | "
f"Samples: {len(self.measurements)}"
)
Coscaíonn an fhuinneog shleamhnáin de mhíle tomhas fás cuimhne gan teorainn agus coinníonn sé sampla ionadaíoch den trácht is déanaí. Go ríthábhachtach, nochtann an rang seo dhá cheathrúchán, ní meán: cur síos ar sheirbhís a fhaigheann an chuid is mó d’úsáideoirí tapa agus a fhaigheann mionlach mí-úsáideach is ea p50 de 700 ms le p99 de 6 shoicind. Chuirfeadh meán an dá réaltacht seo i bhfolach. Ceangail report() le do uirlis méadrachta agus socraigh tairseach foláirimh ar p99 sula dteagmháilfidh tú leis an gcuid eile den chóras.
Príomhphointí
- Briseann moill síos ina TTFT + giniúint (TPOT × tokenanna) + líonra
- Déan tomhas le sruthú i gcónaí chun TTFT fíor a fháil
- Rianaigh ceathrúcháin p50 agus p99, ní an meán amháin
- Baineann rogha samhlacha agus socruithe réasúnaíochta go díreach le moill: freagraíonn GPT-5.6 Terra le réasúnú íseal níos tapúla ná GPT-5.6 Sol le réasúnú ard