Išplėstinis užklausų talpinimas į podėlį
Šiame puslapyje
Anapus automatinio talpinimo į podėlį
3 pamokoje susipažinai su pagrindiniais užklausų talpinimo į podėlį (caching) principais. Ten tai atrodė kaip automatinis mechanizmas, tau naudingas be jokių papildomų pastangų, ir tai tiesa tol, kol tavo programa siunčia tinkamai sutvarkytas užklausas. Realybė gamybinėje aplinkoje yra sudėtingesnė: daugelis vartotojų vienu metu kreipiasi į tą patį API, kiekvienas su savo aplanku, dokumentais ir klausimais. Tuomet bendras priešdėlis sumažėja beveik iki nulio, o pasiekimų podėlyje (cache hit) rodiklis žlunga niekam to nepastebint, nes niekas nesulūžta – tiesiog išauga sąskaita.
Daugiavartotojai, daugiadokumentiai apdorojimo scenarijai ir duomenų srautai: šias sudėtingas situacijas nagrinėsime po vieną, siekdami maksimaliai padidinti pasiekimų podėlyje rodiklį. Pagrindinis principas telpa į vieną sakinį: talpinimas į podėlį nėra tai, kas tau tiesiog nutinka; tai yra tai, ką tu projektuoji.
Užklausų architektūra maksimaliam talpinimui į podėlį
Talpinimas į podėlį taikomas ilgiausiam bendram visų tavo užklausų priešdėliui. Kuo šis priešdėlis ilgesnis ir stabilesnis, tuo daugiau sutaupai. Praktinė išvada tokia: užklausa turi būti suorganizuota nuo stabiliausios dalies iki kintamiausios, tarsi knyga, kurios pirmieji puslapiai niekada nesikeičia, o tik paskutinis skyrius perrašomas kiekviename leidime.
Toliau pateiktame pavyzdyje šis principas taikomas dokumentų analizės asistentui, skirtam advokatų kontorai. Čia išdėstyti trys sluoksniai: globalios instrukcijos, kurios yra užšaldytos; žinių bazė, peržiūrima kartą per mėnesį; ir bylos medžiaga bei klausimas, kurie keičiasi su kiekvienu kvietimu.
import openai
client = openai.OpenAI()
# Sluoksniuota architektūra: nuo stabiliausios iki kintamiausios
# 1 sluoksnis: Globalios instrukcijos (niekada nesikeičia)
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
"""
# 2 sluoksnis: Žinių bazė (keičiasi retai)
KNOWLEDGE_BASE = """
[Insert 5,000+ tokens of case law, legal articles,
analysis templates here—this content changes at most once a month]
"""
# 3 sluoksnis: Bylos kontekstas (keičiasi kiekvienam klientui)
def build_prompt(case_context: str, question: str) -> str:
return f"""{GLOBAL_INSTRUCTIONS}
{KNOWLEDGE_BASE}
--- Current Case ---
{case_context}
--- Question ---
{question}"""
Klasikinė klaida – sistemos užklausos pradžioje įterpti kliento vardą ar šiandienos datą, siekiant ją „asmenuoti“. Vienas kintamas simbolis pradinėje pozicijoje pakankamas, kad priešdėlis taptų unikalus, o pasiekimų podėlyje rodiklis visiems vėlesniems sluoksniams nukristų iki nulio. Viskas, kas kinta, turi būti pabaigoje.
Žinoma, turi patikrinti, ar teorija atsispindi skaičiuose. Toliau pateiktas stebėsenos įrankis kiekviename atsakyme nuskaitydamas input_tokens_details.cached_tokens kaupia matavimus, suteikdamas tau naudotiną vidutinį rodiklį, o ne spėjimą.
class CacheMonitor:
"""Stebi užklausų talpinimo į podėlį efektyvumą."""
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 "Nėra kvietimų."
return (
f"Kvietimai: {len(self.calls)} | "
f"Vidutinis pasiekimų podėlyje rodiklis: {self.average_rate:.1%} | "
f"Sutaupyta tokenų: "
f"{sum(a['cached_tokens'] for a in self.calls):,}"
)
monitor = CacheMonitor()
Trys modeliai, darantys skirtumą
Pirmasis modelis susijęs su apdorojimo tvarka. Kai apdoroji heterogeninių užklausų grupę, jų vykdymas atvykimo tvarka keičia priešdėlius ir neleidžia podėliui išlikti „įšilusiam“. Grupavimas pagal bendrą kontekstą išsprendžia šią problemą: pirmiausia sugrupuok, vėliau vykdyk, kad kiekviena grupė pasinaudotų priešdėliu, paruoštu jos pirmosios užklausos.
from collections import defaultdict
def group_by_context(
requests: list[dict],
) -> dict[str, list[dict]]:
"""Grupuoja užklausas pagal bendrą priešdėlį."""
groups = defaultdict(list)
for request in requests:
# Raktas = bendro konteksto maišos reikšmė (hash)
key = hash(request.get("shared_context", ""))
groups[key].append(request)
return dict(groups)
def process_by_cohort(requests: list[dict]):
"""Apdoroja sugrupuotas užklausas maksimaliam talpinimui į podėlį."""
groups = group_by_context(requests)
for key, group in groups.items():
# Visos grupės užklausos dalijasi tuo pačiu priešdėliu
for request in group:
response = client.responses.create(
model="gpt-5.6-terra",
instructions=request["shared_context"],
input=request["question"],
)
monitor.record(response.usage)
Antrasis modelis sprendžia „šalto starto“ problemą. Pirmoji serijos užklausa kainuoja pilną kainą, nes dar niekas nėra įkelta į podėlį; jei tą pirmąją užklausą pirmadienio rytą 9 val. pateikia tikras vartotojas, jis ir patiria delsą. „Įšildymo“ užklausa, išsiųsta prieš pradedant darbą servisui, perkelia šią kainą ten, kur ji niekam netrukdo. Atkreipk dėmesį į apsaugą funkcijos pradžioje: esant mažiau nei 1024 tokenams, talpinimas į podėlį negalioja, o išankstinis „įšildymas“ būtų grynas nuostolis.
def warm_up_cache(system_prompt: str):
"""Siunčia minimalią užklausą podėliui paruošti."""
if len(system_prompt) // 4 < 1024:
print("Užklausa per trumpa talpinimui į podėlį (< 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"Podėlis paruoštas: {usage.input_tokens} įvesties tokenų, "
f"{getattr(usage.input_tokens_details, 'cached_tokens', 0)} įrašyta į podėlį"
)
Trečiasis modelis daro podėlio išvalymą (invalidavimą) matomą. Kablelio pataisymas 5000 tokenų sistemos užklausoje gali atrodyti nereikšminga, tačiau tas kablelis išvalo podėlį visiems vartotojams. Pridėjus turinio „piršto atspaudą“ (fingerprint), pokytį aptinki diegimo metu, o ne kitą dieną sąskaitoje, ir gali iškart imtis išankstinio „įšildymo“.
import hashlib
class VersionedPrompt:
"""Valdo užklausų versijas talpinimui į podėlį kontroliuoti."""
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
# Jei versija pasikeičia, podėlis bus išvalytas
prompt_v1 = VersionedPrompt("Instructions v1...")
prompt_v2 = VersionedPrompt("Instructions v2 modified...")
if not prompt_v1.is_same_version(prompt_v2):
print("Įspėjimas: užklausa pakeista, podėlis bus išvalytas")
warm_up_cache(prompt_v2.content)
Ką tai reiškia dideliais kiekiais
Paimkime realų atvejį: 10 000 kvietimų per dieną su 3000 tokenų sistemos užklausa. Be talpinimo į podėlį, sąskaitoje būtų 10 000 × 3000, arba 30 mln. įvesties tokenų kiekvieną dieną. Esant 80 % pasiekimų rodikliui, 6 mln. tokenų lieka pilna kaina, o 24 mln. atpinga perpus, todėl sutaupoma apie 40 % įvesties tokenų kainos. Skaičius gali atrodyti nedidelis vieno kvietimo mastu, tačiau per metus gamybinėje aplinkoje tai pakeičia visos programos išlaidų struktūrą.
Svarbiausi punktai
- Struktūrizuok savo užklausas sluoksniais nuo stabiliausios iki kintamiausios dalies
- Grupuoji užklausas pagal bendrą kontekstą, kad podėlis išliktų „įšilęs“
- „Įšildyk“ podėlį prieš didelio srauto pikus
- Stebėk pasiekimų podėlyje rodiklį naudodamas
input_tokens_details.cached_tokens - Versijuok savo užklausas, kad numatytum podėlio išvalymus