# فصل ۰۵ — `cache` و پیش‌محاسبه

<div dir="rtl">

# فصل ۰۵ — `cache` و پیش‌محاسبه

## در این فصل چه یاد می‌گیری

۲۰۰۰ درخواستِ واقع‌نما به سرویس می‌دهیم و می‌بینیم فقط ۲۸۴ متنِ متمایز دارند. یک `dict` ده‌خطی اضافه می‌کنیم و **اجرای مدل از ۲۰۰۰ بار به ۲۵۰ بار می‌رسد — نرخِ اصابت ۸۷٫۵ درصد.**

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

![قفسهٔ خانه‌های شماره‌دار با یک خانهٔ مهرِ کهنه](/lesson-assets/t4-s05-caching/prompt/01-image-pigeonhole-stale.png)

آخر این فصل می‌توانی:

- نرخِ اصابت را به‌عنوان یک متریک اندازه بگیری، نه یک احساس
- کلیدِ `cache` را طوری بسازی که هیچ‌وقت جوابِ کهنه ندهد
- دو لایهٔ `cache` بگذاری و بگویی هرکدام چه چیزی را نجات می‌دهد
- عمرِ ورودی و پیش‌محاسبه را با عدد انتخاب کنی، نه با حدس

## قبل از شروع

**از فصلِ ۱:** `MANIFEST` و شمارهٔ نسخه — همان شماره اینجا وارد کلیدِ `cache` می‌شود. **از فصلِ ۴:** ساعتِ مجازی، که عمرِ ورودی را قابلِ آزمایش می‌کند. **از ترمِ ۲ فصلِ ۶:** نرمال‌سازیِ متنِ فارسی، که این بار نه دقتِ مدل بلکه **نرخِ اصابت** را عوض می‌کند.

> 📓 **نوت‌بوک:** [نوت‌بوک این فصل را در Colab باز کن](/notebooks/darbast/term-4-deployment/session-05-caching.ipynb) — همهٔ کدهای این فصل آماده و به‌ترتیب داخلش هست.

</div>

| اجرا | زمانِ تقریبی |
|---|---|
| کلِ نوت‌بوک روی CPU | حدودِ یک دقیقه |
| GPU | لازم نیست |

<div dir="rtl">

## ۱. ترافیکِ واقعی تکرار دارد

`cache` وقتی معنا دارد که همان سؤال دوباره پرسیده شود. در پشتیبانی این دقیقاً همان چیزی است که می‌افتد: وقتی درگاهِ پرداخت خراب می‌شود، هزار نفر تقریباً یک جمله می‌نویسند.

</div>

```python
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))
```

```text
درخواست‌ها      : 2000
متن‌های متمایز   : 284
پرتکرارترین متن  : 60 بار
سهمِ ۶۰ متنِ داغ  : 0.765
```

<div dir="rtl">

**۲۰۰۰ درخواست، ۲۸۴ سؤالِ متمایز، و سه‌چهارمِ ترافیک از ۶۰ متن می‌آید.**

این شکلِ توزیع اسم دارد و همه‌جا دیده می‌شود: کلمه‌های یک زبان، صفحه‌های یک سایت، محصولاتِ یک فروشگاه. **هر جا این شکل را ببینی، `cache` جواب می‌دهد؛ و هر جا ترافیک واقعاً یکنواخت باشد، `cache` فقط حافظه مصرف می‌کند.**

## ۲. لایهٔ اول: یک `dict`

</div>

```python
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}%")
```

```text
بدونِ cache : 2000 بار اجرای مدل · نرخِ اصابت 0.0%
با cache    :  284 بار اجرای مدل · نرخِ اصابت 85.8%
```

<div dir="rtl">

**هفت برابر کمتر اجرای مدل، با یک `dict`.**

**و `CALLS` مهم‌تر از خودِ `cache` است.** بدونِ این شمارنده فقط می‌توانستیم بگوییم «سریع‌تر شد»؛ با آن می‌گوییم دقیقاً چند بار مدل اجرا شد. **نرخِ اصابت یک متریکِ درجه‌یکِ سرویس است، نه یک جزئیاتِ داخلی** — روی همان داشبوردی می‌نشیند که نرخِ خطا و `p95` می‌نشینند.

## ۳. کلید، مهم‌تر از خودِ `cache`

دو کاربر یک شکایت می‌نویسند، یکی با صفحه‌کلیدِ فارسی و یکی با صفحه‌کلیدِ عربی. **برای مدل یکی‌اند — چون `ask_model` متن را نرمال می‌کند — ولی برای `cache` دو سؤالِ متفاوتند**، چون کلیدمان متنِ خام است.

</div>

```python
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"])
```

