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

فصل ۴ از ۷

پیشرفت ترم
۰٪

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

تا اینجا از چیزهایی محافظت کردیم که می‌دانستیم. این فصل سراغِ چیزی می‌رود که هنوز اتفاق نیفتاده — و سراغِ چیزی که قبلاً اتفاق افتاده و کسی نمی‌داند چرا.

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

بعد یک ردِ ممیزی می‌سازیم — چهار جدول در sqlite3 — و ۱۴۰۰ پیش‌بینی را با آن ثبت می‌کنیم. با ردِ ثبت‌شده، ۱۴۰۰ از ۱۴۰۰ پیش‌بینی دقیقاً بازتولید می‌شود. با حدسِ «حتماً مدلِ فعلی بوده»، ۱۳۲۰ از ۱۴۰۰ — یعنی دربارهٔ ۸۰ پیش‌بینی جوابِ غلط به کسی می‌دهی. هزینه‌اش ۶۱٫۴ بایت به ازای هر پیش‌بینی است.

بایگانیِ برچسب‌خوردهٔ قطعات، با یک نخِ پیوسته از هر قطعه تا قالبِ سازنده‌اش

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

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

قبل از شروع#

از ترمِ ۳ فصلِ ۶: رجیستریِ مدل و پیوندِ مدل به داده و کد. این فصل همان ایده را به زمانِ سرویس می‌برد: هر پاسخِ منفرد هم باید بداند از کجا آمده.

از فصلِ ۲ و ۳ همین ترم: نگهبان‌های خودکار. ستونِ آخرِ سیاههٔ ریسک دقیقاً همان‌هاست.

از ترمِ ۴ فصلِ ۱: جدا کردنِ کد و وزن و پیکربندی. بدونِ آن، «نسخهٔ مدل» معنای دقیقی ندارد.

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

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

۱. سیاههٔ ریسک، از شکست‌های واقعی#

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

هشت ردیفِ زیر همه در همین دوره واقعاً اتفاق افتاده‌اند.

import random

RISKS = [
    ("نشتیِ ردیفِ تکراری در تقسیم", 4, 5, "F1 از ۰٫۸۴۰ به ۰٫۲۵۵ (ترمِ ۲ فصلِ ۷)",
     "split_shares_no_row"),
    ("ارزیابیِ آفلاین وارونه می‌شود", 4, 5, "۰ از ۴۳۲ پیکربندی روی آینده بهتر (ترمِ ۳ فصلِ ۸)",
     "split_is_chronological"),
    ("سقوطِ زیرگروه پس از انتشار", 3, 5, "۸۱ کاربرِ آسیب‌دیده (ترمِ ۴ فصلِ ۶)", None),
    ("قراردادِ داده از بالادست می‌شکند", 4, 3, "بیلد قرمز پیش از آموزش (ترمِ ۶ فصلِ ۲)",
     "schema_categories"),
    ("برچسب وارد ویژگی‌ها می‌شود", 2, 5, "با برچسبِ تصادفی هم ۱٫۰۰۰۰ (فصلِ ۲ همین ترم)",
     "features_ignore_the_label"),
    ("تستِ سبز، خرابیِ زنده", 3, 4, "۱۰ تستِ سبز و یک جهشِ زنده (ترمِ ۱ فصلِ ۲)", None),
    ("مستند از کد عقب می‌ماند", 5, 2, "۱ از ۶ دستور اجرا می‌شد (ترمِ ۶ فصلِ ۳)", "docs_gate"),
    ("مدل بی‌صدا بدتر می‌شود", 4, 4, "در این پروژه هنوز اندازه نگرفته‌ایم (روشش: ترمِ ۵)", None),
]
print(f"{'ریسک':<34}{'احتمال':>8}{'اثر':>6}{'امتیاز':>8}{'نگهبانِ خودکار':>26}")
for name, likelihood, impact, _, guard in sorted(RISKS, key=lambda r: -r[1] * r[2]):
    print(f"{name:<34}{likelihood:>8}{impact:>6}{likelihood * impact:>8}"
          f"{(guard or 'ندارد'):>26}")
