Caching ardleibhéal na leideanna
Ar an leathanach seo
Thar an gcaching uathoibríoch
Chonaic tú bunús caching na leideanna i gCeacht 3. Ansin, bhí an caching le feiceáil mar mheicníocht uathoibríoch a thugann tairbhe duit gan aon iarracht speisialta, agus tá sé sin fíor fad is a sheolann d’iarratas iarratais atá ordaithe go maith. Is móilíne fíréaltacht na táirgeachta: buaileann úsáideoirí iolracha an API céanna ag an am céanna, gach duine acu lena fhillteán féin, lena gcáipéisí féin agus lena gceisteanna féin. Ansin, laghdaítear an réamhtheachta coiteann go dtí beagnach neamhní, agus titann an ráta buailte cache gan aon duine a thabhairt faoi deara é, ós rud é nach mbristear aon rud – ní mhéadaíonn ach an bille.
Il-úsáideoir, il-cháipéis, píblínte próiseála: déanfaimid dul i ngleic leis na cásanna casta seo ceann ar cheann chun an ráta buailte cache a uasmhéadú. Oireann an prionsabal treorach d’aon abairt amháin: ní rud a tharlaíonn duit é an caching; is rud a dhearann tú é.
Ailtireacht leideanna chun caching a uasmhéadú
Baineann caching leis an réamhtheachta coiteann is faide thar d’iarratais. Dá fhaide agus dá cobhsaí an réamhtheachta seo, is mó a shábhálann tú. Is é an toradh praiticiúil ná go gcaithfear leid a eagrú ón gceann is cobhsaí go dtí an ceann is athraitheach, cosúil le leabhar nach n-athraíonn na chéad leathanaigh riamh agus nach ndéantar ach an caibidil dheireanach a athscríobh le gach eagrán.
Cuireann an sampla thíos an prionsabal seo i bhfeidhm ar chúntóir anailíse cáipéisí do ghnólacht dlí. Leanann trí shraith ar a chéile: treoracha domhanda, atá reoite; an bonn eolais, a athbhreithnítear uair sa mhí; agus comhad an cháis agus an cheist, a athraíonn le gach glao.
import openai
client = openai.OpenAI()
# Ailtireacht shraithe: ón gceann is cobhsaí go dtí an ceann is athraitheach
# Sraith 1: Treoracha domhanda (ní athraíonn siad riamh)
GLOBAL_INSTRUCTIONS = """
You are a document analysis assistant for a law firm.
Rules:
- Always respond in French
- Cite relevant legal articles
- Structure as: Analysis / Risks / Recommendations
- Be factual and precise
"""
# Sraith 2: Bonn eolais (athraíonn sé go hannamh)
KNOWLEDGE_BASE = """
[Insert 5,000+ tokens of case law, legal articles,
analysis templates here—this content changes at most once a month]
"""
# Sraith 3: Comhthéacs an cháis (athraíonn sé in aghaidh an chliaint)
def build_prompt(case_context: str, question: str) -> str:
return f"""{GLOBAL_INSTRUCTIONS}
{KNOWLEDGE_BASE}
--- Current Case ---
{case_context}
--- Question ---
{question}"""
Is é an botún clasaiceach ná ainm an chliaint nó dáta an lae inniu a chur ag tús na leide córais chun é a “phearsantú”. Tá carachtar athraitheach amháin sa chéad suíomh sách chun an réamhtheachta a dhéanamh uathúil, ag laghdú an ráta buailte cache go nialas do gach sraith ina dhiaidh sin. Caithfidh aon rud a athraíonn dul go dtí an deireadh.
Ar ndóigh, ní mór duit a fhíorú go n-aistríonn an teoiric go huimhreacha. Léann an monatóir seo a leanas input_tokens_details.cached_tokens ar gach freagra agus carnann sé na tomhais, ag tabhairt meánráta inúsáidte duit seachas braistint bhoilg.
class CacheMonitor:
"""Déanann monatóireacht ar éifeachtúlacht caching na leideanna."""
def __init__(self):
self.calls: list[dict] = []
def record(self, usage) -> dict:
total_input = usage.input_tokens
cached_tokens = getattr(
usage.input_tokens_details, "cached_tokens", 0
)
rate = cached_tokens / total_input if total_input > 0 else 0
entry = {
"total_input": total_input,
"cached_tokens": cached_tokens,
"cache_rate": rate,
}
self.calls.append(entry)
return entry
@property
def average_rate(self) -> float:
if not self.calls:
return 0.0
return sum(a["cache_rate"] for a in self.calls) / len(self.calls)
def report(self) -> str:
if not self.calls:
return "Gan glaonna."
return (
f"Glaonna: {len(self.calls)} | "
f"Meánráta cache: {self.average_rate:.1%} | "
f"Tokenanna sábháilte: "
f"{sum(a['cached_tokens'] for a in self.calls):,}"
)
monitor = CacheMonitor()
Trí phatrún a dhéanann an difríocht
Baineann an chéad phatrún le hord próiseála. Nuair a phróiseálann tú baisc d’iarratais ilchineálacha, déanann reáchtáil iad in ord teachta malartú ar réamhtheachtaithe agus coscaíonn sé an cache fanacht te. Réitíonn grúpáil de réir comhthéacs roinnte an fhadhb: bailigh ar dtús, déan feidhmiú níos déanaí, ionas go mbaineann gach grúpa tairbhe as an réamhtheachta atá ullmhaithe ag a chéad iarratas.
from collections import defaultdict
def group_by_context(
requests: list[dict],
) -> dict[str, list[dict]]:
"""Grúpálann sé iarratais de réir réamhtheachta coiteann."""
groups = defaultdict(list)
for request in requests:
# Eochair = hais den chomhthéacs roinnte
key = hash(request.get("shared_context", ""))
groups[key].append(request)
return dict(groups)
def process_by_cohort(requests: list[dict]):
"""Próiseálann sé iarratais ghrúpáilte chun caching a uasmhéadú."""
groups = group_by_context(requests)
for key, group in groups.items():
# Roinneann gach iarratas sa ghrúpa an réamhtheachta céanna
for request in group:
response = client.responses.create(
model="gpt-5.6-terra",
instructions=request["shared_context"],
input=request["question"],
)
monitor.record(response.usage)
Láimhseálann an dara patrún tosaithe fuara. Íocann an chéad iarratas i sraith an praghas iomlán ós rud é nach bhfuil aon rud cached fós; má thagann an chéad iarratas sin ó úsáideoir fíor ar maidin Dé Luain ag 9 a.m., fulaingíonn siad an moill. Aistríonn iarratas téimh a sheoltar sula n-osclaítear an tseirbhís an costas sin go dtí áit nach gcuireann isteach ar dhuine ar bith. Tabhair faoi deara an garda ag tús na feidhme: faoi bhun 1,024 token, ní bhaineann caching leis, agus bheadh réamhthéamh ina chostas íon.
def warm_up_cache(system_prompt: str):
"""Seolann sé iarratas íosta chun an cache a ullmhú."""
if len(system_prompt) // 4 < 1024:
print("Leid ró-ghearr le haghaidh caching (< 1,024 token)")
return
response = client.responses.create(
model="gpt-5.6-terra",
instructions=system_prompt,
input="Confirm that you are ready.",
max_output_tokens=10,
)
usage = response.usage
print(
f"Cache ullmhaithe: {usage.input_tokens} token ionchuir, "
f"{getattr(usage.input_tokens_details, 'cached_tokens', 0)} cached"
)
Déanann an tríú patrún neamhbhailíochtú an cache infheicthe. Is cosúil gur rud triviálta é camóg a shocrú i leid córais 5,000-token, ach sruthlaíonn an camóg sin an cache do chách. Trí mhéarloirg a cheangal leis an ábhar, braithfidh tú an t-athrú ag an imlonnú seachas an lá dár gcionn ar an mbille, agus is féidir leat leanúint ar aghaidh láithreach le réamhthéamh.
import hashlib
class VersionedPrompt:
"""Bainistíonn sé leaganacha leideanna chun caching a rialú."""
def __init__(self, content: str):
self.content = content
self.version = hashlib.md5(content.encode()).hexdigest()[:8]
def is_same_version(self, other: "VersionedPrompt") -> bool:
return self.version == other.version
# Má athraíonn an leagan, déanfar an cache a neamhbhailíochtú
prompt_v1 = VersionedPrompt("Instructions v1...")
prompt_v2 = VersionedPrompt("Instructions v2 modified...")
if not prompt_v1.is_same_version(prompt_v2):
print("Rabhadh: athraíodh an leid, déanfar an cache a neamhbhailíochtú")
warm_up_cache(prompt_v2.content)
Cad a chiallaíonn sé seo i méid
Tóg cás fíorshaol de 10,000 glao in aghaidh an lae le leid córais 3,000-token. Gan caching, billeálann tú 10,000 × 3,000, nó 30M token ionchuir gach lá. Le ráta buailte 80%, fanann 6M token ag an bpraghas iomlán agus titann 24M go dtí leathphraghas, ag tabhairt na sábhálacha go dtí thart ar 40% ar thokenanna ionchuir. Is cosúil go bhfuil an figiúr measartha i gcoibhneas le glao amháin; thar bhliain táirgeachta, athraíonn sé struchtúr costais an iarratais.
Príomhphointí
- Struchtúraigh do leideanna i sraitheanna ón gceann is cobhsaí go dtí an ceann is athraitheach
- Grúpáil iarratais de réir comhthéacs roinnte chun an cache a choinneáil te
- Téigh an cache roimh bhuaicphointí tráchta
- Déan monatóireacht ar an ráta cache le
input_tokens_details.cached_tokens - Cuir leaganacha ar do leideanna chun réamh-mheastachán a dhéanamh ar neamhbhailíochtaí cache