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

فصل ۴ از ۹

پیشرفت ترم
۰٪

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

۲۰۰ کار را به یک صف می‌دهیم و سرویسِ پایین‌دستی سی درصدِ مواقع جواب نمی‌دهد. بدونِ تلاشِ دوباره ۵۷ کار می‌میرد؛ با حداکثر سه تلاش، ۶ تا.

بعد قیمتش را می‌بینیم: همان تلاشِ دوباره برای ۲۰۰ کار ۲۷۳ ردیف در پایگاه داده می‌نویسد. یک ستونِ کلیدِ اصلی اضافه می‌کنیم و عدد دقیقاً ۲۰۰ می‌شود — بدونِ اینکه حتی یک تلاش کم شود.

و اول از همه ساعتِ مجازی را می‌نویسیم: بیست خط کد که باعث می‌شود آزمایشی با ۲۸ ثانیه انتظار، در صفر ثانیه و با همان عددها اجرا شود. تا آخرِ ترم همراهمان است.

ماشینی که کارت‌های نپذیرفته را به یک ریلِ کناری می‌فرستد

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

  • ساعتِ مجازی بنویسی و رفتارِ زمان‌دار را قطعی و تکرارپذیر آزمایش کنی
  • صفی با تلاشِ دوباره و صفِ نامه‌های مرده بسازی
  • کارِ یکسان‌توان را از غیریکسان‌توان تشخیص بدهی و با شمارش ثابتش کنی
  • بگویی عقب‌نشینیِ نمایی و jitter دقیقاً چه چیزی را می‌خرند

قبل از شروع#

از فصلِ ۲: مهلتِ زمانی و اینکه سرور بعد از رفتنِ کلاینت هم کار را تمام می‌کند. همان‌جا دیدیم بعضی کارها در قالبِ «درخواست و پاسخ» جا نمی‌شوند.

از ترمِ ۲ فصلِ ۱: «هم‌توانی» را آنجا برای مسیرِ داده دیدی: اجرای دوباره نباید وضعیت را عوض کند. اینجا همان ایده به یک کارِ تکی می‌رسد و اسمش «یکسان‌توانی» است — و این بار کسی که اجرای دوباره را راه می‌اندازد خودِ سامانه است، نه تو.

📓 نوت‌بوک: نوت‌بوک این فصل را در Colab باز کن — همهٔ کدهای این فصل آماده و به‌ترتیب داخلش هست.

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

۱. ساعتِ مجازی#

از این فصل به بعد مرتب با زمان کار داریم: مهلتِ تلاشِ دوباره، عمرِ cache، پنجرهٔ انتشار، مهلتِ قطع‌کنندهٔ مدار. اگر این‌ها را با time.sleep امتحان کنیم، دو چیزِ بد اتفاق می‌افتد: آزمایش کند می‌شود، و نتیجه‌اش به سرعتِ ماشین بستگی پیدا می‌کند.

راهِ حل ساده است: زمان را از سیستم نخوان، خودت نگهش دار.

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

    def jump_to(self, moment):
        self.t = max(self.t, moment)         # ساعت هرگز عقب نمی‌رود
        return self.t


clock = Clock()
deadline = clock.now() + 300
print("الان         :", clock.now())
print("منقضی شده؟   :", clock.now() > deadline)
clock.advance(301)
print("بعد از ۳۰۱ ثانیه:", clock.now(), "· منقضی شده؟", clock.now() > deadline)
الان         : 0.0
منقضی شده؟   : False
بعد از ۳۰۱ ثانیه: 301.0 · منقضی شده؟ True

پنج دقیقه گذشت و صفر ثانیه صبر کردیم.

