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

فصل ۶ از ۷

پیشرفت ترم
۰٪

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

یک مدلِ کوچکِ هزینه می‌سازیم — هفت فرض، همه به ساعت-مهندس — و نقطهٔ سربه‌سرِ «بساز» و «بخر» را حساب می‌کنیم.

با احتسابِ نگه‌داری، ساختن در سه سال هیچ‌وقت سربه‌سر نمی‌شود. بدونِ احتسابش، در ماهِ ۱۴ سربه‌سر می‌شود. همان یک جمله، تصمیم را وارونه می‌کند — و همان یک جمله است که در بیشترِ برآوردها اصلاً نوشته نمی‌شود.

بعد یک چیزِ ناخوشایندتر: اختلافِ هزینهٔ سه‌سالهٔ دو گزینه با فرض‌های فعلیِ ما ۲۲ ساعت از حدودِ ۱۳۰۰ ساعت است. یعنی تصمیم روی هیچ ایستاده. و وقتی هر فرض را ۵۰٪ جابه‌جا می‌کنیم، همان اختلاف تا ۱۲۶۶ ساعت تکان می‌خورد.

در آخر هزینهٔ خروج از فروشنده را می‌شماریم و می‌بینیم نقطهٔ سربه‌سر از «هرگز» به ماهِ ۳۱ می‌آید.

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

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

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

قبل از شروع#

از ترمِ ۴ فصلِ ۸: هزینهٔ هر درخواست و نقطهٔ سربه‌سر. آنجا سربه‌سرِ دو معماری بود، اینجا سربه‌سرِ دو تصمیمِ سازمانی.

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

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

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

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

۱. هفت فرض، و دو ستون#

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

HORIZON = 36
ASSUME = {
    "ساختِ اولیه": 320,          # ساعت-مهندس، یک بار
    "نگه‌داریِ ماهانه": 24,      # ساعت-مهندس در ماه — جملهٔ پنهان
    "زیرساختِ ماهانه": 4,        # ساعت-معادل در ماه
    "یکپارچه‌سازیِ اولیه": 40,   # ساعت-مهندس، یک بار
    "درخواستِ ماهِ اول": 10000,
    "رشدِ ماهانهٔ درخواست": 0.03,
    "ساعت-معادل هر هزار درخواست": 2.0,
}


def calls(month, a=ASSUME):
    return a["درخواستِ ماهِ اول"] * (1 + a["رشدِ ماهانهٔ درخواست"]) ** month


def build_cost(month, a=ASSUME, with_maintenance=True):
    monthly = (a["نگه‌داریِ ماهانه"] if with_maintenance else 0) + a["زیرساختِ ماهانه"]
    return a["ساختِ اولیه"] + monthly * (month + 1)


def buy_cost(month, a=ASSUME):
    unit = a["ساعت-معادل هر هزار درخواست"] / 1000
    return a["یکپارچه‌سازیِ اولیه"] + unit * sum(calls(m, a) for m in range(month + 1))


print(f"{'ماه':>6}{'بساز (ساعت)':>16}{'بخر (ساعت)':>16}{'ارزان‌تر':>12}")
for month in (0, 5, 11, 17, 23, 35):
    b, p = build_cost(month), buy_cost(month)
    print(f"{month + 1:>6}{b:>16.0f}{p:>16.0f}{('بساز' if b < p else 'بخر'):>12}")
   ماه     بساز (ساعت)      بخر (ساعت)    ارزان‌تر
     1             348              60         بخر
     6             488             169         بخر
    12             656             324         بخر
    18             824             508         بخر
    24             992             729         بخر
    36            1328            1306         بخر

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

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

۲. نقطهٔ سربه‌سر، و جمله‌ای که از قلم می‌افتد#

def break_even(a=ASSUME, with_maintenance=True, horizon=HORIZON):
    """اولین ماهی که ساختن از خریدن ارزان‌تر می‌شود؛ اگر نشد، None."""
    for month in range(horizon):
        if build_cost(month, a, with_maintenance) <= buy_cost(month, a):
            return month + 1
    return None


print("نقطهٔ سربه‌سر با احتسابِ نگه‌داری:", break_even() or f"در {HORIZON} ماه نمی‌رسد")
print("نقطهٔ سربه‌سر بدونِ احتسابِ نگه‌داری:",
      break_even(with_maintenance=False) or f"در {HORIZON} ماه نمی‌رسد")
نقطهٔ سربه‌سر با احتسابِ نگه‌داری: در 36 ماه نمی‌رسد
نقطهٔ سربه‌سر بدونِ احتسابِ نگه‌داری: 14
for label, flag in (("با نگه‌داری", True), ("بدونِ نگه‌داری", False)):
    b36 = build_cost(HORIZON - 1, ASSUME, flag)
    p36 = buy_cost(HORIZON - 1)
    print(f"{label:<16} هزینهٔ سه‌ساله — بساز {b36:>7.0f} · بخر {p36:>7.0f}"
          f" · توصیه: {'بساز' if b36 < p36 else 'بخر'}")
