# فصل ۰۸ — حریمِ خصوصی در مسیرِ داده

<div dir="rtl">

# فصل ۰۸ — حریمِ خصوصی در مسیرِ داده

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

در متنِ تیکت‌های ما شمارهٔ تلفن و ایمیل و کدِ ملی هست. یک آشکارسازِ منظم می‌نویسیم و اجرایش می‌کنیم: **۵۱٪ را پیدا می‌کند.**

نیمی از دادهٔ حساس از دستش در می‌رود، و علتش هیچ ربطی به الگوها ندارد — **همان گامِ به‌ظاهر بی‌فایدهٔ فصلِ ۶ است.** با یکسان‌سازیِ رقم‌ها به **۹۶٪** می‌رسیم و با حذفِ اعراب به **۹۹٪**؛ دو موردِ باقی‌مانده اصلاً در متن نیستند.

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

![یک ماشینِ چاپ که پیش از عبورِ کاغذ، بخش‌هایی از آن را با مهرِ توپُر می‌پوشاند](/lesson-assets/t2-s08-privacy-in-pipeline/prompt/01-image-redaction-press.png)

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

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

## قبل از شروع

**از فصل ۶:** نرمال‌سازی. آنجا گفتیم گامِ رقم‌ها «هیچ واژه‌ای کم نکرد ولی نگهش می‌داریم». **این فصل بدهیِ آن جمله را می‌پردازد.**

**از فصل ۷:** تقسیمِ گروهی بر پایهٔ مشتری. بخشِ ۷ نشان می‌دهد چطور می‌شود هویتِ مشتری را حذف کرد **بدونِ** اینکه آن تقسیم را از دست بدهی.

> ⚠️ **مواظب باش:** همهٔ داده‌های حساسِ این پیکره **ساختگی‌اند** و ما خودمان کاشته‌ایمشان، پس فهرستِ درستشان را داریم و می‌توانیم بازیافت را دقیق حساب کنیم. **در دادهٔ واقعی چنین فهرستی نداری** — و تمرینِ اجباری دربارهٔ همین است.

> 📓 **نوت‌بوک:** [نوت‌بوک این فصل را در Colab باز کن](/notebooks/darbast/term-2-data-as-infrastructure/session-08-privacy-in-pipeline.ipynb) — همهٔ کدهای این فصل آماده و به‌ترتیب داخلش هست.

</div>

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

<div dir="rtl">

## ۱. چه چیزی در متن هست

</div>

```python
import csv

with open(WORK / "raw" / "tickets.csv", encoding="utf-8") as fh:
    rows = list(csv.DictReader(fh))
with open(WORK / "raw" / "planted_pii.csv", encoding="utf-8") as fh:
    planted = list(csv.DictReader(fh))

by_ticket = {}
for p in planted:
    by_ticket.setdefault(p["ticket_id"], []).append(p)
print("تیکت‌ها:", len(rows), "· تیکتِ دارای دادهٔ حساس:", len(by_ticket))
kinds = {}
for p in planted:
    kinds[p["kind"]] = kinds.get(p["kind"], 0) + 1
print("به تفکیکِ نوع:", kinds)
```

```text
تیکت‌ها: 1240 · تیکتِ دارای دادهٔ حساس: 157
به تفکیکِ نوع: {'melli': 50, 'phone': 59, 'email': 48}
```

<div dir="rtl">

**۱۵۷ تیکت از ۱۲۴۰ — یعنی ۱۳٪ — چیزی دارند که نباید داشته باشند.**

و این دقیقاً همان چیزی است که در سامانه‌های واقعی اتفاق می‌افتد: **فرمِ ثبتِ تیکت جای شماره تلفن ندارد، ولی کاربر آن را داخلِ متن می‌نویسد.** هیچ ستونی به اسمِ `phone` نداری و باز هم شماره‌ها را داری.

## ۲. آشکارساز، نسخهٔ اول

</div>

