داربست — خودآموز MLOps و مهندسی سامانه‌های هوش مصنوعی (پیشرفته)

فصل ۵ از ۹

پیشرفت ترم
۰٪

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

۲۰۰۰ درخواستِ واقع‌نما به سرویس می‌دهیم و می‌بینیم فقط ۲۸۴ متنِ متمایز دارند. یک 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 پری‌کامپیوت حساب کردنِ جواب پیش از آنکه کسی بپرسد

تمرین‌ها

اول خودت فکر کن یا امتحان کن — بعد اینجا را باز کن.

در فصل بعد#

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

به آخر این فصل رسیدی!

اگر ساختی و جواب داد، این دکمه مال توست.