با نگه‌داری      هزینهٔ سه‌ساله — بساز    1328 · بخر    1306 · توصیه: بخر
بدونِ نگه‌داری   هزینهٔ سه‌ساله — بساز     464 · بخر    1306 · توصیه: بساز

۱۳۲۸ در برابرِ ۴۶۴. یک جمله، ۸۶۴ ساعت.

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

در این حساب، نگه‌داری در سه سال ۸۶۴ ساعت است — بیش از دو و نیم برابرِ ساختِ اولیه.

✅ چک کن: به عددِ «نگه‌داریِ ماهانه: ۲۴ ساعت» نگاه کن. از کجا آمده؟ از هیچ‌جا؛ من گذاشتمش. و دقیقاً همین مسئله است: این تنها فرضِ جدول است که هیچ‌کس نمی‌تواند از جایی نگاهش کند. حجمِ درخواست را از لاگ درمی‌آوری، قیمتِ فروشنده را از فهرستش می‌خوانی، ساختِ اولیه را با تجربه تخمین می‌زنی — ولی «چند ساعت در ماه صرفِ نگه‌داشتنِ این می‌شود» را باید خودت اندازه بگیری، و تقریباً هیچ تیمی نمی‌گیرد.

۳. جواب به کدام فرض بند است؟#

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

def gap(a):
    """اختلافِ هزینهٔ سه‌سالهٔ ساختن و خریدن؛ مثبت یعنی خریدن ارزان‌تر است."""
    return build_cost(HORIZON - 1, a) - buy_cost(HORIZON - 1, a)


rows = []
for key in ASSUME:
    span, deltas = [], []
    for factor in (0.5, 1.5):
        changed = dict(ASSUME)
        changed[key] = ASSUME[key] * factor
        span.append(break_even(changed))
        deltas.append(gap(changed))
    shown = [str(x) if x else f">{HORIZON}" for x in span]
    rows.append((key, shown, abs(deltas[0] - deltas[1])))
print(f"{'فرضی که ۵۰٪ جابه‌جا شد':<34}{'سربه‌سر −۵۰٪':>16}"
      f"{'سربه‌سر +۵۰٪':>16}{'جابه‌جاییِ سه‌ساله':>22}")
for key, shown, swing in sorted(rows, key=lambda r: -r[2]):
    print(f"{key:<34}{shown[0]:>16}{shown[1]:>16}{swing:>22.0f}")
print("اختلافِ سه‌ساله با فرض‌های فعلی:", round(gap(ASSUME)))
فرضی که ۵۰٪ جابه‌جا شد                سربه‌سر −۵۰٪    سربه‌سر +۵۰٪    جابه‌جاییِ سه‌ساله
درخواستِ ماهِ اول                              >36              22                  1266
ساعت-معادل هر هزار درخواست                     >36              22                  1266
نگه‌داریِ ماهانه                                23             >36                   864
رشدِ ماهانهٔ درخواست                           >36              28                   778
ساختِ اولیه                                     31             >36                   320
زیرساختِ ماهانه                                 35             >36                   144
یکپارچه‌سازیِ اولیه                            >36             >36                    40
اختلافِ سه‌ساله با فرض‌های فعلی: 22

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

سه فرضِ اولِ جدول جواب را بین ۸۶۴ و ۱۲۶۶ ساعت تکان می‌دهند — یعنی هر کدام به‌تنهایی دست‌کم نزدیک به چهل برابرِ خودِ اختلافِ ۲۲ ساعتی است. پس هر بحثی دربارهٔ «بساز یا بخر» که به این سه نرسد، بحث دربارهٔ چیزِ اشتباهی است.

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

یک صداقتِ لازم دربارهٔ ستون‌های میانی: آنجا که نوشته >36، یعنی در افقِ سه‌ساله سربه‌سر نشد. این ستون‌ها ته می‌خورند و ستونِ آخر نمی‌خورد — به همین دلیل مرتب‌سازی روی ستونِ آخر است، نه روی ماهِ سربه‌سر.

۴. وابستگی به فروشنده، به‌عنوان یک ستون#

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

EXIT = 160          # ساعت-مهندس برای کوچ دادنِ داده و کد به جای دیگر


def buy_with_exit(month, a=ASSUME):
    return buy_cost(month, a) + EXIT


print("اگر روزی مجبور به کوچ شوی، هزینهٔ خروج", EXIT, "ساعت است.")
for month in (11, 23, 35):
    print(f"  ماهِ {month + 1:>2}: بساز {build_cost(month):>6.0f}"
          f" · بخر {buy_cost(month):>6.0f}"
          f" · بخر + خروج {buy_with_exit(month):>6.0f}")