```python
import re

PATTERNS_V1 = {
    "phone": re.compile(r"09[0-9]{9}"),
    "melli": re.compile(r"(?<![0-9])[0-9]{10}(?![0-9])"),
    "email": re.compile(r"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}"),
}


def detect(text, patterns):
    found = []
    for kind, rx in patterns.items():
        found += [(kind, m.group(0)) for m in rx.finditer(text)]
    return found


def recall(patterns, prepare=lambda t: t):
    hit = miss = 0
    missed = []
    for p in planted:
        text = next(r["text"] for r in rows if r["ticket_id"] == p["ticket_id"])
        values = {v for _k, v in detect(prepare(text), patterns)}
        if prepare(p["value"]) in values:
            hit += 1
        else:
            miss += 1
            missed.append(p)
    return hit, miss, missed


hit, miss, missed = recall(PATTERNS_V1)
print(f"پیدا شد {hit} از {hit + miss} · بازیافت {hit / (hit + miss):.3f}")
print("نمونهٔ گم‌شده‌ها:")
for p in missed[:3]:
    print("   ", p["kind"], p["value"])
```

```text
پیدا شد 80 از 157 · بازیافت 0.510
نمونهٔ گم‌شده‌ها:
    melli ۳۰۱۶۶۱۳۱۸۶
    melli ۲۶۱۴۰۱۴۱۹۳
    phone ۰۹۸۸۱۸۱۷۴۱۴
```

<div dir="rtl">

**۵۱٪. نصفِ دادهٔ حساس از آشکارساز رد شد.**

و **اگر عددش را نمی‌گرفتی، فکر می‌کردی کار می‌کند** — چون هشتاد مورد پیدا کرد و هیچ خطایی هم نداد. **این خطرناک‌ترین حالتِ ممکن است: یک محافظِ نیمه‌کاره که به‌ت حسِ امنیت می‌دهد.**

## ۳. چرا گم شدند

</div>

```python
lost = {}
for p in missed:
    lost[p["kind"]] = lost.get(p["kind"], 0) + 1
print("گم‌شده به تفکیکِ نوع:", lost)
persian = sum(any("۰" <= ch <= "۹" for ch in p["value"]) for p in missed)
print("چندتاشان رقمِ فارسی دارند:", persian, "از", len(missed))
```

```text
گم‌شده به تفکیکِ نوع: {'melli': 31, 'phone': 43, 'email': 3}
چندتاشان رقمِ فارسی دارند: 72 از 77
```

<div dir="rtl">

**۷۲ از ۷۷ موردِ گم‌شده رقمِ فارسی دارند.**

`[0-9]` در الگوی ما فقط رقمِ لاتین را می‌گیرد، و کاربرِ فارسی‌زبان شماره‌اش را با `۰۹۱۲…` می‌نویسد. **این یک باگِ الگو نیست؛ یک فرضِ نانوشته دربارهٔ زبان است** — و همان فرضی است که در هر کتابخانهٔ آمادهٔ تشخیصِ دادهٔ حساس هم ممکن است پنهان باشد.

> 💡 **نکته:** در پایتون، `\d` برخلافِ `[0-9]` رقم‌های یونیکد — از جمله فارسی — را هم می‌گیرد. **ولی این تفاوت بینِ زبان‌های برنامه‌نویسی یکسان نیست** و در بیشترِ آن‌ها `\d` هم فقط لاتین است. تکیه کردن به این ریزه‌کاری، ساختنِ دامِ بعدی است؛ **یکسان‌سازیِ ورودی همیشه امن‌تر از هوشمند کردنِ الگوست.**

## ۴. و پنج موردِ دیگر

</div>

```python
DIGITS = str.maketrans("۰۱۲۳۴۵۶۷۸۹٠١٢٣٤٥٦٧٨٩", "01234567890123456789")
HARAKAT = re.compile("[ً-ْٰ]")


def prep_digits(t):
    return t.translate(DIGITS)


def prep_full(t):
    return HARAKAT.sub("", t.translate(DIGITS))


for name, prepare in (("خام", lambda t: t), ("+ رقمِ یکسان", prep_digits),
                      ("+ حذفِ اعراب", prep_full)):
    h, m, rest = recall(PATTERNS_V1, prepare=prepare)
    print(f"  {name:<14} پیدا شد {h:>3} از {h + m} · بازیافت {h / (h + m):.3f}")
last_missed = rest
for p in last_missed:
    text = next(r["text"] for r in rows if r["ticket_id"] == p["ticket_id"])
    print("   مانده:", p["kind"], p["value"], "· متنِ تیکت:", repr(text[:30]))
```

```text
  خام            پیدا شد  80 از 157 · بازیافت 0.510
  + رقمِ یکسان   پیدا شد 151 از 157 · بازیافت 0.962
  + حذفِ اعراب   پیدا شد 155 از 157 · بازیافت 0.987
   مانده: melli ۸۷۱۹۵۱۸۴۵۱ · متنِ تیکت: ''
   مانده: melli 4490988360 · متنِ تیکت: ''
```