و مهم‌تر از سرعت: نتیجه قطعی است. در ژرفا ترمِ ۶ فصلِ ۶ یک عدد بود که هر بار فرق می‌کرد و همان‌جا صادقانه نوشته شد که قابلِ تکرار نیست، چون به زمان‌بندیِ نخ‌ها بستگی داشت. ساعتِ مجازی دقیقاً همان مشکل را از ریشه حل می‌کند: وقتی زمان یک عددِ توی برنامه باشد، هیچ چیزی برای «شانس آوردن» باقی نمی‌ماند.

قاعده‌ای که از این به بعد رعایتش می‌کنیم: هیچ جای کدِ سامانه مستقیم time.time() را صدا نمی‌زند. همه از یک ساعت می‌پرسند، و در تولید آن ساعت زمانِ واقعی را برمی‌گرداند.

۲. کار، صف، و شکستی که قابلِ تکرار است#

import queue
import random
import sqlite3

model = fit_model(TRAIN[:800])
JOBS = [{"job_id": r["ticket_id"], "text": r["text"]} for r in TEST[:200]]
FAIL_RATE = 0.30


def downstream_fails(job_id, attempt):
    """شکستِ ساختگی ولی قطعی: هر جفتِ (کار، تلاش) قرعهٔ خودش را دارد."""
    return random.Random(f"{job_id}:{attempt}").random() < FAIL_RATE


DB = sqlite3.connect(str(WORK / "jobs.db"))
DB.execute("CREATE TABLE naive  (job_id TEXT, label TEXT)")
DB.execute("CREATE TABLE strict (job_id TEXT PRIMARY KEY, label TEXT)")
DB.execute("CREATE TABLE safe   (job_id TEXT PRIMARY KEY, label TEXT)")


def label_of(job):
    return model.predict([normalise(job["text"])])[0]


def insert_naive(job):
    DB.execute("INSERT INTO naive VALUES (?, ?)", (job["job_id"], label_of(job)))


def insert_safe(job):
    DB.execute("INSERT OR IGNORE INTO safe VALUES (?, ?)", (job["job_id"], label_of(job)))


def rows(table):
    return DB.execute(f"SELECT COUNT(*) FROM {table}").fetchone()[0]


work = queue.PriorityQueue()
for i, job in enumerate(JOBS):
    work.put((0.0, i, job, 1))
print("اندازهٔ صف:", work.qsize())
ready_at, _, first, attempt = work.get_nowait()
print("اولین کار:", first["job_id"], "· آمادهٔ اجرا در:", ready_at, "· تلاش:", attempt)
اندازهٔ صف: 200
اولین کار: TK-00062 · آمادهٔ اجرا در: 0.0 · تلاش: 1

PriorityQueue را انتخاب کردیم چون هر کار یک زمانِ آمادگی دارد و باید همیشه زودترینش را برداریم. عضوِ صف یک چهارتایی است: زمانِ آمادگی، یک شمارهٔ ترتیبی برای شکستنِ تساوی، خودِ کار، و شمارهٔ تلاش.

و downstream_fails نکتهٔ ظریفِ این فصل است. به‌جای یک random مشترک، برای هر جفتِ (کار، تلاش) یک قرعهٔ مستقل می‌ریزیم که فقط به نامِ آن جفت بستگی دارد. پس دو آزمایشِ متفاوت دقیقاً همان شکست‌ها را می‌بینند و مقایسه‌شان صادقانه است.

۳. زمان‌بند: صف، ساعت، و هیچ نخی#

def run_queue(insert, max_attempts=1, backoff=lambda attempt, job_id: 5.0):
    clock = Clock()
    work = queue.PriorityQueue()
    for i, job in enumerate(JOBS):
        work.put((0.0, i, job, 1))
    seq, done, dead, moments = len(JOBS), 0, [], []
    while True:
        try:
            ready_at, _, job, attempt = work.get_nowait()
        except queue.Empty:
            break
        clock.jump_to(ready_at)
        moments.append(clock.now())
        insert(job)                                   # عوارضِ جانبی، قبل از قدمی که می‌شکند
        if not downstream_fails(job["job_id"], attempt):
            done += 1
        elif attempt >= max_attempts:
            dead.append({"job_id": job["job_id"], "attempts": attempt})
        else:
            seq += 1
            work.put((clock.now() + backoff(attempt, job["job_id"]), seq, job, attempt + 1))
    return {"done": done, "dead": dead, "attempts": len(moments),
            "elapsed": clock.now(), "moments": moments}


