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

فصل ۸ از ۹

پیشرفت ترم
۰٪

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

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

منحنیِ بارِ یک شبانه‌روز را فرض می‌کنیم و حساب می‌کنیم اوجش ۲٫۱۱ برابرِ میانگین است. مقیاسِ افقی روی همان منحنی ۲٫۰۴ برابر ساعت‌نمونه صرفه‌جویی می‌کند. و بعد یک cache هشتادوهفت‌درصدی همان هزینه را ۸ برابر کم می‌کند — چهار برابرِ بهترین تصمیمِ مقیاس.

دو ماشین‌خانه با ظرفیتِ ثابت و ظرفیتِ متغیر

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

  • هزینه را از روی واحدهای شمرده‌شده بسازی، نه از روی حدس
  • منحنیِ بار را بکشی و نسبتِ اوج به میانگین را بگویی
  • مقیاسِ افقی و عمودی را با ساعت‌نمونه مقایسه کنی
  • نقطهٔ سربه‌سرِ یک بهینه‌سازی را حساب کنی و با قیمتِ خودت تصمیم بگیری

قبل از شروع#

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

⚠️ مواظب باش: در این فصل عمداً هیچ قیمتی — نه ساعتِ ماشین، نه گیگابایت، نه هزارتا درخواست — داخلِ متن نوشته نمی‌شود. هر عددی که اینجا ببینی یک شمارش است، نه یک قیمت. قیمت‌ها را خودت در متغیرهای بالای سلولِ آخر می‌گذاری. و یک قید که به همان اندازه مهم است: منحنیِ بار و ظرفیتِ نمونه هم فرض‌اند، نه اندازه‌گیری. SHAPE و CAPACITY و HEADROOM را ما دستی نوشته‌ایم تا شکلِ یک شبانه‌روزِ معمول را نشان بدهند؛ تنها عددِ اندازه‌گیری‌شدهٔ این فصل نرخِ اصابتِ cache است که از شمارندهٔ بخشِ ۱ می‌آید. هر جا در ادامه «حساب کردیم» می‌بینی، یعنی از همین فرض‌ها نتیجه گرفته‌ایم — روشِ حساب مالِ هر سرویسی است، عددش مالِ این منحنی.

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

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

۱. واحد بشمار، نه پول#

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

import math
import random
import sqlite3

model = fit_model(TRAIN[:800])
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)

CACHE = sqlite3.connect(str(WORK / "cost.db"))
CACHE.execute("CREATE TABLE l2 (key TEXT PRIMARY KEY, label TEXT)")
UNITS = {"model": 0, "cache_read": 0, "cache_write": 0}


def measure(use_cache):
    for key in UNITS:
        UNITS[key] = 0
    CACHE.execute("DELETE FROM l2")
    memory = {}
    for text in STREAM:
        key = normalise(text)
        if use_cache:
            UNITS["cache_read"] += 1
            if key in memory:
                continue
            row = CACHE.execute("SELECT label FROM l2 WHERE key = ?", (key,)).fetchone()
            if row:
                memory[key] = row[0]
                continue
        UNITS["model"] += 1
        label = model.predict([key])[0]
        if use_cache:
            memory[key] = label
            UNITS["cache_write"] += 1
            CACHE.execute("INSERT OR REPLACE INTO l2 VALUES (?, ?)", (key, label))
    CACHE.commit()
    return dict(UNITS)


cold = measure(use_cache=False)
warm = measure(use_cache=True)
print(f"{'':<18}{'اجرای مدل':>12}{'خواندنِ cache':>16}{'نوشتنِ cache':>15}")
for name, u in (("بدونِ cache", cold), ("با cache", warm)):
    print(f"{name:<18}{u['model']:>12}{u['cache_read']:>16}{u['cache_write']:>15}")
print("حجمِ دادهٔ cache (بایت):",
      CACHE.execute("SELECT SUM(LENGTH(CAST(key AS BLOB)) + LENGTH(CAST(label AS BLOB)))"
                    " FROM l2").fetchone()[0])
                     اجرای مدل   خواندنِ cache   نوشتنِ cache
بدونِ cache               2000               0              0
با cache                   250            2000            250
حجمِ دادهٔ cache (بایت): 39356