total = sum(l * i for _, l, i, _, _ in RISKS)
naked = sum(l * i for _, l, i, _, g in RISKS if not g)
print(f"مجموعِ امتیاز: {total} · بدونِ نگهبان: {naked} ({naked / total:.1%})")
ریسک                                احتمال   اثر  امتیاز            نگهبانِ خودکار
نشتیِ ردیفِ تکراری در تقسیم              4     5      20       split_shares_no_row
ارزیابیِ آفلاین وارونه می‌شود            4     5      20    split_is_chronological
مدل بی‌صدا بدتر می‌شود                   4     4      16                     ندارد
سقوطِ زیرگروه پس از انتشار               3     5      15                     ندارد
قراردادِ داده از بالادست می‌شکند         4     3      12         schema_categories
تستِ سبز، خرابیِ زنده                    3     4      12                     ندارد
برچسب وارد ویژگی‌ها می‌شود               2     5      10 features_ignore_the_label
مستند از کد عقب می‌ماند                  5     2      10                 docs_gate
مجموعِ امتیاز: 115 · بدونِ نگهبان: 43 (37.4%)

۳۷٫۴٪ ریسکِ این پروژه هیچ چیزی جلویش را نمی‌گیرد. و بدترینشان دقیقاً همان‌هایی هستند که در تولید اتفاق می‌افتند، نه در بیلد: سقوطِ زیرگروه، بدتر شدنِ بی‌صدای مدل، و خرابی‌ای که ده تستِ سبز نمی‌گیرندش.

ستونِ چهارم — که در جدول چاپ نشده و در کد هست — مهم‌ترین ستون است. بدونِ لنگر، «اثر: ۵» یک احساس است. با لنگر، جمله‌ای است که می‌شود سرش بحث کرد: «اثرش پنج است چون همان اتفاق F1 را از ۰٫۸۴۰ به ۰٫۲۵۵ برد».

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

۲. چقدر از این فهرست، قضاوت است؟#

دو ستونِ «احتمال» و «اثر» عددهای دقیقی نیستند؛ قضاوتِ آدم‌اند. پس بسنجیم این قضاوت چقدر نتیجه را تکان می‌دهد: هر دو ستون را تصادفی یک واحد بالا و پایین می‌بریم و ۵۰۰ بار فهرست را دوباره مرتب می‌کنیم.

def perturb(seed):
    """هر دو ستونِ قضاوتی را یک واحد بالا و پایین می‌بریم و دوباره مرتب می‌کنیم."""
    dice = random.Random(seed)
    scored = [(name, max(1, min(5, l + dice.randint(-1, 1)))
               * max(1, min(5, i + dice.randint(-1, 1)))) for name, l, i, _, _ in RISKS]
    return [n for n, _ in sorted(scored, key=lambda x: -x[1])]


BASE = [n for n, _ in sorted(((name, l * i) for name, l, i, _, _ in RISKS),
                             key=lambda x: -x[1])]
DRAWS = 500
same_first = sum(perturb(s)[0] == BASE[0] for s in range(DRAWS))
same_top3 = sum(set(perturb(s)[:3]) == set(BASE[:3]) for s in range(DRAWS))
in_top3 = {n: sum(n in perturb(s)[:3] for s in range(DRAWS)) / DRAWS for n in BASE}
print(f"در {DRAWS} آشفتگیِ ±۱ روی هر دو ستون:")
print(f"  ریسکِ شمارهٔ یک همان ماند: {same_first / DRAWS:.1%}")
print(f"  مجموعهٔ سه‌تای اول همان ماند: {same_top3 / DRAWS:.1%}")
print("  ماندن در سه‌تای اول، به تفکیک:")
for name in BASE[:5]:
    print(f"    {name:<34}{in_top3[name]:>8.1%}")
در 500 آشفتگیِ ±۱ روی هر دو ستون:
  ریسکِ شمارهٔ یک همان ماند: 47.8%
  مجموعهٔ سه‌تای اول همان ماند: 19.2%
  ماندن در سه‌تای اول، به تفکیک:
    نشتیِ ردیفِ تکراری در تقسیم          82.6%
    ارزیابیِ آفلاین وارونه می‌شود        85.8%
    مدل بی‌صدا بدتر می‌شود               38.0%
    سقوطِ زیرگروه پس از انتشار           39.4%
    قراردادِ داده از بالادست می‌شکند     28.4%

۱۹٫۲٪. یعنی اگر همکارت همان جدول را با قضاوتِ کمی متفاوت پر کند، در چهار مورد از پنج مورد سه‌تای اولِ فهرستش با تو فرق دارد.

این شکستِ سیاههٔ ریسک نیست؛ راهنمای استفاده‌اش است. ستونِ آخر می‌گوید کدام ردیف‌ها واقعاً محکم‌اند: دو ریسکِ اول در بیش از هشتاد درصدِ اجراها در سه‌تای اول می‌مانند، و بقیه بین ۲۸ تا ۳۹ درصد می‌چرخند.

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