DB.execute("DELETE FROM naive")
once = run_queue(insert_naive, max_attempts=1)
naive_once = rows("naive")

DB.execute("DELETE FROM naive")
thrice = run_queue(insert_naive, max_attempts=3)
naive_thrice = rows("naive")

print(f"بدونِ تلاشِ دوباره: {once['attempts']:>3} تلاش · {once['done']:>3} موفق"
      f" · {len(once['dead']):>2} شکست‌خورده")
print(f"با تا سه تلاش    : {thrice['attempts']:>3} تلاش · {thrice['done']:>3} موفق"
      f" · {len(thrice['dead']):>2} در صفِ نامه‌های مرده")
بدونِ تلاشِ دوباره: 200 تلاش · 143 موفق · 57 شکست‌خورده
با تا سه تلاش    : 273 تلاش · 194 موفق ·  6 در صفِ نامه‌های مرده

۵۷ کارِ ازدست‌رفته به ۶ رسید، با ۷۳ تلاشِ اضافه.

ریاضی‌اش هم شهودی است: هر تلاش با احتمالِ ۰٫۳ می‌شکند، پس شکستنِ سه تلاشِ پشتِ سرِ هم احتمالش ۰٫۳ به توانِ ۳ است، یعنی حدودِ ۲٫۷ صدم. ۶ از ۲۰۰ دقیقاً همان‌جاست.

دو جملهٔ صادقانه دربارهٔ همین عدد: اول اینکه تلاشِ دوباره فقط برای خطای گذرا جواب می‌دهد؛ اگر ورودی خراب باشد، هزار تلاش هم همان خطا را می‌دهد و فقط سرویس را اذیت می‌کند. دوم اینکه در تولید، تلاشِ دوباره را روی کدِ ۵۰۰ می‌زنی و روی ۴۰۰ هرگز — همان تفاوتی که در فصلِ قبل قرارداد اعلامش کرد.

🔧 اگر کار نکرد: اگر حلقه با queue.Empty نشکند و تا ابد بچرخد، شرطِ attempt >= max_attempts را جا انداخته‌ای و کارها بی‌نهایت بار به صف برمی‌گردند. پیامی که موقعِ درست‌کاری می‌بینی این است: queue.Empty بدونِ هیچ متنی — این استثنا پیام ندارد و همین گیج‌کننده است. ما به‌عمد از get_nowait() استفاده کردیم تا خالی شدنِ صف همان لحظه معلوم شود؛ get() معمولی تا ابد منتظر می‌ماند و نوت‌بوکت قفل می‌کند.

۴. قیمتِ پنهانِ تلاشِ دوباره#

حالا به همان دو اجرا از زاویهٔ دیگری نگاه کنیم: به پایگاه داده.

print("کارها                        :", len(JOBS))
print("ردیف‌ها، بدونِ تلاشِ دوباره   :", naive_once)
print("ردیف‌ها، با تا سه تلاش       :", naive_thrice)
print("ردیف‌های اضافه               :", naive_thrice - len(JOBS))
کارها                        : 200
ردیف‌ها، بدونِ تلاشِ دوباره   : 200
ردیف‌ها، با تا سه تلاش       : 273
ردیف‌های اضافه               : 73

دویست کار، دویست و هفتاد و سه ردیف.