```text
کلیدِ خام      :  284 ورودیِ cache · نرخِ اصابت 85.8%
کلیدِ نرمال‌شده :  250 ورودیِ cache · نرخِ اصابت 87.5%
اجرای مدل، کمتر شده به اندازهٔ: 34
جواب‌ها یکی است؟ True
```

<div dir="rtl">

**۳۴ اجرای کمتر، و هر ۲۰۰۰ جواب مو به مو همان‌هایند.**

**یک و هفت‌دهم واحد بهبود، نه بیشتر — و همین‌قدر را صادقانه می‌نویسیم.** درسش هم اندازهٔ عدد نیست؛ **قاعده** است: **کلیدِ `cache` باید همان چیزی باشد که مدل واقعاً می‌بیند.** اگر مدل متنِ نرمال‌شده می‌بیند و کلید متنِ خام است، دو نوشتارِ یک جمله دو ورودیِ جدا می‌گیرند. روی پیکرهٔ ما این ۳۴ اجراست؛ روی سرویسی که ورودی‌اش را بیشتر پیش‌پردازش می‌کند — حروفِ کوچک، حذفِ نشانه‌ها، مرتب‌سازیِ پارامترها — همین اختلاف چند برابر می‌شود.

**و شرطِ سلامت این است که خطِ آخر `True` باشد.** `cache` اجازه ندارد جواب را عوض کند؛ فقط اجازه دارد ارزان‌ترش کند.

## ۴. لایهٔ دوم: `cache` ای که ری‌استارت را رد می‌کند

`dict` با فرآیند می‌میرد. هر بار که سرویس را دوباره راه بیندازی، همه‌چیز از صفر شروع می‌شود. لایهٔ دوم یک پایگاه دادهٔ کوچک است که بیرونِ فرآیند زندگی می‌کند.

</div>

```python
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"])
```

```text
اجرای اول       — L1: 1750 · L2: 0 · مدل: 250
بعد از ری‌استارت — L1: 1750 · L2: 250 · مدل: 0
```

<div dir="rtl">

**بعد از ری‌استارت، صفر بار اجرای مدل.** ۲۵۰ سؤالِ متمایز از لایهٔ دوم آمدند و بلافاصله در لایهٔ اول نشستند.

**هر لایه یک شکستِ متفاوت را می‌پوشاند:** لایهٔ اول سریع‌ترین است ولی به فرآیند وابسته و بینِ چند نمونهٔ سرویس مشترک نیست؛ لایهٔ دوم کندتر است ولی از ری‌استارت جان سالم به در می‌برد و همهٔ نمونه‌ها می‌توانند از آن بخوانند. **در تولید لایهٔ دوم معمولاً یک `cache` مشترکِ روی شبکه است؛ ما `sqlite3` گذاشتیم چون همان نقش را با صفر وابستگی بازی می‌کند.**

> ✅ **چک کن:** اگر بعد از «ری‌استارت» عددِ لایهٔ دوم صفر ماند و مدل دوباره ۲۵۰ بار اجرا شد، کلیدِ نوشتن و کلیدِ خواندن یکی نیستند. **این شایع‌ترین باگِ `cache` است و هیچ خطایی هم نمی‌دهد** — فقط `cache` ات همیشه خالی می‌ماند و تو فکر می‌کنی داری از آن استفاده می‌کنی. کلید را در هر دو مسیر یک بار چاپ کن و با چشم مقایسه کن.

## ۵. عمرِ ورودی، با ساعتِ مجازی

هیچ جوابی برای همیشه معتبر نیست. `TTL` می‌گوید یک ورودی چند ثانیه پس از ذخیره هنوز قابلِ استفاده است. **آزمایشش با زمانِ واقعی نیم ساعت طول می‌کشد؛ با ساعتِ فصلِ ۴ کسری از ثانیه.**

</div>

```python
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), "ثانیه")
```

```text
 TTL (ثانیه)  نرخِ اصابت   اجرای مدل
           0        0.0%        2000
          60       38.8%        1224
         300       68.2%         637
        1800       85.3%         293
    بی‌نهایت       87.5%         250
کلِ زمانِ مجازیِ ترافیک: 2000 ثانیه
```

<div dir="rtl">

**۳۳ دقیقهٔ ترافیک، در کسری از ثانیه، با عددهایی که هر بار عیناً تکرار می‌شوند.**

جدول یک شکلِ آشنا دارد: **سود در ابتدا تند بالا می‌رود و بعد صاف می‌شود.** از ۶۰ به ۳۰۰ نرخِ اصابت ۳۰ واحد بالا می‌رود؛ از ۱۸۰۰ به بی‌نهایت فقط دو واحد. **پس `TTL` را جایی می‌گذاری که منحنی صاف شده باشد، نه بیشتر** — چون هر ثانیهٔ اضافه فقط ریسکِ کهنگی را زیاد می‌کند و دیگر چیزی نمی‌خرد.