سه ستون، سه جنسِ کاملاً متفاوتِ هزینه. اجرای مدل پردازنده می‌خواهد، خواندنِ cache یک تماسِ سبک است، و ذخیره‌سازی جای دیسک می‌گیرد و ماهانه حساب می‌شود نه به‌ازای هر درخواست.

سی‌ونه کیلوبایت برای دویست‌وپنجاه جواب. (CAST ... AS BLOB لازم است، چون LENGTH روی متن نویسه می‌شمارد نه بایت، و هر حرفِ فارسی دو بایت است.) این عدد آن‌قدر کوچک است که ذخیره‌سازی در این سرویس اصلاً وارد معادله نمی‌شود، و برای همین حسابِ بخشِ ۶ فقط اجرای مدل و خواندنِ cache را دارد.

۲. به ازای هر میلیون درخواست#

شمارشِ دو هزار درخواست به‌تنهایی معنا ندارد. واحدِ استانداردِ گفت‌وگو با هر فروشنده‌ای «به ازای هر میلیون» است.

def per_million(units):
    factor = 1_000_000 / len(STREAM)
    return {k: v * factor for k, v in units.items()}


for name, u in (("بدونِ cache", cold), ("با cache", warm)):
    p = per_million(u)
    print(f"{name:<12} به ازای هر میلیون درخواست:"
          f" اجرای مدل {p['model']:>10,.0f} · خواندنِ cache {p['cache_read']:>10,.0f}")
print("نسبتِ اجرای مدل:", round(cold["model"] / warm["model"], 2), "برابر")
بدونِ cache  به ازای هر میلیون درخواست: اجرای مدل  1,000,000 · خواندنِ cache          0
با cache     به ازای هر میلیون درخواست: اجرای مدل    125,000 · خواندنِ cache  1,000,000
نسبتِ اجرای مدل: 8.0 برابر

هشت برابر کمتر اجرای مدل — و یک میلیون خواندنِ cache که قبلاً نبود.

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

۳. منحنیِ بار#

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

SHAPE زیر یک فرض است، نه یک اندازه‌گیری — بیست‌وچهار عددِ دستی که شکلِ آشنای یک سرویسِ روزانه را می‌سازند. منحنیِ خودت را باید از سیاههٔ سرویسِ خودت دربیاوری؛ چیزی که اینجا یاد می‌گیری روشِ حساب است، نه این بیست‌وچهار عدد.

SHAPE = [12, 8, 5, 4, 4, 7, 15, 34, 66, 88, 100, 96,
         85, 90, 98, 93, 80, 62, 48, 41, 35, 29, 21, 15]
REQUESTS = [s * 3000 for s in SHAPE]
total = sum(REQUESTS)
peak, mean = max(REQUESTS), total / 24
print(f"درخواست در شبانه‌روز : {total:,}")
print(f"اوج در ساعت         : {peak:,}")
print(f"میانگین در ساعت     : {mean:,.0f}")
print(f"نسبتِ اوج به میانگین : {peak / mean:.2f}")
print("نمودارِ بار:")
for hour, count in enumerate(REQUESTS):
    print(f"  {hour:>2} {'#' * round(count / peak * 40)}")
درخواست در شبانه‌روز : 3,408,000
اوج در ساعت         : 300,000
میانگین در ساعت     : 142,000
نسبتِ اوج به میانگین : 2.11
نمودارِ بار:
   0 #####
   1 ###
   2 ##
   3 ##
   4 ##
   5 ###
   6 ######
   7 ##############
   8 ##########################
   9 ###################################
  10 ########################################
  11 ######################################
  12 ##################################
  13 ####################################
  14 #######################################
  15 #####################################
  16 ################################
  17 #########################
  18 ###################
  19 ################
  20 ##############
  21 ############
  22 ########
  23 ######

نسبتِ اوج به میانگین ۲٫۱۱ است، و همین یک عدد کلِ بحثِ مقیاس‌پذیری را می‌سازد.

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

۴. عمودی در برابرِ افقی#

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

CAPACITY = 60_000          # اجرای مدل در ساعت، برای هر نمونه
HEADROOM = 0.70            # هیچ‌کس نمونه را صد درصد پر نمی‌کند


def instances(load):
    return max(1, math.ceil(load / (CAPACITY * HEADROOM)))