✅ چک کن: به عددِ ۴۷٫۸٪ نگاه کن. تقریباً سکه. حالا از خودت بپرس چند جلسه دربارهٔ اینکه کدام ریسک «شمارهٔ یک» است بحث شده. آن بحث با یک آشفتگیِ ±۱ حل می‌شود، و ±۱ دقیقاً همان چیزی است که هر دو طرف حاضرند رویش کوتاه بیایند.

۳. ردِ ممیزی: چهار جدول#

فردا کسی می‌پرسد «چرا سامانه به تیکتِ من این جواب را داد؟». جوابِ «نمی‌دانم، مدل عوض شده» یک جوابِ فنی نیست، یک شکستِ طراحی است.

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

import hashlib
import json
import sqlite3

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import make_pipeline

DB = WORK / "audit.db"
db = sqlite3.connect(DB)
db.execute("PRAGMA foreign_keys = ON")
db.executescript("""
CREATE TABLE data_versions  (id TEXT PRIMARY KEY, rows INTEGER, upto_week INTEGER);
CREATE TABLE code_versions  (id TEXT PRIMARY KEY, note TEXT);
CREATE TABLE model_versions (
    id TEXT PRIMARY KEY,
    data_id TEXT NOT NULL REFERENCES data_versions(id),
    code_id TEXT NOT NULL REFERENCES code_versions(id),
    threshold REAL NOT NULL);
CREATE TABLE predictions (
    id INTEGER PRIMARY KEY,
    ticket_id TEXT NOT NULL,
    week INTEGER NOT NULL,
    answer INTEGER NOT NULL,
    model_id TEXT NOT NULL REFERENCES model_versions(id));
""")


def digest(payload):
    return hashlib.sha256(json.dumps(payload, ensure_ascii=False,
                                     sort_keys=True).encode("utf-8")).hexdigest()[:12]


def bare(text):
    """نسخهٔ کدِ اول: هنوز «ي» و «ك» عربی را اصلاح نمی‌کرد."""
    return " ".join(text.split())


CODE = {
    "c1": (bare, "بدونِ اصلاحِ «ي» و «ك» · آستانهٔ ۰٫۶۵"),
    "c2": (normalise, "با اصلاحِ «ي» و «ك» · آستانهٔ ۰٫۵۰"),
    "c3": (normalise, "با اصلاحِ «ي» و «ك» · آستانهٔ ۰٫۳۵ پس از ماتریسِ هزینه"),
}
RELEASES = ((10, "c1", 0.65), (14, "c2", 0.50), (18, "c3", 0.35))
MODELS = {}
for week, code_id, threshold in RELEASES:
    clean, note = CODE[code_id]
    rows = [t for t in TICKETS if t["week"] < week]
    data_id = digest([t["ticket_id"] for t in rows])
    model = make_pipeline(CountVectorizer(), LogisticRegression(max_iter=1000))
    model.fit([clean(r["text"]) for r in rows], [r["escalated"] for r in rows])
    db.execute("INSERT OR IGNORE INTO data_versions VALUES (?, ?, ?)",
               (data_id, len(rows), week))
    db.execute("INSERT OR IGNORE INTO code_versions VALUES (?, ?)", (code_id, note))
    model_id = f"m-{data_id}-{code_id}"
    db.execute("INSERT INTO model_versions VALUES (?, ?, ?, ?)",
               (model_id, data_id, code_id, threshold))
    MODELS[model_id] = (clean, model, threshold)
db.commit()
print("نسخه‌ها ثبت شد:",
      db.execute("SELECT COUNT(*) FROM data_versions").fetchone()[0], "دادهٔ ·",
      db.execute("SELECT COUNT(*) FROM code_versions").fetchone()[0], "کدِ ·",
      db.execute("SELECT COUNT(*) FROM model_versions").fetchone()[0], "مدل")
نسخه‌ها ثبت شد: 3 دادهٔ · 3 کدِ · 3 مدل

شناسهٔ نسخهٔ داده از خودِ داده ساخته می‌شود، نه از تاریخ. همان اثرِ انگشتِ محتوای ترمِ ۲ فصلِ ۴: اگر کسی فردا همان اسم را روی دادهٔ متفاوتی بگذارد، اثرِ انگشت لو می‌دهدش.

و سه نسخهٔ کد سه چیزِ متفاوت‌اند، نه سه شماره. c1 هنوز «ي» و «ك» عربی را اصلاح نمی‌کرد — همان باگی که فصلِ ۱ با git bisect پیدایش کرد. این تفاوت در بخشِ ۶ خودش را نشان می‌دهد.