**و `TTL` برابرِ صفر یعنی `cache` ای در کار نیست.** خطِ اولِ جدول برای همین آنجاست: هر تنظیمی باید در برابرِ «اصلاً نباشد» سنجیده شود.

## ۶. باطل‌سازی: ۴۸ جوابِ کهنه، با اطمینانِ کامل

حالا صحنهٔ اصلی. مدل را بازآموزی می‌کنیم — همان کاری که هر تیمی ماهی یک بار می‌کند — و در وسطِ ترافیک نسخهٔ تازه را جایگزین می‌کنیم. **کلیدِ `cache` را دست نمی‌زنیم، چون به‌نظر ربطی ندارد.**

</div>

```python
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']}")
```

```text
کلیدِ بدونِ نسخه :  48 جوابِ کهنه در هزار درخواستِ دوم · اجرای مدل 250
کلیدِ با نسخه   :   0 جوابِ کهنه در هزار درخواستِ دوم · اجرای مدل 377
```

<div dir="rtl">

**۴۸ کاربر از هزار نفر جوابِ مدلی را گرفتند که دیگر مستقر نبود.**

نه خطایی، نه لاگی، نه کندی — **این درخواست‌ها از همه سریع‌تر هم بودند، چون از `cache` آمدند.** و اگر بعدش نتیجه را بسنجی، دقتِ «مدلِ تازه» را پایین‌تر از واقعیت می‌بینی و مدت‌ها دنبالِ باگ در جای اشتباه می‌گردی.

**صفرِ خطِ دوم قطعی است، نه شانسی:** وقتی نسخه بخشی از کلید باشد، هیچ ورودیِ نسخهٔ قبل با کلیدِ نسخهٔ تازه پیدا نمی‌شود. **این تفاوتِ «باطل‌سازی» و «کلیدِ درست» است** — به‌جای اینکه یادت باشد بعد از هر انتشار `cache` را پاک کنی، کلید را طوری بساز که فراموش کردن ممکن نباشد.

**و قیمتش را هم شمرده‌ایم: ۱۲۷ اجرای اضافه.** هر چیزی که وارد کلید شود، `cache` را تکه‌تکه می‌کند؛ پس فقط چیزهایی وارد کلید می‌شوند که **جواب را عوض می‌کنند**: نسخهٔ مدل، نسخهٔ پیش‌پردازش، و هر پارامترِ درخواست که در خروجی اثر دارد.

> 📏 **اندازه بگیر:** **با چه چیزی مقایسه شد؟** با همان ۲۰۰۰ درخواست و همان دو مدل؛ تنها متغیر یک تکه رشته در کلید بود. **روی کدام داده؟** هزار درخواستِ دومِ همان جریان، در هر دو حالت. **با چند `seed`؟** یکی، و جریان با `Random(11)` ساخته شده، پس عددِ ۴۸ روی هر ماشینی همان ۴۸ است. **ولی یک صداقتِ لازم:** این عدد به **میزانِ اختلافِ دو مدل** بستگی دارد، نه به `cache`. اگر مدلِ تازه‌ات تغییرِ بزرگ‌تری داشته باشد، همین باگ صدها جوابِ کهنه می‌سازد. **آنچه قابلِ تعمیم است این است که عدد صفر نیست؛ اندازه‌اش هر بار باید سنجیده شود.**

## ۷. `cache` سرد، و پیش‌محاسبه

هر انتشارِ تازه `cache` را خالی می‌کند. کاربرهای اولِ بعد از انتشار **بدترین تجربه** را دارند، و دقیقاً همان لحظه‌ای است که همه نگاه می‌کنند.

</div>

```python
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}%")
```

```text
cacheِ سرد               : نرخِ اصابت در ۲۰۰ درخواستِ اول 54.0%
با پیش‌محاسبهٔ ۶۰ متنِ داغ : 80.5%
```

<div dir="rtl">

**۶۰ محاسبهٔ قبل از انتشار، بیست‌وشش واحد نرخِ اصابتِ بیشتر در دویست درخواستِ اول.**

این همان ایده‌ای است که در سامانه‌های `embedding` به شکلِ بزرگ‌ترش دیده می‌شود: **`embedding` همهٔ اسناد را یک بار از قبل حساب می‌کنی و ذخیره‌شان می‌کنی**، چون از قبل می‌دانی لازمشان می‌شود و می‌توانی در ساعتِ خلوت حسابشان کنی.

**قاعدهٔ انتخاب ساده است: چیزی را پیش‌محاسبه کن که (۱) از قبل بدانی لازم می‌شود و (۲) خرابیِ کهنگی‌اش کم باشد.** فهرستِ پرتکرارترین سؤال‌های دیروز هر دو شرط را دارد.