ترتیبِ کار در run_queue عمداً همان ترتیبِ دنیای واقعی است: اول عوارضِ جانبی، بعد قدمی که ممکن است بشکند. ردیف نوشته می‌شود، بعد اعلان به سرویسِ پایین‌دستی می‌رود و آن است که جواب نمی‌دهد. صف خبر ندارد که نصفِ کار انجام شده؛ فقط می‌بیند کار شکست خورده و از اول اجرایش می‌کند.

اگر این «ردیف» به‌جای یک برچسب، یک پیامک یا یک برداشت از حساب بود، ۵۷ نفر دست‌کم دو بار پیام می‌گرفتند و ۱۶ نفرشان سه بار. و هیچ خطایی هم در هیچ سیاهه‌ای نبود.

۵. یکسان‌توانی: کلیدی که تکرار را بی‌اثر می‌کند#

راهِ حل این نیست که تلاشِ دوباره را برداریم — دیدیم چقدر ارزش دارد. راهِ حل این است که کار را طوری بنویسیم که اجرای دومش هیچ چیزِ تازه‌ای نسازد. به هر کار یک کلید می‌دهیم و پایگاه داده را وادار می‌کنیم آن کلید را یکتا نگه دارد.

DB.execute("INSERT INTO strict VALUES (?, ?)", ("TK-00001", "پرداخت"))
try:
    DB.execute("INSERT INTO strict VALUES (?, ?)", ("TK-00001", "پرداخت"))
except sqlite3.IntegrityError as exc:
    print("sqlite3.IntegrityError:", exc)
sqlite3.IntegrityError: UNIQUE constraint failed: strict.job_id

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

DB.execute("DELETE FROM safe")
safe_run = run_queue(insert_safe, max_attempts=3)
print(f"تلاش‌ها: {safe_run['attempts']} · ردیف‌های جدولِ یکسان‌توان: {rows('safe')}")
print("هر کار دقیقاً یک ردیف دارد؟",
      DB.execute("SELECT COUNT(DISTINCT job_id) FROM safe").fetchone()[0] == rows("safe"))
تلاش‌ها: 273 · ردیف‌های جدولِ یکسان‌توان: 200
هر کار دقیقاً یک ردیف دارد؟ True

همان ۲۷۳ تلاش، همان شکست‌ها، همان تلاش‌های دوباره — و دقیقاً ۲۰۰ ردیف.

تفاوت فقط دو چیز است: یک ستونِ PRIMARY KEY و یک OR IGNORE. کلیدِ یکسان‌توانی هرچیزی می‌تواند باشد به شرطی که به خودِ کار وابسته باشد، نه به لحظهٔ اجرا: شناسهٔ تیکت خوب است، شناسه‌ای که موقعِ ارسال ساخته می‌شود عالی است، و uuid4() که در هر تلاش از نو ساخته شود دقیقاً همان باگی است که می‌خواستیم از آن فرار کنیم.

✅ چک کن: به هر کارِ ناهم‌زمانِ خودت این سؤال را بزن: «اگر این کار دقیقاً دو بار اجرا شود، از بیرون چه تفاوتی دیده می‌شود؟» اگر جوابت «هیچ» است، یکسان‌توان است. اگر جوابت «دو ایمیل، دو ردیف، دو برداشت» است، کلید ندارد — و روزی که صف شلوغ شود، حتماً دو بار اجرا می‌شود.

📏 اندازه بگیر: با چه چیزی مقایسه شد؟ با همان صف، همان ۲۰۰ کار و همان ۲۷۳ تلاش؛ تنها متغیر تعریفِ جدول بود. روی کدام داده؟ دویست تیکتِ اولِ مجموعهٔ آزمون، یکسان در همهٔ اجراها. با چند seed؟ یکی — و اینجا seed اصلاً تصادفی نیست: downstream_fails قرعه‌اش را از نامِ کار می‌سازد، پس روی هر ماشینی، در هر اجرا، دقیقاً همان ۵۷ کار شکست می‌خورند. این تفاوتِ «تصادفی» و «تکرارناپذیر» است.

۶. صفِ نامه‌های مرده#