<div dir="rtl">

**۵۱٪ به ۹۶٪ به ۹۹٪ — و دو موردِ آخر اصلاً در متن نیستند.**

- **یکسان‌سازیِ رقم‌ها ۷۱ مورد را نجات داد.** همان گامی که در فصلِ ۶ روی اندازهٔ واژگان **صفر** اثر داشت.
- **حذفِ اعراب چهار موردِ دیگر را گرفت.** یک کسره یا تشدید که وسطِ یک شماره افتاده، رشتهٔ ارقام را از وسط می‌شکند و الگو دیگر نمی‌خورد. **این را هیچ‌کس با چشم پیدا نمی‌کند.**
- **دو موردِ باقی‌مانده مالِ تیکت‌هایی‌اند که متنشان خالی است** — همان پنج ردیفِ بی‌متنِ فصلِ ۶. **پس بازیافتِ واقعیِ آشکارساز روی متنِ موجود صد درصد است**، و این را باید صریح گفت، نه اینکه ۹۸٫۷٪ را به‌عنوان سقف گزارش کرد.

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

## ۵. طرفِ دیگرِ ترازو: چند تطبیقِ اشتباه

بازیافتِ بالا به‌تنهایی هیچ ارزشی ندارد — با الگوی «هر عددی» هم صد درصد می‌گیری و کلِ داده را نابود می‌کنی.

</div>

```python
flagged = total_spans = 0
false_spans = []
for r in rows:
    spans = detect(prep_full(r["text"]), PATTERNS_V1)
    total_spans += len(spans)
    truth = {prep_full(p["value"]) for p in by_ticket.get(r["ticket_id"], [])}
    for kind, value in spans:
        if value not in truth:
            false_spans.append((kind, value, r["text"][:40]))
    if spans:
        flagged += 1
print("ردیف‌های علامت‌خورده:", flagged, "· کلِ تطبیق‌ها:", total_spans)
print("تطبیقِ نادرست:", len(false_spans))
print("precision روی تطبیق‌ها:",
      round((total_spans - len(false_spans)) / total_spans, 4))
for kind, value, where in false_spans:
    print("   ", kind, value, "|", where)
```

```text
ردیف‌های علامت‌خورده: 164 · کلِ تطبیق‌ها: 164
تطبیقِ نادرست: 0
precision روی تطبیق‌ها: 1.0
```

<div dir="rtl">

**صفر تطبیقِ اشتباه.**

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

> ✅ **چک کن:** اگر `precision` پایین بیاید، هزینه‌اش پنهان است: هر تطبیقِ اشتباه یعنی یک تکه از متنِ سالم پاک شده. **پس آشکارسازِ دادهٔ حساس دو متریک دارد و هر دو باید گزارش شوند** — دقیقاً مثلِ هر مسئلهٔ نامتوازنِ دیگری.

## ۶. سه راهِ برخورد

</div>

```python
import hashlib

SALT = "darbast-t2-salt"


def redact(text):
    text = prep_full(text)
    for kind, rx in PATTERNS_V1.items():
        text = rx.sub(f"<{kind}>", text)
    return text


def pseudonym(value):
    return "id_" + hashlib.sha256((SALT + value).encode("utf-8")).hexdigest()[:10]


sample = next(r for r in rows if r["ticket_id"] in by_ticket)
print("خام    :", sample["text"][-52:])
print("پاک‌شده:", redact(sample["text"])[-52:])
print("مشتری  :", sample["customer_id"], "→", pseudonym(sample["customer_id"]))
```

```text
خام    :  كارتم كسر شد و برگشت نخورده، كد مليُ‌ام ۲۳۳۵۰۸۶۶۴۹ 
پاک‌شده: ر از كارتم كسر شد و برگشت نخورده، كد ملي‌ام <melli> 
مشتری  : C-0243 → id_dfcf256147
```

<div dir="rtl">

سه ابزار داریم و هرکدام یک معامله‌اند:

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

> ⚠️ **مواظب باش:** **نام‌مستعار با ناشناس‌سازی یکی نیست.** فضای شماره‌های موبایل کوچک است؛ کسی که نمکِ تو را داشته باشد می‌تواند همهٔ حالت‌ها را `hash` کند و جدولِ معکوس بسازد. **نمک را مثلِ رمز نگه دار، و اگر واقعاً ناشناسی می‌خواهی، مقدار را دور بریز.** و بدونِ نمک، این کار عملاً هیچ محافظتی نمی‌دهد.

