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

فصل ۷ از ۹

پیشرفت ترم
۰٪

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

وسطِ ۶۰۰ درخواست، سرویسِ مدل می‌میرد و سیصد ثانیه بعد برمی‌گردد. بدونِ هیچ تدبیری ۳۰۰ درخواست شکست می‌خورند و سرویس ۲۰۶ ثانیه از ترافیک عقب می‌افتد.

بعد دو چیز اضافه می‌کنیم که هرکدام مسئلهٔ متفاوتی را حل می‌کنند. مسیرِ پشتیبان شکست‌ها را صفر می‌کند ولی انتظار را یک ثانیه هم کم نمی‌کند: ۶۱۵ ثانیه، همان‌طور که بود. قطع‌کنندهٔ مدار همان انتظار را به ۴۱٫۹ ثانیه می‌رساند و عقب‌افتادگی را به صفر.

مداری با فیوز و یک مسیرِ کنارگذر

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

  • مسیرِ پشتیبان بسازی و دقتش را اندازه بگیری، نه اینکه فقط داشته باشی‌اش
  • قطع‌کنندهٔ مدار با سه حالت بنویسی و بگویی هرکدام چه چیزی را می‌خرد
  • تفاوتِ «نرخِ خطا» و «عقب‌افتادگی» را با عدد نشان بدهی
  • «بدترین حالتِ قابلِ‌قبول» را قبل از حادثه تعریف کنی، نه وسطش

قبل از شروع#

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

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

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

۱. مسیرِ پشتیبان، و عددی که باید بدانی#

وقتی مدل در دسترس نیست، سه جواب ممکن است: خطا بده، جوابِ بدترِ ارزان بده، یا جوابِ کهنه از cache بده. اینجا دومی را می‌سازیم: یک جدولِ کلمه که در حافظهٔ خودِ سرویس است و به هیچ شبکه‌ای نیاز ندارد.

import random
from collections import Counter, defaultdict

model = fit_model(TRAIN[:800])
STREAM = random.Random(5).choices(TEST, k=600)
MODEL_SAYS = dict(zip([r["ticket_id"] for r in TEST],
                      model.predict([normalise(r["text"]) for r in TEST])))
TRUTH = {r["ticket_id"]: r["category"] for r in TEST}

votes = defaultdict(Counter)
for row in TRAIN[:800]:
    for word in sorted(set(normalise(row["text"]).split())):
        votes[word][row["category"]] += 1
WORD_OWNER = {w: c.most_common(1)[0][0] for w, c in sorted(votes.items())
              if sum(c.values()) >= 3}
DEFAULT = Counter(r["category"] for r in TRAIN[:800]).most_common(1)[0][0]


def rule_predict(text):
    """مسیرِ پشتیبان: یک جدولِ کلمه، بدونِ مدل و بدونِ شبکه."""
    seen = Counter(WORD_OWNER[w] for w in sorted(set(normalise(text).split()))
                   if w in WORD_OWNER)
    return seen.most_common(1)[0][0] if seen else DEFAULT


def accuracy(rows, fn):
    return sum(fn(r) == TRUTH[r["ticket_id"]] for r in rows) / len(rows)


print("اندازهٔ جدولِ کلمه:", len(WORD_OWNER))
print(f"دقتِ مدل روی جریان     : {accuracy(STREAM, lambda r: MODEL_SAYS[r['ticket_id']]):.4f}")
print(f"دقتِ مسیرِ پشتیبان      : {accuracy(STREAM, lambda r: rule_predict(r['text'])):.4f}")
print(f"دقتِ حدسِ همیشه‌یکسان    : {accuracy(STREAM, lambda r: DEFAULT):.4f}")
اندازهٔ جدولِ کلمه: 269
دقتِ مدل روی جریان     : 0.8533
دقتِ مسیرِ پشتیبان      : 0.8200
دقتِ حدسِ همیشه‌یکسان    : 0.2717

سه عدد، و عددِ وسط دو خبر با هم دارد.

خبرِ اول: مسیرِ پشتیبان کار می‌کند — سه واحد بدتر از مدل و پنجاه‌وپنج واحد بهتر از حدس زدن. این یعنی در روزِ بد سرویس هنوز مفید است.

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

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

۲. قطع‌کنندهٔ مدار، در سه حالت#

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