شش کار حتی با سه تلاش هم موفق نشدند. اگر جایی برای رفتن نداشته باشند، بی‌سروصدا ناپدید می‌شوند — و بدترین حالت این است که هیچ‌کس نداند شش تیکت هرگز پردازش نشد.

print("کارهای مرده:", len(thrice["dead"]))
for item in thrice["dead"]:
    print("  ", item["job_id"], "· تلاش‌ها:", item["attempts"],
          "· قرعه‌ها:", [round(random.Random(f"{item['job_id']}:{a}").random(), 3)
                        for a in (1, 2, 3)])
کارهای مرده: 6
   TK-00499 · تلاش‌ها: 3 · قرعه‌ها: [0.142, 0.161, 0.059]
   TK-00404 · تلاش‌ها: 3 · قرعه‌ها: [0.065, 0.241, 0.143]
   TK-01091 · تلاش‌ها: 3 · قرعه‌ها: [0.022, 0.176, 0.206]
   TK-00101 · تلاش‌ها: 3 · قرعه‌ها: [0.087, 0.298, 0.162]
   TK-00206 · تلاش‌ها: 3 · قرعه‌ها: [0.145, 0.048, 0.143]
   TK-00175 · تلاش‌ها: 3 · قرعه‌ها: [0.123, 0.16, 0.102]

هر شش‌تا هر سه قرعه‌شان زیرِ ۰٫۳ افتاده — یعنی واقعاً بدشانس بوده‌اند، نه اینکه باگی در کد باشد. صفِ نامه‌های مرده باید همین را نگه دارد: نه فقط کار، بلکه شواهدِ اینکه چرا مرد.

سه قاعدهٔ عملی برای این صف: تعدادش را پایش کن (رشدِ ناگهانی یعنی خرابیِ بالادستی)، قابلِ اجرای دوباره نگهش دار (بعد از رفعِ مشکل باید بشود همه را برگرداند)، و اگر کارها یکسان‌توان باشند این اجرای دوباره بی‌خطر است. اینجا همهٔ تکه‌های فصل به هم می‌رسند.

۷. عقب‌نشینی و jitter، با عدد#

تا حالا هر تلاشِ دوباره را ۵ ثانیه بعد گذاشتیم. نتیجه‌اش این است که هر ۵۷ کارِ شکست‌خورده دقیقاً در یک لحظه برمی‌گردند — درست وقتی سرویسِ پایین‌دستی هنوز حالش خوب نیست.

