در این فصل چه یاد میگیری#
۲۰۰۰ درخواستِ واقعنما به سرویس میدهیم و میبینیم فقط ۲۸۴ متنِ متمایز دارند. یک dict دهخطی اضافه میکنیم و اجرای مدل از ۲۰۰۰ بار به ۲۵۰ بار میرسد — نرخِ اصابت ۸۷٫۵ درصد.
بعد گرانترین اشتباهِ این حوزه را میسازیم: مدل را بازآموزی میکنیم و کلیدِ cache را دست نمیزنیم. ۴۸ درخواست جوابِ مدلِ قدیمی میگیرند — با کدِ ۲۰۰، بدونِ هیچ خطایی، و سریعتر از همیشه. یک تکه رشته به کلید اضافه میکنیم و عدد صفر میشود؛ و میشماریم که این درستکاری چقدر خرج برداشت.

آخر این فصل میتوانی:
- نرخِ اصابت را بهعنوان یک متریک اندازه بگیری، نه یک احساس
- کلیدِ
cacheرا طوری بسازی که هیچوقت جوابِ کهنه ندهد - دو لایهٔ
cacheبگذاری و بگویی هرکدام چه چیزی را نجات میدهد - عمرِ ورودی و پیشمحاسبه را با عدد انتخاب کنی، نه با حدس
قبل از شروع#
از فصلِ ۱: MANIFEST و شمارهٔ نسخه — همان شماره اینجا وارد کلیدِ cache میشود. از فصلِ ۴: ساعتِ مجازی، که عمرِ ورودی را قابلِ آزمایش میکند. از ترمِ ۲ فصلِ ۶: نرمالسازیِ متنِ فارسی، که این بار نه دقتِ مدل بلکه نرخِ اصابت را عوض میکند.
📓 نوتبوک: نوتبوک این فصل را در Colab باز کن — همهٔ کدهای این فصل آماده و بهترتیب داخلش هست.
| اجرا | زمانِ تقریبی |
|---|---|
| کلِ نوتبوک روی CPU | حدودِ یک دقیقه |
| GPU | لازم نیست |
۱. ترافیکِ واقعی تکرار دارد#
cache وقتی معنا دارد که همان سؤال دوباره پرسیده شود. در پشتیبانی این دقیقاً همان چیزی است که میافتد: وقتی درگاهِ پرداخت خراب میشود، هزار نفر تقریباً یک جمله مینویسند.
import random
import sqlite3
POOL = [r["text"] for r in TEST]
WEIGHTS = [20.0] * 60 + [1.0] * (len(POOL) - 60) # ۶۰ شکایتِ پرتکرار، بقیه پراکنده
STREAM = random.Random(11).choices(POOL, weights=WEIGHTS, k=2000)
print("درخواستها :", len(STREAM))
print("متنهای متمایز :", len(set(STREAM)))
print("پرتکرارترین متن :", max(STREAM.count(t) for t in set(STREAM)), "بار")
print("سهمِ ۶۰ متنِ داغ :", round(sum(t in set(POOL[:60]) for t in STREAM) / len(STREAM), 3))
درخواستها : 2000
متنهای متمایز : 284
پرتکرارترین متن : 60 بار
سهمِ ۶۰ متنِ داغ : 0.765
۲۰۰۰ درخواست، ۲۸۴ سؤالِ متمایز، و سهچهارمِ ترافیک از ۶۰ متن میآید.
این شکلِ توزیع اسم دارد و همهجا دیده میشود: کلمههای یک زبان، صفحههای یک سایت، محصولاتِ یک فروشگاه. هر جا این شکل را ببینی، cache جواب میدهد؛ و هر جا ترافیک واقعاً یکنواخت باشد، cache فقط حافظه مصرف میکند.
۲. لایهٔ اول: یک dict#
class Clock:
def __init__(self, start=0.0):
self.t = float(start)
def now(self):
return self.t
def advance(self, seconds):
self.t += seconds
return self.t
model_v1 = fit_model(TRAIN[:800])
MODELS = {"1.0.0": model_v1}
CALLS = {"n": 0}
def ask_model(version, text):
CALLS["n"] += 1
return MODELS[version].predict([normalise(text)])[0]
def replay(stream, key_of, version="1.0.0"):
CALLS["n"] = 0
memory, hits, answers = {}, 0, []
for text in stream:
key = key_of(text, version)
if key in memory:
hits += 1
else:
memory[key] = ask_model(version, text)
answers.append(memory[key])
return {"hits": hits, "calls": CALLS["n"], "entries": len(memory), "answers": answers}
raw = replay(STREAM, lambda text, version: text)
print(f"بدونِ cache : {len(STREAM):>4} بار اجرای مدل · نرخِ اصابت 0.0%")
print(f"با cache : {raw['calls']:>4} بار اجرای مدل · نرخِ اصابت"
f" {100 * raw['hits'] / len(STREAM):.1f}%")
بدونِ cache : 2000 بار اجرای مدل · نرخِ اصابت 0.0%
با cache : 284 بار اجرای مدل · نرخِ اصابت 85.8%
هفت برابر کمتر اجرای مدل، با یک dict.
و CALLS مهمتر از خودِ cache است. بدونِ این شمارنده فقط میتوانستیم بگوییم «سریعتر شد»؛ با آن میگوییم دقیقاً چند بار مدل اجرا شد. نرخِ اصابت یک متریکِ درجهیکِ سرویس است، نه یک جزئیاتِ داخلی — روی همان داشبوردی مینشیند که نرخِ خطا و p95 مینشینند.
۳. کلید، مهمتر از خودِ cache#
دو کاربر یک شکایت مینویسند، یکی با صفحهکلیدِ فارسی و یکی با صفحهکلیدِ عربی. برای مدل یکیاند — چون ask_model متن را نرمال میکند — ولی برای cache دو سؤالِ متفاوتند، چون کلیدمان متنِ خام است.
norm = replay(STREAM, lambda text, version: normalise(text))
print(f"کلیدِ خام : {raw['entries']:>4} ورودیِ cache · نرخِ اصابت"
f" {100 * raw['hits'] / len(STREAM):.1f}%")
print(f"کلیدِ نرمالشده : {norm['entries']:>4} ورودیِ cache · نرخِ اصابت"
f" {100 * norm['hits'] / len(STREAM):.1f}%")
print("اجرای مدل، کمتر شده به اندازهٔ:", raw["calls"] - norm["calls"])
print("جوابها یکی است؟", raw["answers"] == norm["answers"])
کلیدِ خام : 284 ورودیِ cache · نرخِ اصابت 85.8%
کلیدِ نرمالشده : 250 ورودیِ cache · نرخِ اصابت 87.5%
اجرای مدل، کمتر شده به اندازهٔ: 34
جوابها یکی است؟ True
۳۴ اجرای کمتر، و هر ۲۰۰۰ جواب مو به مو همانهایند.
یک و هفتدهم واحد بهبود، نه بیشتر — و همینقدر را صادقانه مینویسیم. درسش هم اندازهٔ عدد نیست؛ قاعده است: کلیدِ cache باید همان چیزی باشد که مدل واقعاً میبیند. اگر مدل متنِ نرمالشده میبیند و کلید متنِ خام است، دو نوشتارِ یک جمله دو ورودیِ جدا میگیرند. روی پیکرهٔ ما این ۳۴ اجراست؛ روی سرویسی که ورودیاش را بیشتر پیشپردازش میکند — حروفِ کوچک، حذفِ نشانهها، مرتبسازیِ پارامترها — همین اختلاف چند برابر میشود.
و شرطِ سلامت این است که خطِ آخر True باشد. cache اجازه ندارد جواب را عوض کند؛ فقط اجازه دارد ارزانترش کند.
۴. لایهٔ دوم: cache ای که ریاستارت را رد میکند#
dict با فرآیند میمیرد. هر بار که سرویس را دوباره راه بیندازی، همهچیز از صفر شروع میشود. لایهٔ دوم یک پایگاه دادهٔ کوچک است که بیرونِ فرآیند زندگی میکند.
CACHE = sqlite3.connect(str(WORK / "cache.db"))
CACHE.execute("CREATE TABLE l2 (key TEXT PRIMARY KEY, label TEXT, stored_at REAL)")
def l2_get(key):
row = CACHE.execute("SELECT label FROM l2 WHERE key = ?", (key,)).fetchone()
return row[0] if row else None
def l2_put(key, label, at):
CACHE.execute("INSERT OR REPLACE INTO l2 VALUES (?, ?, ?)", (key, label, at))
def two_layer(stream, version="1.0.0", warm_l1=None):
CALLS["n"] = 0
l1 = dict(warm_l1 or {})
stats = {"l1": 0, "l2": 0, "miss": 0}
for text in stream:
key = version + "|" + normalise(text)
if key in l1:
stats["l1"] += 1
continue
found = l2_get(key)
if found is not None:
stats["l2"] += 1
l1[key] = found
continue
stats["miss"] += 1
label = ask_model(version, text)
l1[key] = label
l2_put(key, label, 0.0)
return stats, l1
first, _ = two_layer(STREAM)
print("اجرای اول — L1:", first["l1"], "· L2:", first["l2"], "· مدل:", first["miss"])
second, _ = two_layer(STREAM) # فرآیند از نو، L1 خالی
print("بعد از ریاستارت — L1:", second["l1"], "· L2:", second["l2"], "· مدل:", second["miss"])
اجرای اول — L1: 1750 · L2: 0 · مدل: 250
بعد از ریاستارت — L1: 1750 · L2: 250 · مدل: 0
بعد از ریاستارت، صفر بار اجرای مدل. ۲۵۰ سؤالِ متمایز از لایهٔ دوم آمدند و بلافاصله در لایهٔ اول نشستند.
هر لایه یک شکستِ متفاوت را میپوشاند: لایهٔ اول سریعترین است ولی به فرآیند وابسته و بینِ چند نمونهٔ سرویس مشترک نیست؛ لایهٔ دوم کندتر است ولی از ریاستارت جان سالم به در میبرد و همهٔ نمونهها میتوانند از آن بخوانند. در تولید لایهٔ دوم معمولاً یک cache مشترکِ روی شبکه است؛ ما sqlite3 گذاشتیم چون همان نقش را با صفر وابستگی بازی میکند.
✅ چک کن: اگر بعد از «ریاستارت» عددِ لایهٔ دوم صفر ماند و مدل دوباره ۲۵۰ بار اجرا شد، کلیدِ نوشتن و کلیدِ خواندن یکی نیستند. این شایعترین باگِ
cacheاست و هیچ خطایی هم نمیدهد — فقطcacheات همیشه خالی میماند و تو فکر میکنی داری از آن استفاده میکنی. کلید را در هر دو مسیر یک بار چاپ کن و با چشم مقایسه کن.
۵. عمرِ ورودی، با ساعتِ مجازی#
هیچ جوابی برای همیشه معتبر نیست. TTL میگوید یک ورودی چند ثانیه پس از ذخیره هنوز قابلِ استفاده است. آزمایشش با زمانِ واقعی نیم ساعت طول میکشد؛ با ساعتِ فصلِ ۴ کسری از ثانیه.
def replay_ttl(stream, ttl, gap=1.0):
CALLS["n"] = 0
clock = Clock()
memory, hits = {}, 0
for text in stream:
clock.advance(gap) # یک درخواست در هر ثانیهٔ مجازی
key = normalise(text)
entry = memory.get(key)
if entry is not None and clock.now() - entry[1] <= ttl:
hits += 1
continue
memory[key] = (ask_model("1.0.0", text), clock.now())
return hits, CALLS["n"], clock.now()
print(f"{'TTL (ثانیه)':>12}{'نرخِ اصابت':>12}{'اجرای مدل':>12}")
for ttl in (0, 60, 300, 1800, float("inf")):
hits, calls, end = replay_ttl(STREAM, ttl)
name = "بینهایت" if ttl == float("inf") else f"{ttl:.0f}"
print(f"{name:>12}{100 * hits / len(STREAM):>11.1f}%{calls:>12}")
print("کلِ زمانِ مجازیِ ترافیک:", int(end), "ثانیه")
TTL (ثانیه) نرخِ اصابت اجرای مدل
0 0.0% 2000
60 38.8% 1224
300 68.2% 637
1800 85.3% 293
بینهایت 87.5% 250
کلِ زمانِ مجازیِ ترافیک: 2000 ثانیه
۳۳ دقیقهٔ ترافیک، در کسری از ثانیه، با عددهایی که هر بار عیناً تکرار میشوند.
جدول یک شکلِ آشنا دارد: سود در ابتدا تند بالا میرود و بعد صاف میشود. از ۶۰ به ۳۰۰ نرخِ اصابت ۳۰ واحد بالا میرود؛ از ۱۸۰۰ به بینهایت فقط دو واحد. پس TTL را جایی میگذاری که منحنی صاف شده باشد، نه بیشتر — چون هر ثانیهٔ اضافه فقط ریسکِ کهنگی را زیاد میکند و دیگر چیزی نمیخرد.
و TTL برابرِ صفر یعنی cache ای در کار نیست. خطِ اولِ جدول برای همین آنجاست: هر تنظیمی باید در برابرِ «اصلاً نباشد» سنجیده شود.
۶. باطلسازی: ۴۸ جوابِ کهنه، با اطمینانِ کامل#
حالا صحنهٔ اصلی. مدل را بازآموزی میکنیم — همان کاری که هر تیمی ماهی یک بار میکند — و در وسطِ ترافیک نسخهٔ تازه را جایگزین میکنیم. کلیدِ cache را دست نمیزنیم، چون بهنظر ربطی ندارد.
MODELS["1.1.0"] = fit_model(TRAIN) # بازآموزی روی همهٔ ۱۱۰۰ ردیف
SECOND = STREAM[1000:]
def replay_switch(versioned_key):
CALLS["n"] = 0
memory, served = {}, []
for i, text in enumerate(STREAM):
version = "1.0.0" if i < 1000 else "1.1.0" # وسطِ ترافیک، نسخهٔ تازه بالا میآید
key = (version + "|" if versioned_key else "") + normalise(text)
if key not in memory:
memory[key] = ask_model(version, text)
served.append(memory[key])
fresh = {t: MODELS["1.1.0"].predict([normalise(t)])[0] for t in set(SECOND)}
wrong = sum(1 for text, answer in zip(SECOND, served[1000:]) if answer != fresh[text])
return {"wrong": wrong, "calls": CALLS["n"]}
plain = replay_switch(versioned_key=False)
tagged = replay_switch(versioned_key=True)
print(f"کلیدِ بدونِ نسخه : {plain['wrong']:>3} جوابِ کهنه در هزار درخواستِ دوم"
f" · اجرای مدل {plain['calls']}")
print(f"کلیدِ با نسخه : {tagged['wrong']:>3} جوابِ کهنه در هزار درخواستِ دوم"
f" · اجرای مدل {tagged['calls']}")
کلیدِ بدونِ نسخه : 48 جوابِ کهنه در هزار درخواستِ دوم · اجرای مدل 250
کلیدِ با نسخه : 0 جوابِ کهنه در هزار درخواستِ دوم · اجرای مدل 377
۴۸ کاربر از هزار نفر جوابِ مدلی را گرفتند که دیگر مستقر نبود.
نه خطایی، نه لاگی، نه کندی — این درخواستها از همه سریعتر هم بودند، چون از cache آمدند. و اگر بعدش نتیجه را بسنجی، دقتِ «مدلِ تازه» را پایینتر از واقعیت میبینی و مدتها دنبالِ باگ در جای اشتباه میگردی.
صفرِ خطِ دوم قطعی است، نه شانسی: وقتی نسخه بخشی از کلید باشد، هیچ ورودیِ نسخهٔ قبل با کلیدِ نسخهٔ تازه پیدا نمیشود. این تفاوتِ «باطلسازی» و «کلیدِ درست» است — بهجای اینکه یادت باشد بعد از هر انتشار cache را پاک کنی، کلید را طوری بساز که فراموش کردن ممکن نباشد.
و قیمتش را هم شمردهایم: ۱۲۷ اجرای اضافه. هر چیزی که وارد کلید شود، cache را تکهتکه میکند؛ پس فقط چیزهایی وارد کلید میشوند که جواب را عوض میکنند: نسخهٔ مدل، نسخهٔ پیشپردازش، و هر پارامترِ درخواست که در خروجی اثر دارد.
📏 اندازه بگیر: با چه چیزی مقایسه شد؟ با همان ۲۰۰۰ درخواست و همان دو مدل؛ تنها متغیر یک تکه رشته در کلید بود. روی کدام داده؟ هزار درخواستِ دومِ همان جریان، در هر دو حالت. با چند
seed؟ یکی، و جریان باRandom(11)ساخته شده، پس عددِ ۴۸ روی هر ماشینی همان ۴۸ است. ولی یک صداقتِ لازم: این عدد به میزانِ اختلافِ دو مدل بستگی دارد، نه بهcache. اگر مدلِ تازهات تغییرِ بزرگتری داشته باشد، همین باگ صدها جوابِ کهنه میسازد. آنچه قابلِ تعمیم است این است که عدد صفر نیست؛ اندازهاش هر بار باید سنجیده شود.
۷. cache سرد، و پیشمحاسبه#
هر انتشارِ تازه cache را خالی میکند. کاربرهای اولِ بعد از انتشار بدترین تجربه را دارند، و دقیقاً همان لحظهای است که همه نگاه میکنند.
HOT = sorted(set(STREAM), key=lambda t: (-STREAM.count(t), t))[:60] # تساویها هم قطعی
warm = {"1.1.0|" + normalise(t): MODELS["1.1.0"].predict([normalise(t)])[0] for t in HOT}
def hit_rate(stream, warm_l1):
memory, hits = dict(warm_l1), 0
for text in stream:
key = "1.1.0|" + normalise(text)
if key in memory:
hits += 1
else:
memory[key] = MODELS["1.1.0"].predict([normalise(text)])[0]
return 100 * hits / len(stream)
head = SECOND[:200]
print(f"cacheِ سرد : نرخِ اصابت در ۲۰۰ درخواستِ اول {hit_rate(head, {}):.1f}%")
print(f"با پیشمحاسبهٔ ۶۰ متنِ داغ : {hit_rate(head, warm):.1f}%")
cacheِ سرد : نرخِ اصابت در ۲۰۰ درخواستِ اول 54.0%
با پیشمحاسبهٔ ۶۰ متنِ داغ : 80.5%
۶۰ محاسبهٔ قبل از انتشار، بیستوشش واحد نرخِ اصابتِ بیشتر در دویست درخواستِ اول.
این همان ایدهای است که در سامانههای embedding به شکلِ بزرگترش دیده میشود: embedding همهٔ اسناد را یک بار از قبل حساب میکنی و ذخیرهشان میکنی، چون از قبل میدانی لازمشان میشود و میتوانی در ساعتِ خلوت حسابشان کنی.
قاعدهٔ انتخاب ساده است: چیزی را پیشمحاسبه کن که (۱) از قبل بدانی لازم میشود و (۲) خرابیِ کهنگیاش کم باشد. فهرستِ پرتکرارترین سؤالهای دیروز هر دو شرط را دارد.
🔧 اگر کار نکرد: اگر
cacheات پر میشود ولی نرخِ اصابت پایین میماند، اولین چیزی که باید ببینی تعدادِ ورودیها است. اگر تعداد به تعدادِ درخواستها نزدیک شد، یعنی کلیدت چیزی دارد که هر بار عوض میشود — زمان، شناسهٔ درخواست، یاuuid. و اگر برنامه باMemoryErrorیا کندیِ ناگهانی مرد،cacheات سقف ندارد: یکdictبیسقف در تولید یک نشتیِ حافظه است، و راهِ استانداردش بیرون انداختنِ کماستفادهترین ورودی است.
🤖 از دستیارت بپرس: «
LRUچیست و چرا تقریباً همیشه بهعنوان سیاستِ بیرون انداختن انتخاب میشود؟» بعد این را بپرس: «cache stampedeچیست و چرا وقتی یک ورودیِ داغ منقضی میشود، هزار درخواست همزمان به مدل میرسند؟» — جوابش شکلِ دیگری از همان ازدحامی است که در فصلِ ۴ باjitterپخشش کردیم.
واژههای تازهٔ این فصل#
| کلمه | تلفظ به حروف فارسی | یعنی چه |
|---|---|---|
| cache | کش | نگه داشتنِ جوابِ محاسبهشده برای دفعهٔ بعد |
| hit rate | هیت ریت | نسبتِ درخواستهایی که از cache جواب گرفتند |
| cache key | کش کی | رشتهای که مشخص میکند دو درخواست یک سؤالند |
| invalidation | اینولیدیشن | بیاعتبار کردنِ ورودیهایی که دیگر درست نیستند |
| TTL | تیتیال | مدتی که یک ورودی معتبر میماند |
| cold cache | کولد کش | cache خالی، بلافاصله بعد از راهاندازی |
| precompute | پریکامپیوت | حساب کردنِ جواب پیش از آنکه کسی بپرسد |
تمرینها
اول خودت فکر کن یا امتحان کن — بعد اینجا را باز کن.
در فصل بعد#
حالا سرویسی داری که ارزان و پایدار جواب میدهد. فصلِ بعد سختترین سؤالِ ترم را میپرسد: مدلِ تازه را چطور منتشر میکنی؟ دو نسخه داریم که نسخهٔ تازهشان روی کلِ ترافیک بهتر است ولی روی یک زیرگروهِ ششدرصدی از ۹۳ درصد به ۴۱ درصد سقوط میکند. سه استراتژیِ انتشار را روی هر دو اجرا میکنیم و میشماریم کدامیک این سقوط را میگیرد و کدام با خیالِ راحت تأییدش میکند.
به آخر این فصل رسیدی!
اگر ساختی و جواب داد، این دکمه مال توست.