۴. سرو کن، و همان لحظه ثبت کن#

LIVE = [(row[0], row[1]) for row in db.execute(
    "SELECT m.id, d.upto_week FROM model_versions m"
    " JOIN data_versions d ON d.id = m.data_id ORDER BY d.upto_week")]


def live_at(week):
    """کدام نسخهٔ مدل در آن هفته زنده بود."""
    return [model_id for model_id, since in LIVE if since <= week][-1]


served = []
for ticket in TICKETS:
    if ticket["week"] < 10:
        continue
    model_id = live_at(ticket["week"])
    clean, model, threshold = MODELS[model_id]
    score = model.predict_proba([clean(ticket["text"])])[0][1]
    served.append((ticket["ticket_id"], ticket["week"], int(score >= threshold), model_id))
db.executemany("INSERT INTO predictions (ticket_id, week, answer, model_id)"
               " VALUES (?, ?, ?, ?)", served)
db.commit()
print("پیش‌بینیِ ثبت‌شده:", len(served),
      "· حجمِ پایگاه داده به ازای هر پیش‌بینی:",
      round(DB.stat().st_size / len(served), 1), "بایت")
پیش‌بینیِ ثبت‌شده: 1400 · حجمِ پایگاه داده به ازای هر پیش‌بینی: 61.4 بایت

۶۱٫۴ بایت. این کلِ هزینهٔ قابلِ ممیزی بودن است — و شاملِ هر چهار جدول و همهٔ کلیدهایشان می‌شود. بحثِ «ثبتِ رد گران است» معمولاً بدونِ این عدد انجام می‌شود.

و یک جزئیِ مهم: model_id هنگامِ سرو نوشته می‌شود، نه بعداً. اگر بعداً بنویسی‌اش، داری حدس می‌زنی — و بخشِ ۶ نشان می‌دهد آن حدس چقدر غلط درمی‌آید.

۵. یک شماره، و کلِ داستان#

QUERY = """
SELECT p.ticket_id, p.week, p.answer, m.id, m.threshold, d.id, d.rows, d.upto_week, c.note
FROM predictions p
JOIN model_versions m ON m.id = p.model_id
JOIN data_versions  d ON d.id = m.data_id
JOIN code_versions  c ON c.id = m.code_id
WHERE p.id = ?
"""
row = db.execute(QUERY, (200,)).fetchone()
print("پیش‌بینیِ شمارهٔ ۲۰۰")
print("  تیکت:", row[0], "· هفته:", row[1], "· جواب:", row[2])
print("  نسخهٔ مدل:", row[3], "· آستانه:", row[4])
print("  نسخهٔ داده:", row[5], "·", row[6], "ردیف تا هفتهٔ", row[7])
print("  نسخهٔ کد:", row[8])
پیش‌بینیِ شمارهٔ ۲۰۰
  تیکت: TK-01200 · هفته: 11 · جواب: 0
  نسخهٔ مدل: m-b5f1806dfda0-c1 · آستانه: 0.65
  نسخهٔ داده: b5f1806dfda0 · 1000 ردیف تا هفتهٔ 10
  نسخهٔ کد: بدونِ اصلاحِ «ي» و «ك» · آستانهٔ ۰٫۶۵

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

۶. بازتولید: مدرک، نه اعتماد#

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

TEXT = {t["ticket_id"]: t["text"] for t in TICKETS}


def reproduce(pinned=True):
    """جوابِ هر پیش‌بینی را دوباره می‌سازد — یک بار از روی رد، یک بار با حدسِ مدلِ فعلی."""
    latest = LIVE[-1][0]
    same = 0
    for ticket_id, _, answer, model_id in served:
        clean, model, threshold = MODELS[model_id if pinned else latest]
        score = model.predict_proba([clean(TEXT[ticket_id])])[0][1]
        same += int(score >= threshold) == answer
    return same


print("بازتولیدِ هر", len(served), "پیش‌بینی:")
print("  با ردِ ثبت‌شده     :", reproduce(True), "از", len(served))
print("  با حدسِ مدلِ فعلی  :", reproduce(False), "از", len(served))
بازتولیدِ هر 1400 پیش‌بینی:
  با ردِ ثبت‌شده     : 1400 از 1400
  با حدسِ مدلِ فعلی  : 1320 از 1400
try:
    db.execute("INSERT INTO predictions (ticket_id, week, answer, model_id)"
               " VALUES (?, ?, ?, ?)", ("TK-99999", 20, 1, "m-یک-چیزی"))
    db.commit()