def plan(hit_rate, floor=1):
    runs = [round(r * (1 - hit_rate)) for r in REQUESTS]
    return {"vertical": instances(max(runs)) * 24,
            "horizontal": sum(max(floor, instances(r)) for r in runs)}


no_cache = plan(0.0)
print(f"بدونِ cache — عمودی: {no_cache['vertical']} ساعت‌نمونه"
      f" · افقی: {no_cache['horizontal']} ساعت‌نمونه"
      f" · صرفه‌جویی {no_cache['vertical'] / no_cache['horizontal']:.2f} برابر")
floored = plan(0.0, floor=2)
print(f"با کفِ دو نمونه   — افقی: {floored['horizontal']} ساعت‌نمونه"
      f" · صرفه‌جویی {no_cache['vertical'] / floored['horizontal']:.2f} برابر")
بدونِ cache — عمودی: 192 ساعت‌نمونه · افقی: 94 ساعت‌نمونه · صرفه‌جویی 2.04 برابر
با کفِ دو نمونه   — افقی: 100 ساعت‌نمونه · صرفه‌جویی 1.92 برابر

۱۹۲ در برابرِ ۹۴ ساعت‌نمونه. عددِ ۲٫۰۴ تقریباً همان نسبتِ اوج به میانگینِ بخشِ قبل است، و این تصادفی نیست: مقیاسِ افقی دقیقاً همان فاصله را می‌گیرد.

و باز هم: CAPACITY و HEADROOM هر دو فرض‌اند. ظرفیتِ نمونه را باید با یک آزمونِ بار روی سخت‌افزارِ خودت اندازه بگیری، نه از یک کتاب برداری. HEADROOM هم یک تصمیمِ واقعی است: اگر نمونه‌ها را صد درصد پر کنی، هر نوسانِ کوچکِ ترافیک صف می‌سازد و p95 را خراب می‌کند. هفتاد درصد یعنی سی درصدِ ظرفیت را برای بدشانسی کنار گذاشته‌ای.

و کفِ دو نمونه هزینهٔ واقعیِ افقی است. یک نمونه یعنی هر ری‌استارت یک قطعی است، پس در عمل زیرِ دو نمونه نمی‌روی. صرفه‌جویی از ۲٫۰۴ به ۱٫۹۲ رسید — نه فاجعه، ولی رایگان هم نبود.

✅ چک کن: به ستونِ افقی نگاه کن و از خودت بپرس چند بار در شبانه‌روز تعدادِ نمونه‌ها عوض شد. هر تغییر یک راه‌اندازیِ تازه است، و هر راه‌اندازی یعنی بارگذاریِ دوبارهٔ مدل و یک cache سرد (فصلِ ۵). اگر منحنیِ بارت دندانه‌دار باشد، مقیاسِ خودکار می‌تواند بیشتر از آنچه صرفه‌جویی می‌کند خرج بتراشد.

۵. cache منحنی را عوض می‌کند#

hit = 1 - warm["model"] / cold["model"]
cached = plan(hit)
print(f"نرخِ اصابتِ اندازه‌گیری‌شده: {100 * hit:.1f}%")
print(f"با cache — عمودی: {cached['vertical']} ساعت‌نمونه"
      f" · افقی: {cached['horizontal']} ساعت‌نمونه")
print(f"عمودیِ بدونِ cache در برابرِ افقیِ با cache:"
      f" {no_cache['vertical'] / cached['horizontal']:.2f} برابر")
print(f"بهترین تصمیمِ مقیاس، بدونِ cache : "
      f"{no_cache['vertical'] / no_cache['horizontal']:.2f} برابر")
نرخِ اصابتِ اندازه‌گیری‌شده: 87.5%
با cache — عمودی: 24 ساعت‌نمونه · افقی: 24 ساعت‌نمونه
عمودیِ بدونِ cache در برابرِ افقیِ با cache: 8.00 برابر
بهترین تصمیمِ مقیاس، بدونِ cache : 2.04 برابر

هشت برابر در برابرِ دو برابر.

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

این ترتیبِ درستِ کار است و اغلب وارونه انجام می‌شود: اول کارِ کمتر کن، بعد ماشینِ بیشتر بخر. هر ساعتی که صرفِ تنظیمِ مقیاسِ خودکار می‌شود در حالی که هشتاد درصدِ درخواست‌ها تکراری‌اند، ساعتِ هدررفته است.