## ۷. حالا هزینه‌اش را اندازه بگیر

</div>

```python
import random

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import f1_score

ARABIC = {"ي": "ی", "ك": "ک", "ة": "ه", "أ": "ا", "إ": "ا", "ؤ": "و"}

seen, DATA = set(), []
for r in rows:
    key = tuple(r.values())
    if key in seen or not r["text"].strip():
        continue
    seen.add(key)
    t = r["text"]
    for a, b in ARABIC.items():
        t = t.replace(a, b)
    r["clean"] = " ".join(t.replace("‌", " ").split())
    DATA.append(r)

Y = [int(r["escalated"]) for r in DATA]
G = [r["customer_id"] for r in DATA]
VARIANTS = {
    "متنِ خام": [r["clean"] for r in DATA],
    "پاک‌سازی‌شده": [redact(r["clean"]) for r in DATA],
    "بدونِ هر عدد": [re.sub(r"[0-9]+", " ", prep_digits(r["clean"])) for r in DATA],
}


def group_split(groups, seed, frac=0.25):
    names = sorted(set(groups))
    random.Random(seed).shuffle(names)
    held, held_rows, target = set(), 0, frac * len(groups)
    for g in names:
        if held_rows >= target:
            break
        held.add(g)
        held_rows += sum(1 for x in groups if x == g)
    te = [i for i, g in enumerate(groups) if g in held]
    tr = [i for i, g in enumerate(groups) if g not in held]
    return tr, te


def oversample(xs, ys, seed):
    rng = random.Random(seed)
    minor = [i for i, y in enumerate(ys) if y == 1]
    major = [i for i, y in enumerate(ys) if y == 0]
    idx = list(range(len(ys))) + [rng.choice(minor) for _ in range(len(major) - len(minor))]
    rng.shuffle(idx)
    return [xs[i] for i in idx], [ys[i] for i in idx]


def score(texts, seed):
    tr, te = group_split(G, seed)
    xtr, ytr = oversample([texts[i] for i in tr], [Y[i] for i in tr], seed)
    vec = CountVectorizer(min_df=1)
    model = LogisticRegression(max_iter=2000, random_state=seed)
    model.fit(vec.fit_transform(xtr), ytr)
    pred = model.predict(vec.transform([texts[i] for i in te]))
    return f1_score([Y[i] for i in te], pred, zero_division=0)


for name, texts in VARIANTS.items():
    v = [score(texts, s) for s in range(5)]
    print(f"  {name:<14} F1 {sum(v) / 5:.4f}  [{min(v):.3f}–{max(v):.3f}]")
```

```text
  متنِ خام       F1 0.2554  [0.151–0.351]
  پاک‌سازی‌شده   F1 0.2653  [0.131–0.410]
  بدونِ هر عدد   F1 0.2708  [0.148–0.380]
```

<div dir="rtl">

**پاک کردنِ کلِ دادهٔ حساس هیچ هزینه‌ای نداشت — و حتی حذفِ **همهٔ** عددهای متن هم نداشت.**

میانگین‌ها ۰٫۲۵۵ و ۰٫۲۶۵ و ۰٫۲۷۱ اند و دامنه‌هایشان کاملاً روی هم افتاده‌اند. **پس نتیجهٔ درست این نیست که «پاک‌سازی مدل را بهتر کرد»؛ این است که «با این اندازهٔ داده، اثری قابلِ تشخیص ندارد».**

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

> 📏 **اندازه بگیر:** **با چه چیزی مقایسه شد؟** با همان مدل روی متنِ خام، و با یک نسخهٔ افراطی‌تر (بدونِ هیچ عددی) تا سقفِ ضرر هم دیده شود. **روی کدام داده؟** با **تقسیمِ گروهیِ** فصلِ ۷، چون تقسیمِ تصادفی هر سه ردیف را به یک اندازه متورم می‌کرد. **با چند `seed`؟** پنج‌تا، و دامنه‌ها همان چیزی‌اند که اجازه نمی‌دهند این جدول را به‌عنوان «بهبود» بخوانی.

## ۸. نگه‌داشتِ حداقلی، و چیزی که می‌شکند

</div>