class Breaker:
    """بسته: همه‌چیز عادی. باز: اصلاً تماس نگیر. نیمه‌باز: فقط یک تماسِ آزمایشی."""

    def __init__(self, clock, threshold=5, cooldown=30.0):
        self.clock, self.threshold, self.cooldown = clock, threshold, cooldown
        self.state, self.failures, self.opened_at = "بسته", 0, 0.0
        self.probes = 0

    def allow(self):
        if self.state == "بسته":
            return True
        if self.clock.now() - self.opened_at >= self.cooldown:
            self.state = "نیمه‌باز"
            self.probes += 1
            return True
        return False

    def record(self, ok):
        if ok:
            self.state, self.failures = "بسته", 0
        else:
            self.failures += 1
            if self.state == "نیمه‌باز" or self.failures >= self.threshold:
                self.state, self.opened_at = "باز", self.clock.now()


demo_clock = Clock()
demo = Breaker(demo_clock)
for step in range(8):
    allowed = demo.allow()
    print(f"گام {step}: حالت={demo.state:<8} تماس مجاز؟ {str(allowed):<5}", end="")
    if allowed:
        demo.record(False)                          # هر تماس شکست می‌خورد
    print(" → حالت پس از تماس:", demo.state)
    demo_clock.advance(10.0)
گام 0: حالت=بسته     تماس مجاز؟ True  → حالت پس از تماس: بسته
گام 1: حالت=بسته     تماس مجاز؟ True  → حالت پس از تماس: بسته
گام 2: حالت=بسته     تماس مجاز؟ True  → حالت پس از تماس: بسته
گام 3: حالت=بسته     تماس مجاز؟ True  → حالت پس از تماس: بسته
گام 4: حالت=بسته     تماس مجاز؟ True  → حالت پس از تماس: باز
گام 5: حالت=باز      تماس مجاز؟ False → حالت پس از تماس: باز
گام 6: حالت=باز      تماس مجاز؟ False → حالت پس از تماس: باز
گام 7: حالت=نیمه‌باز تماس مجاز؟ True  → حالت پس از تماس: باز

سه حالت، و هرکدام یک تصمیم:

  • بسته — همه‌چیز عادی است، تماس بگیر. شکست‌های پیاپی شمرده می‌شوند.
  • باز — سرویس مریض است، اصلاً تماس نگیر. هر تماس فقط دو ثانیه هدر می‌دهد و به سرویسی که دارد بلند می‌شود دوباره فشار می‌آورد.
  • نیمه‌باز — بعد از یک مهلت، دقیقاً یک تماسِ آزمایشی. موفق شد؟ برگرد به بسته. شکست خورد؟ برگرد به باز و مهلت را از نو بشمار.

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

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

۳. سه حالت، یک قطعی#

حالا قطعیِ واقعی: از درخواستِ ۲۰۰ تا ۵۰۰ سرویسِ مدل جواب نمی‌دهد و هر تماس دو ثانیه طول می‌کشد تا با مهلت تمام شود.

DOWN = range(200, 500)
TIMEOUT, FAST, CHEAP = 2.0, 0.05, 0.001


def run(use_fallback, use_breaker, half_open=True):
    clock = Clock()
    breaker = Breaker(clock)
    if not half_open:
        breaker.cooldown = float("inf")
    served = failed = degraded = late = right = 0
    wait = 0.0
    for i, row in enumerate(STREAM):
        clock.jump_to(i * 1.0)                      # یک درخواست در هر ثانیه می‌رسد
        answer = None
        if not use_breaker or breaker.allow():
            if i in DOWN:
                clock.advance(TIMEOUT)
                wait += TIMEOUT
                if use_breaker:
                    breaker.record(False)
            else:
                clock.advance(FAST)
                wait += FAST
                answer = MODEL_SAYS[row["ticket_id"]]
                if use_breaker:
                    breaker.record(True)
        if answer is None:
            if not use_fallback:
                failed += 1
                continue
            clock.advance(CHEAP)
            wait += CHEAP
            answer = rule_predict(row["text"])
            degraded += 1
            if i >= DOWN.stop:
                late += 1
        served += 1
        right += answer == TRUTH[row["ticket_id"]]
    return {"served": served, "failed": failed, "degraded": degraded, "late": late,
            "wait": wait, "end": clock.now(), "acc": right / max(served, 1),
            "probes": breaker.probes}


plain = run(use_fallback=False, use_breaker=False)
fb = run(use_fallback=True, use_breaker=False)
both = run(use_fallback=True, use_breaker=True)
print(f"{'حالت':<26}{'سرو':>6}{'شکست':>7}{'پشتیبان':>9}{'انتظار':>10}{'دقت':>9}")
for name, r in (("بدونِ پشتیبان و قطع‌کننده", plain),
                ("فقط مسیرِ پشتیبان", fb),
                ("پشتیبان + قطع‌کنندهٔ مدار", both)):
    print(f"{name:<26}{r['served']:>6}{r['failed']:>7}{r['degraded']:>9}"
          f"{r['wait']:>9.1f}s{r['acc']:>9.4f}")
