Deployment, MLOps, and Security › AI Security and Privacy › Day 346
Day 346: Data Privacy and PII Handling
Master production AI data privacy: implement differential privacy with Laplace noise, build cryptographic zero-knowledge PII token vaults, enforce k-anonymity, and design GDPR-compliant machine unlearning pipelines in Python.
Hands-on lab for this lesson
Lab files on GitHub: https://github.com/ai-roadmap-365/ai-roadmap-365.github.io/tree/main/labs/sections/deployment-mlops-and-security/day-346-data-privacy-and-pii-handling
- Get the hands-on files. Clone the labs repository once (you can reuse this clone for every lesson). This works on macOS, Linux, and Windows (PowerShell or WSL):
git clone https://github.com/ai-roadmap-365/ai-roadmap-365.github.io.git cd ai-roadmap-365.github.io - Open this lesson's lab. Move into the directory for this specific day. Every lab lives at the same predictable path — section / subsection / week / day:
cd labs/sections/deployment-mlops-and-security/day-346-data-privacy-and-pii-handling - Read the lab guide. Open `README.md` in that directory. It lists the exact commands, what each does, the expected output, and how to check your work — read it before running anything.
- Run it and check your work. Follow the README's "How to run" section: run the example first to see the finished result, then complete the numbered exercises in `starter/`, then run the tests. The tests pass (exit 0) only when your work is correct.
bash tests/run_tests.sh # or the test command named in the lab README
You can also open the lab as a local page (works offline, shows the file tree and expected output).
Learning objectives
By the end of this lesson you will be able to:
- Formulate Differential Privacy (DP) with epsilon-delta bounds and implement calibrated Laplace and Gaussian noise addition.
- Design Zero-Knowledge PII Tokenization Vaults replacing SSNs, credit cards, and emails with deterministic HMAC tokens before LLM ingress.
- Implement k-Anonymity and l-Diversity data sanitization algorithms for fine-tuning dataset preparation.
- Evaluate GDPR Article 17 'Right to be Forgotten' compliance and machine unlearning techniques for LLM model weights.
- Build a production Privacy Preserving Ingress & Token Vault Gateway in Python with reversible pseudonymization and audit logging.
Prerequisites
Why this matters
Sending sensitive user data into third-party cloud LLMs or embedding unredacted customer records into RAG vector databases violates fundamental data privacy regulations (GDPR, CCPA, HIPAA) and creates severe legal liability:
- Mass PII Exposure via Model Memorization: Deep neural networks memorize rare sequence tokens in their training data. Attackers query models with targeted prefix prompts to reconstruct credit card numbers, home addresses, and private medical histories.
- Regulatory Penalties (GDPR Article 83): Non-compliance with privacy mandates can result in fines up to 20 million euros or 4% of global annual turnover.
- Right to Erasure (Article 17) Violations: When a customer requests deletion, an organization unable to scrub that person’s influence from fine-tuned weights or vector indices faces immediate regulatory sanctions.
Production AI architectures must enforce rigorous privacy controls: Zero-Knowledge PII Token Vaults, Differential Privacy noise mechanisms, k-anonymity dataset pruning, and machine unlearning protocols.
The idea in plain language
Think of AI data privacy like submitting medical records to a research study through a privacy-preserving legal intermediary:
- The Danger (Sending Raw Medical Records): You hand a patient’s unredacted hospital chart directly to an external analyst (Direct Cloud PII Leak).
- The Privacy Intermediary (Zero-Knowledge Token Vault): A secure hospital registrar replaces the patient’s name with
<PATIENT_904>and their address with<REGION_WEST>. The external analyst processes the chart, generates medical insights, and refers to<PATIENT_904>. Upon return, the registrar swaps the real name back before delivering results to the primary care physician (Reversible Pseudonymization). - Differential Privacy (The Blur Filter): When publishing hospital statistics, the registrar adds mathematically calibrated random noise so that an outside observer cannot deduce whether any specific individual was admitted to the hospital.
Historical background
Privacy engineering in AI evolved through four major eras:
1. The Quasi-Identifier Era (1998–2006)
Latanya Sweeney demonstrated that 87% of the US population can be uniquely identified by the combination of 5-digit ZIP code, gender, and date of birth, leading to the formulation of $k$-Anonymity and $l$-Diversity.
2. The Differential Privacy Revolution (2006–2016)
Cynthia Dwork introduced Differential Privacy, establishing the global mathematical gold standard for statistical data release and bounding individual disclosure risks.
3. Differentially Private SGD (DP-SGD) (2016–2022)
Abadi et al. developed DP-SGD, applying gradient clipping and Gaussian noise during backpropagation to train neural networks with provable differential privacy guarantees.
4. Zero-Knowledge Token Vaults and Machine Unlearning (2023–Present)
Generative AI required bidirectional, real-time prompt de-identification gateways and algorithmic weight unlearning to comply with global GDPR Article 17 mandates.
What it is — and what it is not
Let us define the operational principles of production AI data privacy:
What AI Data Privacy Is:
- Enforcing Zero-Knowledge Token Vaults that pseudonymize all sensitive PII (names, SSNs, credit cards, emails) before LLM prompt transmission.
- Calibrating Laplace and Gaussian noise injection via Differential Privacy ($\epsilon, \delta$) to protect aggregate dataset releases.
- Grouping tabular training records into $k$-anonymous equivalence classes ($k \ge 5$) to prevent linkage re-identification.
- Maintaining cryptographic key enclaves that allow targeted record deletion and pseudonym mapping erasure.
What AI Data Privacy Is Not:
- Trusting external cloud LLM vendor terms of service without technical de-identification barriers.
- Assuming simple asterisk masking (e.g.
123-**-****) provides mathematical privacy against modern correlation attacks.
+-------------------------------------------------------------------------------+
| AI DATA PRIVACY ARCHITECTURE MATRIX |
+-------------------+-----------------------+-----------------------------------+
| Privacy Control | Mathematical Model | Deployment Layer |
+-------------------+-----------------------+-----------------------------------+
| PII Token Vault | Reversible HMAC Map | AI Gateway Ingress / Egress |
| Aggregate Egress | (epsilon, delta)-DP | Telemetry & Analytics Pipeline |
| Fine-Tuning Data | k-Anonymity / l-Div | Data Pre-Processing & Curation |
| Weight Training | DP-SGD (Grad Clipping)| Model Training / Fine-Tuning |
| Right to Erasure | Machine Unlearning | Post-Training Parameter Scrubbing |
+-------------------+-----------------------+-----------------------------------+
Why it was created and what problems it solves
Production privacy engineering resolves three critical risks in modern AI systems:
1. Preventing Unintended Training Memorization
By adding calibrated noise during DP-SGD training or sanitizing PII prior to RAG vector indexing, models cannot memorize or regurgitate private customer secrets.
2. Enabling Third-Party Cloud LLM Ingestion Without Compliance Breach
Enterprises in regulated industries (finance, healthcare, defense) can safely utilize commercial frontier models (e.g. GPT-4o, Claude 3.5 Sonnet) because raw PII never leaves the local enterprise perimeter.
3. Fulfilling the Right to be Forgotten (GDPR Article 17)
By replacing raw customer data with ephemeral pseudonym keys, deleting the key in the token vault instantly renders all downstream model responses and logs permanently de-identified without expensive model retraining.
How it works
Let us examine the mathematical foundations of Differential Privacy and the Laplace Mechanism:
1. The Definition of Differential Privacy
A randomized algorithm M satisfies (epsilon, delta)-Differential Privacy if for all neighboring datasets D_1, D_2 differing in a single individual’s record, and all output subsets S in Range(M):
P[M(D_1) in S] <= exp(epsilon) * P[M(D_2) in S] + delta
epsilon(Epsilon): The privacy loss parameter. Smallerepsilon(e.g.epsilon = 0.5) provides stronger mathematical privacy at the expense of adding more noise.delta(Delta): The probability of failure (typically set to< 1e-5).
2. The Laplace Noise Mechanism
To compute a private numerical query f(D) with global L1 sensitivity Delta f = max ||f(D_1) - f(D_2)||_1:
M(D) = f(D) + Laplace(0, Delta f / epsilon)
[Raw Ingress Query] ➔ [Compute Exact Metric f(D)] ➔ [Sample Noise from Laplace(0, Delta f / epsilon)] ➔ [Release Sanitized Metric]
An everyday analogy
Think of differential privacy like answering a survey about a sensitive topic using a coin flip:
- The Sensitive Question: “Have you ever stolen corporate property?”
- The Randomized Protocol (Local DP):
- Flip a private coin. If Heads ➔ answer truthfully.
- If Tails ➔ flip a second coin: Heads = “Yes”, Tails = “No”.
- The Plausible Deniability: Anyone observing your “Yes” response cannot know if you admitted to theft or simply flipped two Tails (Mathematical Privacy Guarantee).
- The Aggregate Truth: The surveyor knows 25% of responses are random noise and can algebraically subtract the noise to calculate the true corporate theft rate with extreme precision (Statistical Utility Retention).
Examples in practice
Let us build a complete Python Zero-Knowledge PII Token Vault and Differential Privacy Engine:
import re
import math
import random
from typing import Dict, Any, Tuple, List
class DifferentialPrivacyEngine:
@staticmethod
def laplace_mechanism(true_value: float, sensitivity: float, epsilon: float) -> float:
if epsilon <= 0:
raise ValueError("Epsilon privacy budget must be strictly positive.")
scale = sensitivity / epsilon
# Sample Laplace noise: Laplace(0, scale) via inverse transform sampling
u = random.random() - 0.5
noise = -scale * math.copysign(1.0, u) * math.log(1.0 - 2.0 * abs(u))
return round(true_value + noise, 4)
class PIITokenVault:
def __init__(self):
self.forward_map: Dict[str, str] = {}
self.reverse_map: Dict[str, str] = {}
self.entity_counters: Dict[str, int] = {"PERSON": 0, "SSN": 0, "EMAIL": 0, "CREDIT_CARD": 0}
# Regex PII extractors
self.ssn_pattern = re.compile(r"\b\d{3}-\d{2}-\d{4}\b")
self.email_pattern = re.compile(r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b")
self.cc_pattern = re.compile(r"\b(?:\d{4}-){3}\d{4}\b")
def tokenize_text(self, text: str) -> str:
tokenized = text
# 1. Replace SSNs
for match in self.ssn_pattern.findall(text):
if match not in self.forward_map:
self.entity_counters["SSN"] += 1
token = f"<SSN_{self.entity_counters['SSN']}>"
self.forward_map[match] = token
self.reverse_map[token] = match
tokenized = tokenized.replace(match, self.forward_map[match])
# 2. Replace Emails
for match in self.email_pattern.findall(text):
if match not in self.forward_map:
self.entity_counters["EMAIL"] += 1
token = f"<EMAIL_{self.entity_counters['EMAIL']}>"
self.forward_map[match] = token
self.reverse_map[token] = match
tokenized = tokenized.replace(match, self.forward_map[match])
# 3. Replace Credit Cards
for match in self.cc_pattern.findall(text):
if match not in self.forward_map:
self.entity_counters["CREDIT_CARD"] += 1
token = f"<CREDIT_CARD_{self.entity_counters['CREDIT_CARD']}>"
self.forward_map[match] = token
self.reverse_map[token] = match
tokenized = tokenized.replace(match, self.forward_map[match])
return tokenized
def detokenize_text(self, text: str) -> str:
detokenized = text
for token, raw_val in self.reverse_map.items():
detokenized = detokenized.replace(token, raw_val)
return detokenized
def forget_user_pii(self, raw_pii_value: str) -> bool:
if raw_pii_value in self.forward_map:
token = self.forward_map[raw_pii_value]
del self.forward_map[raw_pii_value]
del self.reverse_map[token]
return True
return False
if __name__ == "__main__":
vault = PIITokenVault()
raw = "User email is john.doe@example.com and SSN is 123-45-6789. Card: 4532-1234-5678-9012."
# 1. Tokenize for LLM ingress
sanitized = vault.tokenize_text(raw)
print(f"Sanitized Prompt: {sanitized}")
# 2. Detokenize LLM generation for client response
llm_resp = f"Processed account for <EMAIL_1> with card <CREDIT_CARD_1> successfully."
client_resp = vault.detokenize_text(llm_resp)
print(f"Detokenized Response: {client_resp}")
# 3. Differential Privacy Laplace Noise
noisy_avg = DifferentialPrivacyEngine.laplace_mechanism(true_value=50000.0, sensitivity=1000.0, epsilon=0.5)
print(f"DP Metric (Epsilon=0.5): {noisy_avg}")
Production Architecture Case Study: Healthcare AI Clinical Assistant
Consider a HIPAA-compliant clinical assistant processing electronic health records (EHR).
# Production Privacy Architecture: Clinical EHR Copilot
**Regulatory Standard:** HIPAA Security Rule & GDPR Art. 9 (Special Category Data)
**Deployment Infrastructure:** AWS Nitro Enclaves (Isolated Virtual Enclave)
## 1. Data Ingress & Tokenization
- Clinical notes containing patient names, MRNs (Medical Record Numbers), and phone numbers enter the isolated enclave.
- The In-Memory Token Vault converts identifiers into cryptographic surrogates (`<PATIENT_UUID>`, `<MRN_UUID>`).
- Clinical text is processed by a HIPAA-compliant frontier model.
## 2. Ephemeral Key Deletion (Right to Erasure)
- Session token mappings are stored exclusively in non-persistent RAM.
- Upon session termination (`DELETE /sessions/{id}`), encryption keys are cryptographically shredded from memory.
- Any logs stored in central telemetry contain only synthetic `<PATIENT_UUID>` identifiers.
4. Advanced Cryptographic Salt Tokenization and Enclave Hashing
In large multi-tenant platforms, simple sequential surrogates (e.g. <SSN_1>) can be susceptible to cross-session frequency analysis if token values are deterministically correlated across multiple user interactions. To eliminate this correlation vector:
- HMAC-SHA256 Salted Hashing: Every tenant organization is provisioned with an isolated 256-bit cryptographic salt stored exclusively within a Hardware Security Module (HSM).
- Ephemeral Session IVs: Each user conversation generates an ephemeral Initialization Vector (IV), ensuring that identical input strings produce distinct pseudonymous surrogate tokens across distinct sessions.
- Hardware Enclave Isolation: The forward and reverse mapping lookup tables reside strictly within hardware-isolated memory pages (e.g. AWS Nitro Enclaves, Intel SGX) where even host root administrators cannot inspect running memory buffers or process dumps.
+-------------------------------------------------------------------------------+
| CRYPTOGRAPHIC PII TOKENIZATION TOPOLOGY |
+-------------------+-------------------+-------------------+-------------------+
| Component | Security Domain | Isolation Layer | Cryptographic Key |
+-------------------+-------------------+-------------------+-------------------+
| Ingress Proxy | Public Internet | TLS 1.3 / mTLS | Edge Cert |
| Token Vault HSM | Hardware Enclave | Nitro / SGX RAM | AES-256-GCM / HMAC|
| Public LLM Router | Cloud VPC | Tokenized Only | ZERO Plaintext PII|
+-------------------+-------------------+-------------------+-------------------+
Detailed Failure Mode Taxonomy: AI Data Privacy Hazards
+-------------------------------------------------------------------------------+
| AI DATA PRIVACY FAILURE TAXONOMY |
+-------------------+-----------------------+-----------------------------------+
| Failure Mode | Root Cause Analysis | Architectural Mitigation |
+-------------------+-----------------------+-----------------------------------+
| Re-Identification | Quasi-identifiers | Enforce k-anonymity (k >= 5) on |
| via Linkage Attack| (ZIP, Age, Gender) | all published training datasets |
| Privacy Budget | Re-using DP queries | Track cumulative epsilon budget; |
| Exhaustion | without accounting | halt queries when epsilon > 5.0 |
| Unsanitized Cache | Storing raw prompts | Store only tokenized surrogate |
| Embeddings | in vector databases | vectors in public vector indices |
| Incomplete Memory | Deleting logs but | Apply machine unlearning or retrain|
| Scrubbing | keeping model weights | weights using privacy checkpoints |
+-------------------+-----------------------+-----------------------------------+
Deep Architectural Breakdown: Machine Unlearning Approaches
When a user exercises their GDPR Article 17 Right to Erasure:
1. Exact Retraining (Gold Standard, High Cost)
Retrain the model from scratch on dataset D \ {x_i}. Computationally infeasible for 70B+ parameter models (>$500,000 per retraining run).
2. SISA (Sharded, Isolated, Sliced, Aggregated)
Partition training data into S isolated shards and train sub-models. When user x_i requests deletion, retrain only the single affected shard (1/S compute cost).
3. Targeted Gradient Ascent (Approximate Unlearning)
Execute negative gradient steps on the sample loss Loss(x_i, theta) combined with a KL-divergence penalty on retaining the model’s performance across remaining data.
+-------------------------------------------------------------------------------+
| MACHINE UNLEARNING COMPARISON MATRIX |
+-------------------+-------------------+-------------------+-------------------+
| Approach | Privacy Guarantee | Compute Cost | Model Utility |
+-------------------+-------------------+-------------------+-------------------+
| Exact Retraining | 100% Guaranteed | 1.0x (Extreme) | 100% Preserved |
| SISA Sharding | 100% Guaranteed | 0.05x - 0.1x | 98% Preserved |
| Gradient Ascent | Approximate | 0.001x (Fast) | May degrade edge |
+-------------------+-------------------+-------------------+-------------------+
Implications: security, privacy, performance, scalability, and cost
1. Latency Overhead of In-Memory Token Vaults
Running regex tokenization and detokenization takes <1.5\text{ms} per request in Python, introducing negligible latency while ensuring complete PII isolation.
2. Differential Privacy Utility Trade-Off
Selecting $\epsilon = 0.1$ provides military-grade privacy but introduces significant noise variance. For enterprise analytics, $\epsilon \in [0.5, 2.0]$ delivers the optimal balance between privacy and business reporting utility.
Alternatives: free, open source, and commercial
| Tool / Framework | Type | Best Suited For | Key Capabilities |
|---|---|---|---|
| Microsoft Presidio | Open Source | PII Redaction & Vault | NER-based PII identification |
| Opacus (PyTorch) | Open Source | DP-SGD Training | Differentially private deep learning |
| Skyflow | Commercial SaaS | PII Data Privacy Vault | Zero-trust tokenization API |
| ARX Data Anonymizer | Open Source | k-Anonymity Curation | De-identification tool for research data |
Comparison with related concepts
+-----------------------+-----------------------+-----------------------+
| Dimension | Basic Redaction | DP + Token Vault |
+-----------------------+-----------------------+-----------------------+
| Reversibility | Irreversible (Lost) | Fully Reversible |
| Mathematical Bound | None (Heuristic) | Provable (Epsilon-DP) |
| Regulatory Defensibility| Weak (Vulnerable) | Gold Standard (GDPR) |
| Downstream Utility | Breaks Context | Preserves LLM Context |
+-----------------------+-----------------------+-----------------------+
When to use it — and when not to
Enforce Zero-Knowledge Token Vaults and DP for:
- All healthcare, banking, fintech, and enterprise HR applications.
- Ingestion of user-generated support tickets and conversational chats.
- Datasets shared across multi-tenant boundaries.
Lightweight Anonymization is Acceptable for:
- Synthetic benchmarking datasets with zero real human data.
Production Checklist: AI Data Privacy Hardening
- In-memory PII token vault operational for SSNs, emails, and credit cards.
- Ephemeral session key deletion mechanism implemented.
- Vector database embeddings computed only on de-identified texts.
- Differential Privacy Laplace noise calibrated with $\epsilon \le 2.0$.
- GDPR Article 17 machine unlearning / key shredding policy documented.
The AI connection
-
Models memorise rare sequences, which makes a training set containing a credit card number a model that can be prompted into reproducing it.
-
Embeddings are derived personal data. A vector built from an unredacted record carries that record’s information, and a vector index is very hard to erase from.
-
Erasure is the hardest AI privacy requirement. You cannot delete a person from fine-tuned weights, which is why key shredding and SISA sharding exist.
-
A token vault lets a regulated business use a frontier model — the raw identifier never leaves your perimeter, and the model reasons about a surrogate.
-
Differential privacy buys a provable bound, not a feeling. Epsilon is a number you choose and can defend, which is unusual among privacy controls.
Knowledge check
- What is the Laplace scale parameter formula in Differential Privacy? $b = \Delta f / \epsilon$, scaling noise directly with sensitivity and inversely with privacy budget.
- How does a token vault preserve LLM reasoning context while protecting PII? By replacing entities with surrogate tokens (
<PERSON_1>) so the model grasps relational semantics without seeing real identities. - What is k-Anonymity? Ensuring every combination of quasi-identifiers is shared by at least $k$ distinct individuals in the dataset.
Hands-on exercise
In this lab, you will build a Production PII Token Vault and Differential Privacy Engine in Python. Your implementation will:
- Detect and tokenize SSNs, emails, and credit card numbers into surrogate tokens.
- Maintain bidirectional mapping in memory and reverse detokenize model generations.
- Implement right-to-be-forgotten key deletion (
forget_user_pii). - Implement the Laplace mechanism for Differential Privacy noise injection.
Expected output
============================= test session starts ==============================
collected 5 items
tests/test_data_privacy.py ..... [100%]
============================== 5 passed in 0.02s ===============================
[TOKEN VAULT] Initialized Zero-Knowledge PII Token Vault.
[TOKENIZATION] Replaced SSN and email with synthetic surrogate tokens.
[DETOKENIZATION] Successfully restored raw PII for client delivery.
[RIGHT TO FORGET] Shredded PII key mapping; verification failed as expected.
[DIFFERENTIAL PRIVACY] Injected calibrated Laplace noise (Epsilon: 0.5).
Validate your work
Run the pytest test suite:
pytest tests/run_tests.sh
Troubleshooting
- Inverse sampling math: Use
math.copysign(1.0, u)to preserve positive and negative Laplace noise tails. - Key deletion: Verify both
forward_mapandreverse_mapkeys are deleted.
Common mistakes
- Re-using static token IDs across different users, causing entity collision across sessions.
Practice assignment
Extend the vault with Phone Number and Street Address Regex Extractors.
Extension challenge
Implement a Local Differential Privacy (LDP) Randomized Response Simulator evaluating binary surveys.
Quiz
Q1. What is the primary mathematical guarantee provided by (epsilon, delta)-Differential Privacy?
- One person's record cannot noticeably change the output
- The database will run 10x faster
- The data is encrypted on an optical disk
- All text is translated into Latin
Show answer
Answer: A. One person's record cannot noticeably change the output
Differential privacy mathematically bounds the influence of any single training sample or user record.
Q2. How does a 'Zero-Knowledge PII Token Vault' operate in an AI inference pipeline?
- It deletes all of the customer records permanently
- It swaps real PII for surrogates, then restores them
- It asks the user to retype their password
- It converts text into raw binary numbers
Show answer
Answer: B. It swaps real PII for surrogates, then restores them
Token vaults ensure third-party LLMs and logs never see or store raw identifiable customer data.
Q3. What is the definition of 'k-Anonymity' in tabular and text datasets?
- A dataset where every record appears exactly k times
- A dataset with k columns
- Each record is indistinguishable from k-1 others
- An algorithm that compresses data by a factor of k
Show answer
Answer: C. Each record is indistinguishable from k-1 others
k-Anonymity prevents re-identification attacks by grouping quasi-identifiers into equivalence classes of size >= k.
Q4. Why is GDPR Article 17 ('Right to Erasure / Right to be Forgotten') particularly challenging for Generative AI models?
- Because hard drives cannot delete files
- Because GPUs only support write-only memory
- Because the EU AI Act prohibits retraining
- Models memorise, so removal needs unlearning or retraining
Show answer
Answer: D. Models memorise, so removal needs unlearning or retraining
Extracting memorized knowledge from distributed neural network weights without full retraining is an active challenge.
Q5. In the Laplace Mechanism for Differential Privacy, how is the scale parameter b calculated given sensitivity Delta f and privacy budget epsilon?
- b = Delta f / epsilon
- b = epsilon * Delta f
- b = Delta f + epsilon
- b = log(epsilon)
Show answer
Answer: A. b = Delta f / epsilon
The Laplace scale parameter is b = Delta f / epsilon, adding noise proportional to global sensitivity and inversely proportional to epsilon.
Glossary
- Differential Privacy (DP)
- A mathematical framework bounding individual privacy loss in statistical releases.
- Epsilon (Privacy Budget)
- The privacy parameter quantifying maximum allowable information leakage; smaller epsilon means stronger privacy.
- Laplace Mechanism
- A DP algorithm adding noise drawn from a zero-mean Laplace distribution scaled by sensitivity/epsilon.
- PII Token Vault
- An isolated enclave replacing sensitive personal data with cryptographic surrogates before LLM ingress.
- Pseudonymization
- Processing personal data such that it can no longer be attributed to a specific subject without additional stored key information.
- k-Anonymity
- A data protection standard where each combination of quasi-identifiers matches at least k records.
- Machine Unlearning
- Algorithms designed to scrub memorized training samples from neural network weights without full re-training.
- Quasi-Identifier
- Non-unique attributes (e.g. ZIP code, birth date, gender) that combine to uniquely identify an individual.
Sources and further reading
- The Algorithmic Foundations of Differential Privacy (Dwork & Roth, 2014) — Foundations and Trends in Theoretical Computer Science (accessed 2026-08-30)
- Deep Learning with Differential Privacy (Abadi et al., 2016) — ACM CCS / arXiv (accessed 2026-08-30)
- Machine Unlearning: A Comprehensive Survey (Nguyen et al., 2022) — IEEE Transactions on Knowledge and Data Engineering (accessed 2026-08-30)
Kept in this browser, no account needed. Your progress page turns the whole record into one link you can bookmark or open on another device.