def busiest_second(moments, width=1.0):
    counts = {}
    for t in moments:
        bucket = int(t // width)
        counts[bucket] = counts.get(bucket, 0) + 1
    return max(counts.values())


def with_jitter(attempt, job_id):
    base = 5.0 * (2 ** (attempt - 1))                 # ۵ ثانیه، ۱۰ ثانیه، ...
    return base * (1 + random.Random(f"jitter:{job_id}:{attempt}").random())


DB.execute("DELETE FROM safe")
flat = run_queue(insert_safe, max_attempts=3)
DB.execute("DELETE FROM safe")
spread = run_queue(insert_safe, max_attempts=3, backoff=with_jitter)

for name, run in (("ثابت، بدونِ jitter", flat), ("نمایی، با jitter ", spread)):
    later = [t for t in run["moments"] if t > 0]
    print(f"{name}: زمانِ مجازیِ کل {run['elapsed']:>6.1f} ثانیه"
          f" · شلوغ‌ترین ثانیهٔ تلاشِ دوباره {busiest_second(later):>3}")
ثابت، بدونِ jitter: زمانِ مجازیِ کل   10.0 ثانیه · شلوغ‌ترین ثانیهٔ تلاشِ دوباره  57
نمایی، با jitter : زمانِ مجازیِ کل   28.3 ثانیه · شلوغ‌ترین ثانیهٔ تلاشِ دوباره  17

اوجِ بار از ۵۷ به ۱۷ رسید — و کلِ کار به‌جای ۱۰ ثانیه، ۲۸ ثانیه طول کشید.

این یک معامله است، نه یک بهبودِ رایگان: عقب‌نشینیِ نمایی و jitter گذردهی را نمی‌خرند، فشارِ لحظه‌ایِ روی سرویسِ بیمار را می‌خرند. اگر سرویسِ پایین‌دستی به‌خاطرِ بار افتاده باشد، برگرداندنِ ۵۷ درخواست در یک ثانیه دقیقاً همان کاری است که دوباره زمینش می‌زند.

🌱 ریشه‌اش کجاست: آن 5.0 * (2 ** (attempt - 1)) همان تابعِ ریشه، ترم ۴ فصل ۷ — رشدِ نمایی، و چرا شهود شکست می‌خورد است، و همان فصل هشدارش را هم می‌دهد: «در رشدِ نمایی هیچ درصدی کوچک نیست؛ فقط زمان لازم دارد.» اینجا این خاصیت به نفعِ ماست — پنجم و ششمِ تلاش‌ها آن‌قدر عقب می‌افتند که دیگر ازدحامی نمی‌سازند — ولی همان خاصیت دامِ خودش را هم دارد: با سقفِ تلاشِ بالا، آخرین تلاش می‌تواند ساعت‌ها بعد بیفتد. به همین دلیل در تولید کنارِ عقب‌نشینیِ نمایی همیشه یک سقفِ زمانی می‌گذارند، نه فقط سقفِ تعداد.

و توجه کن که ۲۸٫۳ ثانیه یک عددِ واقعی است، نه تخمین — همهٔ این آزمایش در کسری از ثانیه اجرا شد، چون تنها ساعتی که در کار بود ساعتِ خودمان بود.

🤖 از دستیارت بپرس: «تفاوتِ at-least-once و exactly-once در سامانه‌های صف چیست و چرا exactly-once واقعی تقریباً همیشه یک ادعاست؟» جوابِ درست به «تحویلِ حداقل یک بار، پردازشِ یکسان‌توان» می‌رسد. بعد این را بپرس: «اگر عوارضِ جانبیِ کارِ من ارسالِ ایمیل باشد و پایگاه داده نداشته باشم، کلیدِ یکسان‌توانی را کجا نگه دارم؟»

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

کلمه تلفظ به حروف فارسی یعنی چه
virtual clock ویرچوال کلاک ساعتی داخلِ برنامه که خودت جلویش می‌بری
worker ورکر جزئی که کارها را از صف برمی‌دارد و انجام می‌دهد
retry ری‌ترای اجرای دوبارهٔ کاری که شکست خورده
idempotent آیدم‌پوتنت کاری که اجرای دوباره‌اش هیچ اثرِ تازه‌ای نمی‌گذارد
idempotency key آیدم‌پوتنسی کی شناسه‌ای که دو اجرای یک کار را یکی می‌کند
dead letter queue دِد لِتِر کیو جایی که کارِ چندبار شکست‌خورده می‌رود تا گم نشود
exponential backoff اکسپوننشال بک‌آف دو برابر شدنِ فاصلهٔ تلاش‌های پیاپی
jitter جیتر پراکندنِ تصادفیِ زمانِ تلاش‌ها تا با هم برنگردند

تمرین‌ها

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

در فصل بعد#

صف بارِ سنگین را از سرِ راهِ کاربر برداشت. فصلِ بعد سراغِ بارِ سبک ولی تکراری می‌رود: cache. نرخِ اصابت را اندازه می‌گیریم، و بعد گران‌ترین اشتباهِ این حوزه را نشان می‌دهیم — یک cache که بعد از عوض شدنِ نسخهٔ مدل، ۴۸ جواب از هر هزار درخواست را با مدلِ بازنشسته و با اطمینانِ کامل تحویل می‌دهد.

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

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