حالت                         سرو   شکست  پشتیبان    انتظار      دقت
بدونِ پشتیبان و قطع‌کننده    300    300        0    615.0s   0.8133
فقط مسیرِ پشتیبان            600      0      300    615.3s   0.8283
پشتیبان + قطع‌کنندهٔ مدار    600      0      329     41.9s   0.8200

دو ابزار، دو مسئلهٔ کاملاً متفاوت — و این مهم‌ترین جدولِ فصل است.

مسیرِ پشتیبان شکست را حل می‌کند: ۳۰۰ شکست به صفر رسید و همهٔ ۶۰۰ درخواست جواب گرفتند. ولی به ستونِ «انتظار» نگاه کن: ۶۱۵٫۳ ثانیه، تقریباً همان ۶۱۵ ثانیهٔ حالتِ اول. چون هر درخواست اول دو ثانیه منتظرِ مدلِ مرده می‌ماند و بعد سراغِ پشتیبان می‌رود.

قطع‌کننده انتظار را حل می‌کند: ۴۱٫۹ ثانیه به‌جای ۶۱۵. چون بعد از پنج شکستِ اول دیگر اصلاً تماس نمی‌گیرد و مستقیم می‌رود سراغِ پشتیبان.

و هیچ‌کدام جای دیگری را نمی‌گیرد. قطع‌کننده بدونِ پشتیبان فقط سریع‌تر خطا می‌دهد؛ پشتیبان بدونِ قطع‌کننده جوابِ درست می‌دهد ولی سرویس را همان‌قدر کند نگه می‌دارد.

✅ چک کن: ستونِ «پشتیبان» در ردیفِ سوم ۳۲۹ است، نه ۳۰۰. بیست‌ونه درخواستِ اضافه بعد از بهبودِ سرویس با مسیرِ پشتیبان جواب گرفتند — چون قطع‌کننده هنوز باز بود و خبر نداشت که مدل برگشته. قیمتِ ندانستن، همیشه در همین ستون پیدا می‌شود؛ بخشِ ۵ دقیقاً دربارهٔ همین است.

۴. عقب‌افتادگی: عددی که در نرخِ خطا دیده نمی‌شود#

print(f"آخرین درخواست در ثانیهٔ {len(STREAM) - 1} رسید.")
print(f"  بدونِ قطع‌کننده: سرویس در ثانیهٔ {plain['end']:.0f} کارش تمام شد"
      f" — {plain['end'] - (len(STREAM) - 1):.0f} ثانیه عقب")
print(f"  با قطع‌کننده  : سرویس در ثانیهٔ {both['end']:.0f} کارش تمام شد"
      f" — {both['end'] - (len(STREAM) - 1):.0f} ثانیه عقب")
print("  تماس‌های آزمایشیِ قطع‌کننده:", both["probes"])
آخرین درخواست در ثانیهٔ 599 رسید.
  بدونِ قطع‌کننده: سرویس در ثانیهٔ 805 کارش تمام شد — 206 ثانیه عقب
  با قطع‌کننده  : سرویس در ثانیهٔ 599 کارش تمام شد — 0 ثانیه عقب
  تماس‌های آزمایشیِ قطع‌کننده: 10

۲۰۶ ثانیه عقب، در برابرِ صفر.

درخواست‌ها هر ثانیه یکی می‌رسند و هرکدام دو ثانیه طول می‌کشد. هر ثانیه یک ثانیه عقب‌تر می‌افتی، و این عقب‌افتادگی تا مدت‌ها بعد از پایانِ قطعی ادامه دارد.

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

و ده تماسِ آزمایشی، کلِ چیزی است که قطع‌کننده در سیصد ثانیه قطعی خرج کرد — به‌جای سیصد تماسِ بی‌فایده.

📏 اندازه بگیر: با چه چیزی مقایسه شد؟ با همان ۶۰۰ درخواست، همان قطعی و همان مدل؛ تنها متغیر داشتن یا نداشتنِ پشتیبان و قطع‌کننده بود. روی کدام داده؟ یک جریانِ یکسان، ساخته‌شده با Random(5). با چند seed؟ یکی، و اینجا seed فقط جریان را می‌سازد، نه نتیجه را: قطعی در بازهٔ ثابتِ ۲۰۰ تا ۵۰۰ است و ساعت مجازی است، پس ۶۱۵٫۰ و ۴۱٫۹ روی هر ماشینی همان عددهایند. اگر با time.sleep نوشته بودیمش، همین آزمایش ده دقیقه طول می‌کشید و هیچ‌کدام از عددها تکرارپذیر نبود.