except sqlite3.IntegrityError as error:
    print("sqlite3.IntegrityError:", error)
print("پیش‌بینیِ ثبت‌شده با نسخهٔ مدلِ ناشناخته:",
      db.execute("SELECT COUNT(*) FROM predictions WHERE ticket_id = 'TK-99999'").fetchone()[0])
sqlite3.IntegrityError: FOREIGN KEY constraint failed
پیش‌بینیِ ثبت‌شده با نسخهٔ مدلِ ناشناخته: 0

۱۴۰۰ از ۱۴۰۰ در برابرِ ۱۳۲۰ از ۱۴۰۰.

آن ۸۰ اختلاف تصادفی نیستند: هر کدام یک تیکتِ واقعی‌اند که اگر صاحبش شکایت کند و تو با مدلِ امروز بازسازی‌اش کنی، جوابِ غلطی به‌ش می‌دهی و مطمئن هم هستی. بدترین شکلِ اشتباه همین است — اشتباهی که مدرک هم برایش داری.

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

📏 اندازه بگیر: با چه چیزی مقایسه شد؟ بازتولید از روی رد، در برابرِ رایج‌ترین جانشینش در دنیای واقعی: «حتماً همان مدلِ فعلی بوده». روی کدام داده؟ روی همهٔ ۱۴۰۰ پیش‌بینیِ ثبت‌شده، نه یک نمونه. با چند seed؟ اینجا seed معنا ندارد و همین را باید گفت: بازتولید یا قطعی است یا نیست. عددِ ۱۴۰۰ از ۱۴۰۰ اگر ۱۳۹۹ بود، ردِ ما ناقص بود — نه «تقریباً خوب». و آشفتگیِ بخشِ ۲ ۵۰۰ قرعه داشت، چون آنجا ورودی قضاوتِ آدم بود.

🔧 اگر کار نکرد: اگر بلوکِ آخر به‌جای IntegrityError بی‌صدا ردیف را ثبت کرد، PRAGMA foreign_keys = ON اجرا نشده — sqlite3 به‌طورِ پیش‌فرض کلیدِ خارجی را نادیده می‌گیرد و این تنظیم به‌ازای هر اتصال است، نه به‌ازای هر پایگاه داده. اگر sqlite3.OperationalError: table data_versions already exists گرفتی، سلولِ ساختِ جدول‌ها را دوباره اجرا کرده‌ای؛ نوت‌بوک را از سلولِ راه‌اندازی از نو بزن، چون همان سلول پوشهٔ کار را پاک می‌کند. و اگر شمارهٔ ۲۰۰ در جدولت چیزِ دیگری بود، پیش‌بینی‌ها را با ترتیبِ متفاوتی ثبت کرده‌ای — شمارهٔ خودکار به ترتیبِ درج وابسته است و همین یکی از دلایلی است که شناسهٔ پایدارتر (مثلاً شناسهٔ تیکت) بهتر است.

🤖 از دستیارت بپرس: «تفاوتِ ثبتِ رد (audit log) با لاگِ معمولیِ برنامه چیست؟» بعد این را بپرس: «اگر قانونی مجبورم کند بگویم یک تصمیمِ خودکار چرا گرفته شده، کدام ستون‌ها را باید از همین حالا ذخیره کنم؟» — به هر ستونی که پیشنهاد می‌دهد این سؤال را بزن: «اگر این را نداشته باشم، دقیقاً کدام سؤال بی‌جواب می‌ماند؟»

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

کلمه تلفظ به حروف فارسی یعنی چه
risk register ریسک رجیستر سیاههٔ ریسک‌ها با احتمال، اثر و نگهبانِ هر کدام
⁦likelihood × impact⁩ لایکلی‌هود ایمپکت امتیازِ ریسک: احتمالِ رخ دادن ضربدرِ شدتِ اثرش
audit trail آدیت تریل زنجیرهٔ ثبت‌شده‌ای که هر خروجی را به ورودی‌هایش برمی‌گرداند
lineage لینیج تبارِ یک داده یا مدل: از کجا و با چه چیزی ساخته شد
foreign key فارن کی قیدی که نمی‌گذارد ردیفی به چیزِ ناموجود ارجاع بدهد
sensitivity analysis سنسیتیویتی انالیسیس سنجشِ اینکه نتیجه چقدر به فرض‌های ورودی وابسته است

تمرین‌ها

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

در فصل بعد#

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

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

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

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