📏 اندازه بگیر: با چه چیزی مقایسه شد؟ با همان منحنیِ بار و همان ظرفیتِ نمونه؛ تنها متغیر نرخِ اصابت بود، و آن هم اندازه‌گیری شده — از شمارندهٔ بخشِ ۱ آمده، نه از یک فرض. روی کدام داده؟ همان ۲۰۰۰ درخواست برای شمارشِ واحدها و همان منحنیِ ۲۴ساعته برای ساعت‌نمونه. با چند seed؟ یکی، و اینجا صادقانه باید گفت که این عدد بیشتر از هر چیزی به شکلِ ترافیک وابسته است، نه به seed: اگر ترافیکِ تو تکرارِ کمتری داشته باشد، نرخِ اصابت پایین می‌آید و همین حساب جوابِ دیگری می‌دهد. عددِ ۸ برابر مالِ این ترافیک است؛ روشِ رسیدن به آن مالِ هر ترافیکی.

۶. نقطهٔ سربه‌سر، با قیمتِ خودت#

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

PRICE_CACHE_READ = [1.0, 0.1, 0.01]      # ← نسبتِ قیمتِ خودت را اینجا بگذار


def per_request(units, price_cache_read):
    return (units["model"] + units["cache_read"] * price_cache_read) / len(STREAM)


saved = cold["model"] - warm["model"]
breakeven = saved / warm["cache_read"]
print(f"واحدِ حساب: هزینهٔ یک بار اجرای مدل = ۱")
print(f"نقطهٔ سربه‌سر: هر خواندنِ cache باید ارزان‌تر از {breakeven:.4f}"
      f" برابرِ یک اجرای مدل باشد")
for ratio in PRICE_CACHE_READ:
    a, b = per_request(cold, ratio), per_request(warm, ratio)
    print(f"  نسبتِ قیمت {ratio:<5} → بدونِ cache {a:.4f} · با cache {b:.4f}"
          f" · نسبت {a / b:.2f}")
print(f"ساعت‌نمونه به ازای هر میلیون درخواست:"
      f" بدونِ cache {no_cache['horizontal'] / total * 1e6:.1f}"
      f" · با cache {cached['horizontal'] / total * 1e6:.1f}")
واحدِ حساب: هزینهٔ یک بار اجرای مدل = ۱
نقطهٔ سربه‌سر: هر خواندنِ cache باید ارزان‌تر از 0.8750 برابرِ یک اجرای مدل باشد
  نسبتِ قیمت 1.0   → بدونِ cache 1.0000 · با cache 1.1250 · نسبت 0.89
  نسبتِ قیمت 0.1   → بدونِ cache 1.0000 · با cache 0.2250 · نسبت 4.44
  نسبتِ قیمت 0.01  → بدونِ cache 1.0000 · با cache 0.1350 · نسبت 7.41
ساعت‌نمونه به ازای هر میلیون درخواست: بدونِ cache 27.6 · با cache 7.0

خطِ اولِ جدول یک هشدارِ واقعی است: با نسبتِ قیمتِ ۱، cache سرویس را گران‌تر می‌کند، نه ارزان‌تر.

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

در عمل این نسبت خیلی کوچک است — یک جست‌وجو در cache هزارها برابر ارزان‌تر از اجرای یک مدل است — پس جواب معمولاً روشن است. ولی این را باید بدانی، نه فرض کنی، و روزی که مدلت خیلی کوچک و cache ات روی شبکه باشد، همین حساب می‌تواند وارونه شود.

🌱 ریشه‌اش کجاست: «نقطهٔ سربه‌سر» یک اسمِ فنی برای یک کارِ آشناست: دو عبارت را برابر بگذار و مجهول را دربیاور. اینجا یک طرف هزینهٔ بدونِ cache است (۲۰۰۰ اجرای مدل) و طرفِ دیگر هزینهٔ با cache (۲۵۰ + r × ۲۰۰۰)، و مجهولْ نسبتِ قیمتِ r است. حل کردنش دقیقاً همان قاعدهٔ ریشه، ترم ۳ فصل ۳ — معادلهٔ خطی، قدم‌به‌قدم است: «برعکسِ ترتیبِ عملیات» — اول جمع را بردار، بعد ضرب را. پس عددِ ۰٫۸۷۵ یک ثابتِ جادویی نیست؛ جوابِ یک معادلهٔ خطیِ دومرحله‌ای است — و اگر نرخِ اصابتت عوض شود، همان معادله عددِ دیگری می‌دهد.

