# فصل ۰۴ — ریسک، ممیزی، ردِ تصمیم

<div dir="rtl">

# فصل ۰۴ — ریسک، ممیزی، ردِ تصمیم

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

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

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

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

![بایگانیِ برچسب‌خوردهٔ قطعات، با یک نخِ پیوسته از هر قطعه تا قالبِ سازنده‌اش](/lesson-assets/t6-s04-risk-and-audit/prompt/01-image-traced-back-to-the-mould.png)

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

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

## قبل از شروع

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

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

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

> 📓 **نوت‌بوک:** [نوت‌بوک این فصل را در Colab باز کن](/notebooks/darbast/term-6-team-and-delivery/session-04-risk-and-audit.ipynb) — همهٔ کدهای این فصل آماده و به‌ترتیب داخلش هست.

</div>

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

<div dir="rtl">

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

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

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

</div>

```python
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%})")
```

```text
ریسک                                احتمال   اثر  امتیاز            نگهبانِ خودکار
نشتیِ ردیفِ تکراری در تقسیم              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%)
```

<div dir="rtl">

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

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

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

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

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

</div>

```python
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%}")
```

```text
در 500 آشفتگیِ ±۱ روی هر دو ستون:
  ریسکِ شمارهٔ یک همان ماند: 47.8%
  مجموعهٔ سه‌تای اول همان ماند: 19.2%
  ماندن در سه‌تای اول، به تفکیک:
    نشتیِ ردیفِ تکراری در تقسیم          82.6%
    ارزیابیِ آفلاین وارونه می‌شود        85.8%
    مدل بی‌صدا بدتر می‌شود               38.0%
    سقوطِ زیرگروه پس از انتشار           39.4%
    قراردادِ داده از بالادست می‌شکند     28.4%
```

<div dir="rtl">

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

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

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

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

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

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

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

</div>

```python
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], "مدل")
```

```text
نسخه‌ها ثبت شد: 3 دادهٔ · 3 کدِ · 3 مدل
```

<div dir="rtl">

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

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

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

</div>

```python
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), "بایت")
```

```text
پیش‌بینیِ ثبت‌شده: 1400 · حجمِ پایگاه داده به ازای هر پیش‌بینی: 61.4 بایت
```

<div dir="rtl">

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

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

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

</div>

```python
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])
```

```text
پیش‌بینیِ شمارهٔ ۲۰۰
  تیکت: TK-01200 · هفته: 11 · جواب: 0
  نسخهٔ مدل: m-b5f1806dfda0-c1 · آستانه: 0.65
  نسخهٔ داده: b5f1806dfda0 · 1000 ردیف تا هفتهٔ 10
  نسخهٔ کد: بدونِ اصلاحِ «ي» و «ك» · آستانهٔ ۰٫۶۵
```

<div dir="rtl">

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

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

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

</div>

```python
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))
```

```text
بازتولیدِ هر 1400 پیش‌بینی:
  با ردِ ثبت‌شده     : 1400 از 1400
  با حدسِ مدلِ فعلی  : 1320 از 1400
```

```python
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])
```

```text
sqlite3.IntegrityError: FOREIGN KEY constraint failed
پیش‌بینیِ ثبت‌شده با نسخهٔ مدلِ ناشناخته: 0
```

<div dir="rtl">

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

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

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

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

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

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

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

</div>

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

<div dir="rtl">

## تمرین‌ها

قبل از تمرین، بدونِ نگاه به بالا جواب بده: چرا «۱۳۹۹ از ۱۴۰۰» برای یک ردِ ممیزی نمرهٔ قبولی نیست؟

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

**تمرینِ ستاره‌دار ⭐:** ردِ ممیزی را کامل کن. **ستونِ ورودیِ خامِ هر پیش‌بینی را هم ذخیره کن** (یا اثرِ انگشتش را) و بعد سه چیز را اندازه بگیر: بایت به ازای هر پیش‌بینی پس از این اضافه، سهمِ پیش‌بینی‌هایی که **بدونِ دسترسی به پایگاه دادهٔ اصلی** بازتولید می‌شوند، و زمانِ بازسازیِ یک پیش‌بینیِ منفرد. **و سؤالِ سخت را جواب بده: اگر متنِ تیکت دادهٔ شخصی باشد، ذخیرهٔ خامش با درسِ ترمِ ۲ فصلِ ۸ می‌خواند؟** جوابت باید بین «قابلِ ممیزی بودن» و «نگه‌داشتِ حداقلی» یک تصمیمِ صریح بگیرد و **همان تصمیم را به‌شکلِ تصمیم‌نامهٔ فصلِ قبل بنویسد**.

## در فصل بعد

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

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

</div>

---
Source: https://yaadestan.com/courses/darbast/lessons/t6/s04-risk-and-audit (یادستان, Yaadestan)