۵. نیمه‌باز: چطور بفهمی سرویس برگشته#

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

stuck = run(use_fallback=True, use_breaker=True, half_open=False)
print("بعد از بهبودِ سرویس در درخواستِ", DOWN.stop, ":")
print("  با نیمه‌باز  : درخواست‌هایی که هنوز پشتیبان گرفتند:", both["late"])
print("  بدونِ نیمه‌باز:", stuck["late"])
بعد از بهبودِ سرویس در درخواستِ 500 :
  با نیمه‌باز  : درخواست‌هایی که هنوز پشتیبان گرفتند: 29
  بدونِ نیمه‌باز: 100

۲۹ در برابرِ ۱۰۰. بدونِ نیمه‌باز، سرویس تا آخرِ عمرش جوابِ پشتیبان می‌دهد در حالی که مدل کاملاً سالم است.

عددِ ۲۹ هم اتفاقی نیست: مهلتِ ما ۳۰ ثانیه است، پس در بدترین حالت ۳۰ درخواست قبل از تماسِ آزمایشیِ بعدی می‌گذرند. مهلت را کم کنی، سریع‌تر برمی‌گردی ولی به سرویسی که هنوز مریض است بیشتر فشار می‌آوری. این همان معاملهٔ فصلِ ۴ است، این بار در جای دیگری.

۶. بدترین حالتِ قابلِ‌قبول#

تا اینجا فرض کردیم جوابِ بدتر از هیچ جواب بهتر است. این یک فرض است، نه یک حقیقت — و باید قبل از حادثه دربارهٔ آن تصمیم بگیری، نه وسطش.

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

اگر مدل نیست… کِی درست است چه چیزی باید در پاسخ باشد
خطای صریح بده تصمیم بدونِ مدل بی‌معناست کدِ ۵۰۳ و Retry-After
جوابِ پشتیبان بده جوابِ تقریبی هم مفید است نشانه‌ای که می‌گوید پشتیبان بوده
جوابِ cache بده کهنگیِ کوتاه بی‌ضرر است سنِ جواب
صف کن و بعداً جواب بده کاربر منتظر نیست شناسهٔ کار (فصلِ ۴)

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

🔧 اگر کار نکرد: اگر قطع‌کننده‌ات باز شد و هیچ‌وقت بسته نشد، نگاه کن ببین record(True) را در مسیرِ موفق صدا می‌زنی یا نه — رایج‌ترین باگ این است که فقط شکست‌ها ثبت می‌شوند. و اگر برعکس هرگز باز نشد، failures را جایی صفر می‌کنی که نباید. یک راهِ سریعِ تشخیص: در هر گام breaker.state را چاپ کن؛ اگر رشتهٔ «باز» یک بار هم دیده نشد، شمارنده هرگز به آستانه نرسیده است.

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

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

کلمه تلفظ به حروف فارسی یعنی چه
graceful degradation گریسفول دگرادیشن بدتر شدنِ کیفیت به‌جای از کار افتادنِ کامل
fallback فال‌بک مسیرِ ارزان‌تری که وقتی مسیرِ اصلی نیست جواب می‌دهد
circuit breaker سرکیت بریکر نگهبانی که بعد از چند شکستِ پیاپی تماس را قطع می‌کند
half-open هاف-اوپن حالتی که فقط یک تماسِ آزمایشی اجازه می‌دهد
backlog بک‌لاگ کارهایی که رسیده‌اند و هنوز نوبتشان نشده
blast radius بلست ریدیس دامنهٔ آسیبی که یک خرابی می‌تواند بزند
bulkhead بالک‌هد جدا کردنِ منابع تا خرابیِ یک بخش کلِ سامانه را نگیرد

تمرین‌ها

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

در فصل بعد#

سامانه‌ات حالا سریع است، ارزان است، و در روزِ بد هم جواب می‌دهد. فصلِ بعد می‌پرسد چقدر خرج برمی‌دارد. هزینهٔ هر درخواست را از روی واحدهای شمرده‌شده می‌سازیم — نه از روی قیمت‌هایی که فردا عوض می‌شوند — و روی یک منحنیِ بارِ بیست‌وچهارساعته می‌بینیم مقیاس‌پذیریِ افقی و عمودی هرکدام چند برابر ساعت‌ماشین می‌خواهند.

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

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