```python
KEEP = ["ticket_id", "created_at", "channel", "category", "escalated",
        "rating", "handling_minutes"]
minimal = [{k: r[k] for k in KEEP} | {"customer_ref": pseudonym(r["customer_id"]),
                                      "text": redact(r["clean"])}
           for r in DATA]
print("ستون‌های قبل:", len(DATA[0]) - 1, "· بعد:", len(minimal[0]))
try:
    print(minimal[0]["customer_id"])
except KeyError as e:
    print("KeyError:", e)
```

```text
ستون‌های قبل: 10 · بعد: 9
KeyError: 'customer_id'
```

<div dir="rtl">

> 🔧 **اگر کار نکرد:** `KeyError: 'customer_id'` **همان چیزی است که باید بیفتد** و در پروژهٔ واقعی هم می‌افتد — چون یک مرحلهٔ پایین‌دستی که سال‌ها روی آن ستون حساب می‌کرد، ناگهان آن را ندارد. **راهِ غلط این است که ستون را برگردانی.** راهِ درست این است که مرحلهٔ پایین‌دستی را به ستونِ جانشین وصل کنی — و دقیقاً به همین دلیل، مینیمم‌سازی باید **قبل از** نوشتنِ مرحله‌های پایین‌دستی طراحی شود، نه بعد از آن.

</div>

```python
groups_after = [r["customer_ref"] for r in minimal]
print("گروه‌های یکتا — قبل:", len(set(G)), "· بعد:", len(set(groups_after)))
tr, te = group_split(groups_after, 0)
print("مشتریِ مشترکِ دو طرف بعد از نام‌مستعار:",
      len({groups_after[i] for i in tr} & {groups_after[i] for i in te}))
```

```text
گروه‌های یکتا — قبل: 253 · بعد: 253
مشتریِ مشترکِ دو طرف بعد از نام‌مستعار: 0
```

<div dir="rtl">

**۲۵۳ گروه قبل، ۲۵۳ گروه بعد — و تقسیمِ گروهیِ فصلِ ۷ دست‌نخورده کار می‌کند.**

این همان چیزی است که نام‌مستعار به‌ت می‌دهد و حذفِ کامل نمی‌دهد: **رابطهٔ «این دو تیکت مالِ یک نفرند» حفظ می‌شود، بدونِ اینکه بدانی آن نفر کیست.** برای مسیرِ داده، آن رابطه همان چیزی است که لازم داری؛ **هویت هیچ‌وقت لازم نبود.**

## ۹. مهلتِ نگه‌داری

</div>

```python
CUTOFF = "2031-05-01"
kept = [r for r in minimal if r["created_at"] >= CUTOFF]
print("مهلتِ نگه‌داری از", CUTOFF, "→", len(kept), "از", len(minimal),
      f"({100 * len(kept) / len(minimal):.1f}٪)")
print("تشدید در دادهٔ مانده:", sum(int(r["escalated"]) for r in kept),
      "· در کلِ داده:", sum(Y))
```

```text
مهلتِ نگه‌داری از 2031-05-01 → 426 از 1195 (35.6٪)
تشدید در دادهٔ مانده: 37 · در کلِ داده: 110
```

<div dir="rtl">

**دو سومِ داده رفت، و مهم‌تر: از ۱۱۰ نمونهٔ کلاسِ نادر فقط ۳۷ ماند.**

**مهلتِ نگه‌داری روی کلاسِ نادر همیشه سنگین‌تر می‌نشیند** — نه چون تبعیض قائل است، چون تعدادش از اول کم بوده و درصدِ یکسان از عددِ کوچک، عددِ کوچک‌تری باقی می‌گذارد.

</div>

```python
KEPT = {r["ticket_id"] for r in kept}
idx_kept = [i for i, r in enumerate(DATA) if r["ticket_id"] in KEPT]


def score_subset(texts, seed, subset):
    tr, te = group_split(G, seed)
    tr = [i for i in tr if i in subset]
    xtr, ytr = oversample([texts[i] for i in tr], [Y[i] for i in tr], seed)
    vec = CountVectorizer(min_df=1)
    model = LogisticRegression(max_iter=2000, random_state=seed)
    model.fit(vec.fit_transform(xtr), ytr)
    pred = model.predict(vec.transform([texts[i] for i in te]))
    return f1_score([Y[i] for i in te], pred, zero_division=0)


texts = VARIANTS["پاک‌سازی‌شده"]
sub = set(idx_kept)
full = [score(texts, s) for s in range(5)]
short = [score_subset(texts, s, sub) for s in range(5)]
print(f"  همهٔ تاریخچه   F1 {sum(full) / 5:.4f}  [{min(full):.3f}–{max(full):.3f}]")
print(f"  فقط دو ماهِ آخر F1 {sum(short) / 5:.4f}  [{min(short):.3f}–{max(short):.3f}]")
```

