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

فصل ۸ از ۹

پیشرفت ترم
۰٪

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

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

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

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

یک ماشینِ چاپ که پیش از عبورِ کاغذ، بخش‌هایی از آن را با مهرِ توپُر می‌پوشاند

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

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

قبل از شروع#

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

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

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

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

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

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

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)
تیکت‌ها: 1240 · تیکتِ دارای دادهٔ حساس: 157
به تفکیکِ نوع: {'melli': 50, 'phone': 59, 'email': 48}

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

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

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

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"])
پیدا شد 80 از 157 · بازیافت 0.510
نمونهٔ گم‌شده‌ها:
    melli ۳۰۱۶۶۱۳۱۸۶
    melli ۲۶۱۴۰۱۴۱۹۳
    phone ۰۹۸۸۱۸۱۷۴۱۴

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

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

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

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))
گم‌شده به تفکیکِ نوع: {'melli': 31, 'phone': 43, 'email': 3}
چندتاشان رقمِ فارسی دارند: 72 از 77

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

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

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

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

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]))
  خام            پیدا شد  80 از 157 · بازیافت 0.510
  + رقمِ یکسان   پیدا شد 151 از 157 · بازیافت 0.962
  + حذفِ اعراب   پیدا شد 155 از 157 · بازیافت 0.987
   مانده: melli ۸۷۱۹۵۱۸۴۵۱ · متنِ تیکت: ''
   مانده: melli 4490988360 · متنِ تیکت: ''

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

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

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

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

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

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)
ردیف‌های علامت‌خورده: 164 · کلِ تطبیق‌ها: 164
تطبیقِ نادرست: 0
precision روی تطبیق‌ها: 1.0

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

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

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

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

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

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

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

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

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

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}]")
  متنِ خام       F1 0.2554  [0.151–0.351]
  پاک‌سازی‌شده   F1 0.2653  [0.131–0.410]
  بدونِ هر عدد   F1 0.2708  [0.148–0.380]

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

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

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

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

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

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)
ستون‌های قبل: 10 · بعد: 9
KeyError: 'customer_id'

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

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}))
گروه‌های یکتا — قبل: 253 · بعد: 253
مشتریِ مشترکِ دو طرف بعد از نام‌مستعار: 0

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

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

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

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))
مهلتِ نگه‌داری از 2031-05-01 → 426 از 1195 (35.6٪)
تشدید در دادهٔ مانده: 37 · در کلِ داده: 110

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

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

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}]")
  همهٔ تاریخچه   F1 0.2653  [0.131–0.410]
  فقط دو ماهِ آخر F1 0.2117  [0.143–0.269]

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

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

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

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

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

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

تمرین‌ها

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

در فصل بعد#

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

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

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