و به دو عددِ خطِ آخر نگاه کن: ۲۷٫۶ در برابرِ ۷٫۰ ساعت‌نمونه در هر میلیون. هرکدام را در قیمتِ ساعتیِ فروشنده‌ات ضرب کن، و مجموعِ سه ضرب — اجرای مدل، خواندنِ cache، ساعت‌نمونه — کلِ هزینهٔ متغیرِ سرویس است.

۷. چه چیزی را مقیاس حل نمی‌کند#

اگر مشکل این است… مقیاس کمک می‌کند؟ کارِ درست
ساعتِ اوج سرویس کند می‌شود بله، افقی مقیاسِ خودکار روی منحنیِ بار
هر درخواست ذاتاً گران است نه cache، مدلِ کوچک‌تر، batching
هشتاد درصدِ سؤال‌ها تکراری‌اند نه cache (فصلِ ۵)
کارِ سنگین فوری نیست نه صف و اجرای شبانه (فصلِ ۴)
یک وابستگی افتاده نه قطع‌کننده و پشتیبان (فصلِ ۷)
حجمِ ذخیره‌سازی زیاد است نه مهلتِ نگه‌داری (ترمِ ۲ فصلِ ۸)

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

🔧 اگر کار نکرد: اگر plan برایت ZeroDivisionError: division by zero داد، HEADROOM یا CAPACITY را صفر گذاشته‌ای، چون instances بر حاصل‌ضربشان تقسیم می‌کند. برعکسش هم تله است: hit_rate برابرِ ۱ هیچ خطایی نمی‌دهد و plan(1.0) همان ۲۴ ساعت‌نمونه را برمی‌گرداند، چون instances را با max(1, ...) نوشته‌ایم؛ ولی عددی که برمی‌گردد بی‌معنا است: نرخِ اصابتِ صد درصد یعنی مدل هیچ‌وقت اجرا نمی‌شود، و آن‌وقت اصلاً به مدل نیازی نداری. هر بار که یک محاسبهٔ هزینه عددِ صفر یا بی‌نهایت داد، اول به فرض‌هایت شک کن، بعد به کد.

🤖 از دستیارت بپرس: «تفاوتِ reserved و spot و on-demand در خریدِ ظرفیت چیست و هرکدام چه ریسکی دارند؟» بعد این را بپرس: «اگر منحنیِ بارِ من نسبتِ اوج به میانگینِ ۲ داشته باشد، چه ترکیبی از ظرفیتِ ثابت و ظرفیتِ کشسان کمترین هزینه را می‌دهد؟» — جوابش همان تقسیمِ «کف با قیمتِ ارزان‌تر، اوج با قیمتِ گران‌تر» است.

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

کلمه تلفظ به حروف فارسی یعنی چه
cost per request کاست پر ریکوئست هزینهٔ متغیرِ سرویس تقسیم بر تعدادِ درخواست
load curve لود کرو شکلِ توزیعِ ترافیک در طولِ شبانه‌روز
peak-to-mean ratio پیک تو مین ریشیو نسبتِ بارِ اوج به بارِ میانگین
vertical scaling ورتیکال اسکیلینگ بزرگ‌تر کردنِ همان ماشین
horizontal scaling هوریزنتال اسکیلینگ زیاد کردنِ تعدادِ ماشین‌ها
headroom هدروم ظرفیتِ خالی که عمداً پر نمی‌شود
break-even بریک-ایون نقطه‌ای که دو گزینه هزینهٔ برابر دارند

تمرین‌ها

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

در فصل بعد#

هشت فصل گذشت. فصلِ آخر هفت قطعه از آن‌ها را در یک خطِ استقرار کنارِ هم می‌گذارد: artifact با MANIFEST، سرویسِ نسخه‌دار، صفِ یکسان‌توان، cache کلیددارِ نسخه، انتشارِ قناری با دروازهٔ زیرگروهی، قطع‌کننده و پشتیبان، و سیاههٔ هزینه. و چیزی که تا حالا نداشتیم: دکمهٔ برگشت — با اندازه‌گیریِ اینکه از لحظهٔ خرابی تا لحظهٔ برگشت چند کاربر آسیب دیدند.

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

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