```text
  همهٔ تاریخچه   F1 0.2653  [0.131–0.410]
  فقط دو ماهِ آخر F1 0.2117  [0.143–0.269]
```

<div dir="rtl">

**میانگین از ۰٫۲۶۵ به ۰٫۲۱۲ آمد — ولی دامنه‌ها هنوز روی هم می‌افتند (۰٫۱۳–۰٫۴۱ در برابرِ ۰٫۱۴–۰٫۲۷).**

**پس گزارشِ صادقانه این است: «با پنج `seed` نتوانستیم افت را از نویز جدا کنیم؛ برای ادعای محکم به تکرارِ بیشتر نیاز است.»** نوشتنِ «مهلتِ نگه‌داری دقت را ۵ واحد پایین آورد» با این شواهد، همان کاری است که این ترم مدام دربارهٔ آن هشدار می‌دهد.

**و نکتهٔ عملی: مهلتِ نگه‌داری یک تصمیمِ فنی نیست، یک تعهد است.** عددش را حقوق و سیاستِ سازمان تعیین می‌کند؛ **کارِ تو این است که هزینه‌اش را با عدد روی میز بگذاری تا آن تصمیم آگاهانه گرفته شود.**

> 🤖 **از دستیارت بپرس:** «تفاوتِ `anonymization` و `pseudonymization` چیست و چرا `hash` کردنِ شمارهٔ تلفن ناشناس‌سازی حساب نمی‌شود؟» بعد این را هم بپرس: **«اگر ستون‌های حساس را حذف کنم ولی تاریخِ تولد و کدِ پستی و جنسیت را نگه دارم، هنوز می‌شود افراد را شناسایی کرد؟»** — جوابش مفهومِ `quasi-identifier` است و کاملاً عوض می‌کند که «دادهٔ حساس» را چطور تعریف کنی.

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

</div>

| کلمه | تلفظ به حروف فارسی | یعنی چه |
|---|---|---|
| PII | پی-آی-آی | داده‌ای که یک فردِ مشخص را شناسایی می‌کند |
| redaction | ریداکشن | جایگزینیِ مقدارِ حساس با برچسبِ نوعش |
| pseudonymization | سودونیمایزیشن | جایگزینیِ هویت با شناسه‌ای پایدار ولی بی‌معنا |
| anonymization | اَنونیمایزیشن | حذفِ برگشت‌ناپذیرِ امکانِ شناسایی |
| data minimization | دیتا مینیمایزیشن | نگه‌داشتنِ فقط چیزی که واقعاً لازم است |
| retention period | ریتنشن پیریود | مدتی که داده نگه داشته می‌شود و بعدش حذف |
| quasi-identifier | کوازی-آیدنتیفایر | ستونی که تنها بی‌خطر است ولی با بقیه شناسایی می‌کند |

<div dir="rtl">

## تمرین‌ها

قبل از تمرین، بدونِ نگاه به بالا جواب بده: چرا بازیافتِ آشکارساز بدونِ `precision` بی‌معناست؟

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

**تمرینِ ستاره‌دار ⭐:** یک الگوی چهارم اضافه کن: **شمارهٔ کارتِ بانکی** (چهار گروهِ چهاررقمی که ممکن است با فاصله یا خط تیره جدا شده باشند). حالا `precision` را دوباره حساب کن — **این بار روی متنی که عمداً چند شمارهٔ سفارشِ شانزده‌رقمی هم داخلش گذاشته‌ای.** بعد سؤالِ سخت: چطور می‌شود شمارهٔ کارت را از شمارهٔ سفارش تشخیص داد بدونِ اینکه به طولش تکیه کنی؟ (راهنمایی: شمارهٔ کارت یک رقمِ کنترلی دارد.) **بازیافت و `precision` را قبل و بعد از افزودنِ آن بررسی گزارش کن.**

## در فصل بعد

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

</div>

---
Source: https://yaadestan.com/courses/darbast/lessons/t2/s08-privacy-in-pipeline (یادستان, Yaadestan)