> 🔧 **اگر کار نکرد:** اگر `cache` ات پر می‌شود ولی نرخِ اصابت پایین می‌ماند، اولین چیزی که باید ببینی **تعدادِ ورودی‌ها** است. اگر تعداد به تعدادِ درخواست‌ها نزدیک شد، یعنی کلیدت چیزی دارد که هر بار عوض می‌شود — زمان، شناسهٔ درخواست، یا `uuid`. و اگر برنامه با `MemoryError` یا کندیِ ناگهانی مرد، `cache` ات سقف ندارد: **یک `dict` بی‌سقف در تولید یک نشتیِ حافظه است**، و راهِ استانداردش بیرون انداختنِ کم‌استفاده‌ترین ورودی است.

> 🤖 **از دستیارت بپرس:** «`LRU` چیست و چرا تقریباً همیشه به‌عنوان سیاستِ بیرون انداختن انتخاب می‌شود؟» بعد این را بپرس: **«`cache stampede` چیست و چرا وقتی یک ورودیِ داغ منقضی می‌شود، هزار درخواست هم‌زمان به مدل می‌رسند؟»** — جوابش شکلِ دیگری از همان ازدحامی است که در فصلِ ۴ با `jitter` پخشش کردیم.

## واژه‌های تازهٔ این فصل

</div>

| کلمه | تلفظ به حروف فارسی | یعنی چه |
|---|---|---|
| cache | کش | نگه داشتنِ جوابِ محاسبه‌شده برای دفعهٔ بعد |
| hit rate | هیت ریت | نسبتِ درخواست‌هایی که از `cache` جواب گرفتند |
| cache key | کش کی | رشته‌ای که مشخص می‌کند دو درخواست یک سؤالند |
| invalidation | این‌ولیدیشن | بی‌اعتبار کردنِ ورودی‌هایی که دیگر درست نیستند |
| TTL | تی‌تی‌ال | مدتی که یک ورودی معتبر می‌ماند |
| cold cache | کولد کش | `cache` خالی، بلافاصله بعد از راه‌اندازی |
| precompute | پری‌کامپیوت | حساب کردنِ جواب پیش از آنکه کسی بپرسد |

<div dir="rtl">

## تمرین‌ها

قبل از تمرین، بدونِ نگاه به بالا جواب بده: چرا صفرِ «کلیدِ با نسخه» یک نتیجهٔ قطعی است و نه یک اندازه‌گیریِ آماری؟

**تمرینِ اجباری:** به لایهٔ اول یک **سقف** بده: وقتی تعدادِ ورودی‌ها از `MAX` گذشت، کم‌استفاده‌ترین را بیرون بینداز. حالا `MAX` را ۲۵، ۵۰، ۱۰۰ و ۲۵۰ بگذار و **دو عدد** برای هرکدام گزارش کن: نرخِ اصابت و تعدادِ اجرای مدل. **جدولت را نگاه کن و جواب بده: با ۶۰ متنِ داغ، از کدام `MAX` به بعد سود عملاً تمام می‌شود؟** عددت را با ستونِ «متن‌های متمایز» بخشِ ۱ مقایسه کن.

**تمرینِ ستاره‌دار ⭐:** یک `cache` بساز که **جوابِ کم‌اطمینان را ذخیره نکند** — یعنی فقط وقتی می‌نویسد که اطمینانِ مدل از آستانهٔ فصلِ ۱ بیشتر باشد. **سه چیز را اندازه بگیر:** نرخِ اصابت، تعدادِ اجرای مدل، و **دقتِ جواب‌هایی که از `cache` آمدند در برابرِ دقتِ جواب‌هایی که از مدل آمدند.** بعد سؤالِ سخت را جواب بده: **اگر دقتِ جواب‌های `cache` بالاتر درآمد، این یعنی `cache` مفید بوده یا یعنی اندازه‌گیریت سوگیری دارد؟** — جوابت باید به این برسد که کدام سؤال‌ها اصلاً وارد `cache` شده‌اند.

## در فصل بعد

حالا سرویسی داری که ارزان و پایدار جواب می‌دهد. فصلِ بعد سخت‌ترین سؤالِ ترم را می‌پرسد: **مدلِ تازه را چطور منتشر می‌کنی؟** دو نسخه داریم که نسخهٔ تازه‌شان روی کلِ ترافیک **بهتر** است ولی روی یک زیرگروهِ شش‌درصدی از ۹۳ درصد به ۴۱ درصد سقوط می‌کند. سه استراتژیِ انتشار را روی هر دو اجرا می‌کنیم و می‌شماریم **کدام‌یک این سقوط را می‌گیرد و کدام با خیالِ راحت تأییدش می‌کند.**

</div>

---
Source: https://yaadestan.com/courses/darbast/lessons/t4/s05-caching (یادستان, Yaadestan)