first = next((m + 1 for m in range(HORIZON)
              if build_cost(m) <= buy_with_exit(m)), None)
print("نقطهٔ سربه‌سر وقتی هزینهٔ خروج شمرده شود:", first)
اگر روزی مجبور به کوچ شوی، هزینهٔ خروج 160 ساعت است.
  ماهِ 12: بساز    656 · بخر    324 · بخر + خروج    484
  ماهِ 24: بساز    992 · بخر    729 · بخر + خروج    889
  ماهِ 36: بساز   1328 · بخر   1306 · بخر + خروج   1466
نقطهٔ سربه‌سر وقتی هزینهٔ خروج شمرده شود: 31

از «هرگز» به ماهِ ۳۱.

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

و یک کاهندهٔ ریسک که ارزان‌تر از هر دو گزینه است: از روزِ اول پشتِ یک مرزِ خودت خریدش کن. اگر کدت مستقیم با فروشنده حرف بزند، هزینهٔ خروج بالاست؛ اگر با یک واسطِ کوچکِ خودت حرف بزند، همان ۱۶۰ ساعت به چند ساعت تبدیل می‌شود — و همان الگویی است که ترمِ ۴ فصلِ ۲ به‌عنوان «قراردادِ API» ساخت.

۵. معیارِ تصمیم#

عددها تصمیم نمی‌گیرند. این‌ها می‌گیرند:

بپرس اگر جوابش این بود، به این سمت برو
این کار تمایزِ ما است یا زیرساختِ عمومی؟ تمایز ← بساز · عمومی ← بخر
فاصلهٔ دو ستون در افقِ ما چقدر است؟ زیرِ نویزِ فرض‌ها ← این یک تصمیمِ مالی نیست؛ با سطرِ اولِ همین جدول تصمیم بگیر
نگه‌داریش را اندازه گرفته‌ایم یا حدس زده‌ایم؟ حدس ← اول اندازه بگیر
اگر فروشنده فردا نبود، چند ساعت طول می‌کشد؟ زیاد ← یا مرز بگذار یا بساز
اگر حجم ده برابر شود کدام می‌شکند؟ همان جدولِ حساسیت را با ده برابر دوباره بزن
کسی هست که سالِ بعد نگهش دارد؟ نه ← نساز، هرچه جدول بگوید

و سطرِ آخر مهم‌ترینشان است و هیچ عددی ندارد. سامانه‌ای که ساخته می‌شود و نگهبان ندارد، در همان ماهِ ششم گران‌تر از هر گزینهٔ خریدنی می‌شود — نه در ساعت، در حادثه.

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

🔧 اگر کار نکرد: اگر break_even همیشه None داد و انتظارش را نداشتی، HORIZON را بزرگ‌تر کن و دوباره ببین — ممکن است سربه‌سر واقعاً وجود داشته باشد و بیرونِ افقت افتاده باشد. اگر TypeError: unsupported operand type(s) for *: 'dict' and 'float' گرفتی، در حلقهٔ حساسیت ASSUME را به‌جای ASSUME[key] ضرب کرده‌ای. و اگر ستونِ «بخر» رشد نکرد، calls را با month صدا نزده‌ای: توانِ (1 + رشد) ** month تنها جایی است که زمان وارد آن ستون می‌شود.

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

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

کلمه تلفظ به حروف فارسی یعنی چه
total cost of ownership توتال کاست آف اونرشیپ همهٔ هزینهٔ عمرِ یک سامانه، نه فقط ساختنش
break-even point بریک-ایون پوینت زمانی که هزینهٔ انباشتهٔ دو گزینه برابر می‌شود
vendor lock-in وندور لاک-این وابستگی‌ای که رفتن از یک فروشنده را گران می‌کند
exit cost اگزیت کاست ساعتی که کوچ دادنِ داده و کد به جای دیگر می‌برد
maintenance load مینتننس لود کارِ تکرارشوندهٔ نگه‌داشتنِ یک سامانهٔ زنده
sunk cost سانک کاست هزینه‌ای که خرج شده و در تصمیمِ امروز نباید بشمارد

تمرین‌ها

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

در فصل بعد#

فصلِ بعد آخرین فصلِ داربست است و هیچ مفهومِ تازه‌ای ندارد.

یک سیاههٔ تحویل می‌سازیم که خودش را روی پروژهٔ خودت اجرا می‌کند — نه یک فهرستِ کاغذی، یک برنامه که به پوشهٔ پروژه نگاه می‌کند و می‌گوید چند بند از چند بند. و سه قانونِ ثابتِ این دوره را کنارِ هم می‌گذاریم و می‌بینیم هر بندِ آن سیاهه، به کدام‌یک از آن سه خدمت می‌کند.

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

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