Vision Systems & Engineering
Privacy in Computer Vision
What images reveal about the people and places in them, how detection followed by blurring, pixelation or a solid box tries to remove it and how an attacker who can model the redaction undoes blur and pixelation, and where federated learning, on-device processing, differential privacy and data protection law fit.
intermediate
Privacy in computer vision is the problem of building and running vision systems without exposing the people, and the information about them, that cameras record. A photograph or a video frame shows faces, bodies, licence plates, screens, documents and places, including people who did not ask to be recorded and are not the reason the image was taken. Vision systems make this information easier to extract at scale, and a trained model can carry some of its training images with it. This article describes what images reveal, the anonymization methods used on images and datasets and how they fail, an example in which blurred and pixelated plates are re-identified, and where federated learning, on-device processing, differential privacy and data protection law fit. Privacy questions about datasets of people, such as consent and withdrawal, are introduced in dataset bias; the example’s blur is the Gaussian filter.
Definition
NIST’s AI Risk Management Framework counts “privacy-enhanced” among the characteristics of trustworthy AI systems and describes privacy as the norms and practices that help to safeguard human autonomy, identity and dignity; these typically address freedom from intrusion, limiting observation, or individuals’ agency to consent to disclosure or control of facets of their identities, such as body, data and reputation (NIST AI 100-1, 2023, §3.6). The same section notes two points that matter for vision: AI systems can present new risks to privacy by allowing inference to identify individuals or previously private information about them, and privacy-enhancing technologies (PETs) and data-minimizing methods, such as de-identification and aggregation of certain model outputs, support privacy-enhanced design but can, under conditions such as data sparsity, cost accuracy.
For images, two families of measures follow, in our summary. One changes the data: it removes or obscures what identifies people (faces, plates, text, metadata) before images are stored, shared or released. The other changes where data go and what leaves them: it processes images on the device, trains without collecting them, or limits what a trained model can reveal. The first family is judged by what an attacker can still recover from the released image; the second by what can be recovered from what the system transmits or publishes.
What Images Reveal
The threats differ by who holds the image and what they can compare it with. In our grouping:
- Identification of the people shown. A face, a gait or a body is a biometric trait; biometric recognition and face recognition systems match it against a gallery. Bystanders are recorded alongside the subject of an image: driving data record bystanders’ faces and licence plates, as autonomous driving perception notes, and robots in homes, hospitals and streets record people who have not agreed to it (robot perception).
- Linkage of a redacted image to a candidate. When the obscured content comes from a known, limited set (a licence plate format, an account number, a name in a staff list), an attacker who can reproduce the redaction compares the released image with redacted versions of every candidate. This is the attack of the example below.
- Inference beyond identity. Background, signs, landmarks and timestamps can locate an image; NIST’s wording above covers inference of previously private information. Person re-identification links the same person across cameras, which video surveillance applies at the scale of a site.
- What a trained model gives back. Image generation describes Carlini et al.’s extraction of training images from diffusion models. Other attacks on trained models, membership inference (whether a given image was in the training set) and model inversion, are named here only.
- What the file carries. Metadata and text burned into pixels identify subjects independently of what the image shows; medical computer vision describes DICOM’s de-identification profiles and their limits, and neuroimaging analysis the face contained in structural brain scans.
Anonymization by Detection and Obfuscation
In the dataset pipelines described below, image anonymization has two stages: a detector finds the regions to protect, and an obfuscation removes or hides what they contain. The dataset articles record the pipelines their creators describe. nuScenes detects faces and licence plates “for high recall” and blurs the detections (nuScenes); SA-1B detected faces with RetinaFace and blurred them, blurred licence plates with a model that has not been made public, and does not release the unaltered photographs (SA-1B); ADE20K’s current release blurs faces and licence plates (ADE20K); Ego4D’s partners generally required informed consent of the camera wearers and blurring of faces and other identifying information in public spaces (Ego4D).
Detection is the weak link of the first stage, in our reasoning. A face or plate the detector misses is released unaltered, so the protection of a dataset is bounded by the detector’s recall on the hardest cases (small, occluded, turned away), not by the strength of the blur. The nuScenes statement that its detectors are run for high recall is a choice of operating point in this sense: false positives cost some blurred background, false negatives cost privacy. Face detection describes the detectors and their errors on small and occluded faces.
The second stage takes one of four forms, in our grouping:
- Blurring convolves the region with a two-dimensional Gaussian (Hill et al., 2016, §1); its strength is the standard deviation in pixels.
- Pixelation, which Hill et al. call mosaicing (also pixelization), superposes a rectangular grid on the region and replaces each cell by the average of its pixels; its strength is the block size .
- A solid box replaces the region by a constant.
- Replacement fills the region with other content, for example a generated face or re-rendered text.
Blurring and pixelation are lossy, so they cannot in general be reversed. Hill et al. place them in a middle ground between transforms that can be inverted and those that obscure the region entirely, and point out that if the original has predictable regularities, as text does, enough information may remain to recover it, or at least to narrow its possibilities (§1). They modelled mosaiced text with hidden Markov models trained on rendered, mosaiced examples, and compared them with their implementation of a brute-force method that Venkatraman described in a blog post: render every possible string, mosaic it the same way, and output the string whose mosaic is nearest to the redacted one (§1, §3.2). The paper’s text dates the blog post 2007, while its reference list gives 2014.
On seven-digit strings in a 24-point MICR font, both methods recovered the redacted text over a wide range of grid sizes, and both fell off as the grid size approached the font size, which they attribute to cells large enough to span several digits (§3.3, Fig. 7a). Under JPEG compression, applied before or after mosaicing, the brute-force method, which matches grid values by Euclidean distance, was easily misdirected, while the HMMs were fairly robust (Fig. 7b–c). For blurred text, they mosaiced the blurred image first and then decoded it; on sentences rendered in “24p Verdana”, the HMMs kept a score of 70%, which they treat as the threshold of sensible text, up to a blur radius of 45 pixels and the brute-force method up to 15 (§4, Fig. 17). Hill et al. report blur by a “blur radius” determined by the Gaussian’s standard deviation, a scale not compared numerically with the used below. Both methods need the parameters of the redaction (typeface, size, grid size and offsets); identifying the offsets was often the most time-consuming step, and an HMM trained at one vertical offset lost accuracy quickly at another (§3.4, §3.6, Fig. 14). Their conclusion is that mosaicing and blurring are not viable for text redaction; they recommend a solid bar, or better, replacing the text with a placeholder and re-rendering the document, which also hides the length of the redacted passage (§1, §5). Even a solid bar leaks length: they describe how Naccache and Whelan recovered text under a black bar from font metrics, given a short list of possible phrases (§1).
Faces are not text, but Hill et al. cite work showing similar weaknesses: Newton, Sweeney and Malin showed that face recognition software can recognize mosaiced faces from still images, and Cavedon, Foschini and Vigna used super-resolution to recover mosaiced faces from video of subjects who moved little between frames (as Hill et al., §1, describe them). McPherson, Shokri and Shmatikov’s “Defeating Image Obfuscation with Deep Learning” (2016) and Frome et al.’s “Large-scale Privacy Protection in Google Street View” (2009) were not read for this article and are named here only.
Example: Re-identifying Redacted Plates
The script below asks how much of a licence plate survives blur, pixelation and a solid box when the attacker can reproduce the redaction. The plates are synthetic seven-digit strings drawn with our own seven-segment glyphs; no font and no image of a person is used. The attacker is our analogue of Hill et al.’s brute-force baseline, applied to plates rather than text, so the outcomes test this analogue, not their HMMs or their data.
Plates. Each plate is a float image (rows by columns, row 0 at the top) with a background of 0.85 and dark digits of 0.15. A glyph is pixels with 2-pixel strokes, on a 12-pixel pitch starting at column 6 and row 4. Segments are rectangles drawn on a grid four times finer than the pixels, and each pixel is the mean of its fine cells, so the image records how much of each pixel the ink covers. Each plate is shifted by a random sub-pixel offset of 0, 0.25, 0.5 or 0.75 pixels in each axis, and Gaussian sensor noise with standard deviation 0.02 is added to the captured image before redaction. Plates are drawn uniformly from the digit strings.
Redactions, each released at the full resolution:
- Gaussian blur with pixels, SciPy’s
gaussian_filterwith border mode"nearest"and truncation at (SciPy’s default mode is"reflect"). - Pixelation with blocks pixels on a grid whose lines lie at rows and columns , with the grid offset drawn uniformly from for each plate. The image is padded by edge replication to whole blocks, each block is replaced by its mean, and the full-resolution image, with every block filled with its mean, is released; the array of block means alone carries the same information.
- A solid black box (value 0) over the whole plate.
Attacker. It knows the plate format, the redaction and its parameter, the plate’s sub-pixel offset and, unless stated, the grid offset. Knowing the sub-pixel offset is a generous assumption: Hill et al. identified such parameters by hand before decoding. For each plate it forms candidates, the true plate (candidate 0) and 999 distinct random plates, redacts the noise-free candidates and picks the one nearest to the released image in L2 distance. Squared distances within of the smallest are ties, broken uniformly at random. Because blur, pixelation (with replication padding) and the box are all linear, a redacted plate equals the redacted background minus the seven redacted characters; the script builds candidates that way and checks the identity on every plate.
The script prints:
- Checks: C1 renders without sensor noise and counts, for each blur and pixelation, how often the true plate is found among the trials in which no decoy’s redaction coincides with the true plate’s (squared distance above ), which must be every such trial; C2 the linearity identity, with a tolerance of ; C3 data properties (distinct glyphs, pixel range, at least three blank columns between glyphs, and the noise level, expected within 0.0005 of 0.02, a bar written in the plan after the planning script described in the process note had run; that script adds no noise); C4 that all candidates tie under the box in every trial.
- The attack under sensor noise, with exact (Clopper–Pearson) 95% intervals from
binomtest(...).proportion_ci(), against chance . - Noise added after redaction, Gaussian with standard deviation 0.05 or 0.2.
- An unknown grid offset: the attacker keeps the offsets under which the released image is most nearly constant inside each block, runs the attack under each and takes the overall nearest candidate.
- A per-character decoder that needs no candidate list: it decodes each position alone from its own 12-pixel cell (columns to ), comparing the cell with the ten redacted digits at that position and treating the other characters as absent. It is scored by the fraction of characters and of whole plates recovered, out of all plates (chance for a whole plate).
The script was run with python plates.py 0 200 (seed 0, 200 plates per condition), NumPy 2.3.5 and SciPy 1.16.3, and takes about 50 seconds on a laptop CPU (approximate, measured while other agents shared the machine).
import os
for v in ("OPENBLAS_NUM_THREADS", "OMP_NUM_THREADS", "MKL_NUM_THREADS"):
os.environ[v] = "1" # one BLAS thread, set before NumPy loads
import sys
import numpy as np
from scipy.ndimage import gaussian_filter
from scipy.stats import binomtest
SEED = int(sys.argv[1]) if len(sys.argv) > 1 else 0
T = int(sys.argv[2]) if len(sys.argv) > 2 else 200 # plates per condition
H, W, SS = 24, 96, 4 # image size (px) and supersampling factor
BG, INK = 0.85, 0.15 # plate background and ink levels
GW, GH, ST = 8, 16, 2 # glyph width, height and stroke (px)
PITCH, X0, Y0 = 12, 6, 4 # character pitch and top-left of the first glyph (px)
N = 1000 # candidates: the true plate and 999 random others
SIGMA_S = 0.02 # sensor noise, added before redaction
POST = (0.05, 0.2) # noise added after redaction
TOL = 1e-10 # squared distances this close count as ties
DIGITS = ["abcdef", "bc", "abdeg", "abcdg", "bcfg", "acdfg", "acdefg", "abc", "abcdefg", "abcdfg"]
REDACTIONS = [("blur", 1), ("blur", 2), ("blur", 4), ("blur", 8),
("pixelate", 2), ("pixelate", 4), ("pixelate", 8), ("pixelate", 16), ("box", 0)]
def glyph(d):
"""High-resolution (4x) mask of the seven-segment digit d."""
w, h, t = GW * SS, GH * SS, ST * SS
seg = {"a": (0, t, 0, w), "g": ((h - t) // 2, (h + t) // 2, 0, w), "d": (h - t, h, 0, w),
"f": (0, (h + t) // 2, 0, t), "b": (0, (h + t) // 2, w - t, w),
"e": ((h - t) // 2, h, 0, t), "c": ((h - t) // 2, h, w - t, w)}
m = np.zeros((h, w))
for s in DIGITS[d]:
y0, y1, x0, x1 = seg[s]
m[y0:y1, x0:x1] = 1.0
return m
def coverage(off):
"""Ink coverage (7 positions, 10 digits, H, W) at sub-pixel offset off, in quarter pixels."""
cov = np.zeros((7, 10, H, W))
for d in range(10):
g = glyph(d)
for p in range(7):
hr = np.zeros((H * SS, W * SS))
y, x = Y0 * SS + off[0], (X0 + PITCH * p) * SS + off[1]
hr[y:y + GH * SS, x:x + GW * SS] = g
cov[p, d] = hr.reshape(H, SS, W, SS).mean(axis=(1, 3)) # 4x4 box = pixel area
return cov
def render(cov, digits):
"""Plate image(s): background minus the ink of each position's digit (glyphs never overlap)."""
digits = np.atleast_2d(digits)
img = np.full((len(digits), H, W), BG)
for p in range(7):
img -= (BG - INK) * cov[p][digits[:, p]]
return img
def pixelate(img, b, g):
"""Block means on a grid with lines at rows g[0] + kb and columns g[1] + kb; the image is
padded by edge replication to whole blocks, and each block is filled with its mean."""
pt, pl = (b - g[0]) % b, (b - g[1]) % b
Hp, Wp = -(-(H + pt) // b) * b, -(-(W + pl) // b) * b
pad = [(0, 0)] * (img.ndim - 2) + [(pt, Hp - H - pt), (pl, Wp - W - pl)]
q = np.pad(img, pad, mode="edge")
m = q.reshape(*q.shape[:-2], Hp // b, b, Wp // b, b).mean(axis=(-3, -1))
return np.repeat(np.repeat(m, b, axis=-2), b, axis=-1)[..., pt:pt + H, pl:pl + W]
def redact(img, kind, s, g=(0, 0)):
if kind == "blur":
return gaussian_filter(img, s, mode="nearest", truncate=4.0, axes=(-2, -1))
if kind == "pixelate":
return pixelate(img, s, g)
return np.zeros_like(img) # solid black box
def nearest(y, cands, rng):
"""Index of the candidate closest to y in L2, ties broken at random; also the distances."""
d = ((cands - y) ** 2).sum(axis=(-2, -1))
ties = np.flatnonzero(d <= d.min() + TOL)
return rng.choice(ties), ties.size, d
def per_character(y, rbg, rcov, rng):
"""Decode each position alone from its 12-px cell, other characters modelled as absent."""
out = []
for p in range(7):
c = slice(X0 + PITCH * p - 2, X0 + PITCH * p + GW + 2)
models = rbg[:, c] - (BG - INK) * rcov[p][:, :, c]
k, _, _ = nearest(y[:, c], models, rng)
out.append(k)
return np.array(out)
def grid_search(y, b):
"""Grid offsets whose blocks are most nearly constant in the released image (ties kept)."""
best = []
for axis, n in ((0, H), (1, W)):
dif = np.abs(np.diff(y, axis=axis))
score = [dif.take([i for i in range(n - 1) if (i + 1 - g) % b != 0], axis=axis).sum()
for g in range(b)]
best.append(np.flatnonzero(np.array(score) <= min(score) + TOL))
return [(gy, gx) for gy in best[0] for gx in best[1]]
def ci(k, n):
r = binomtest(int(k), int(n)).proportion_ci() # exact (Clopper-Pearson), 95%
return r.low, r.high
rng = np.random.default_rng(SEED)
offsets = [(oy, ox) for oy in range(SS) for ox in range(SS)]
COV = {o: coverage(o) for o in offsets}
BLUR = {(s, o): redact(COV[o], "blur", s) for s in (1, 2, 4, 8) for o in offsets}
# ---- data checks (C3) ----
g10 = np.array([glyph(d).ravel() for d in range(10)])
pair = np.sqrt(((g10[:, None] - g10[None]) ** 2).sum(-1))[np.triu_indices(10, 1)]
eights = [render(COV[o], np.full(7, 8))[0] for o in offsets]
gaps = []
for o, im in zip(offsets, eights):
ink_cols = (im < BG).any(axis=0)
for p in range(6):
lo, hi = X0 + PITCH * p, X0 + PITCH * (p + 1)
gaps.append(int((~ink_cols[lo:hi + 1]).sum()))
print(f"C3 data: min pairwise glyph distance {pair.min():.3f} (> 0); pixel range "
f"[{min(e.min() for e in eights):.3f}, {max(e.max() for e in eights):.3f}] in [{INK}, {BG}]; "
f"min blank columns between glyphs {min(gaps)} (>= 3)")
names = [f"{k} {s}" if k != "box" else "box" for k, s in REDACTIONS]
hit = {(n, z): 0 for n in names for z in (0.0,) + POST}
base_hit = {n: 0 for n in names}
base_inj = {n: 0 for n in names}
base_min = {n: np.inf for n in names}
lin_err = {n: 0.0 for n in names}
box_ties = []
unk_hit = {b: 0 for b in (2, 4, 8, 16)}
unk_found = {b: 0 for b in (2, 4, 8, 16)}
pc_char = {n: 0 for n in names}
pc_plate = {n: 0 for n in names}
noise_res = []
for t in range(T):
off = offsets[rng.integers(len(offsets))]
cov = COV[off]
true = int(rng.integers(10**7))
others = rng.choice(10**7 - 1, size=N - 1, replace=False)
others = others + (others >= true) # distinct, never the true plate
ints = np.concatenate([[true], others]) # the true plate is candidate 0
digits = (ints[:, None] // 10 ** np.arange(6, -1, -1)) % 10
assert len(np.unique(ints)) == N
clean = render(cov, digits[0])[0]
x = clean + rng.normal(0.0, SIGMA_S, (H, W)) # captured image
noise_res.append(x - clean)
for (kind, s), name in zip(REDACTIONS, names):
g = tuple(int(v) for v in rng.integers(s, size=2)) if kind == "pixelate" else (0, 0)
if kind == "blur":
rcov = BLUR[(s, off)]
else:
rcov = redact(cov, kind, s, g)
rbg = redact(np.full((H, W), BG), kind, s, g)
cands = rbg - (BG - INK) * sum(rcov[p][digits[:, p]] for p in range(7))
# C2: the redacted plate is the redacted background minus the redacted characters
lin_err[name] = max(lin_err[name], np.abs(redact(clean, kind, s, g) - cands[0]).max())
# C1: noise-free capture
k, nt, d = nearest(redact(clean, kind, s, g), cands, rng)
base_hit[name] += k == 0
inj = d[1:].min() > TOL
base_inj[name] += inj
base_min[name] = min(base_min[name], d[1:].min())
# sensor noise, then optional noise after redaction
y0 = redact(x, kind, s, g)
for z in (0.0,) + POST:
y = y0 + (rng.normal(0.0, z, (H, W)) if z > 0 else 0.0)
k, nt, _ = nearest(y, cands, rng)
hit[(name, z)] += k == 0
if kind == "box" and z == 0.0:
box_ties.append(nt)
# per-character decoder over the full 10^7 space
dec = per_character(y0, rbg, rcov, rng)
pc_char[name] += int((dec == digits[0]).sum())
pc_plate[name] += bool((dec == digits[0]).all())
# grid offset unknown: the attacker searches it
if kind == "pixelate":
pool = []
for gg in grid_search(y0, s):
rc = redact(cov, kind, s, gg)
rb = redact(np.full((H, W), BG), kind, s, gg)
cc = rb - (BG - INK) * sum(rc[p][digits[:, p]] for p in range(7))
dd = ((cc - y0) ** 2).sum(axis=(-2, -1))
pool += [(dd[i], i, gg) for i in np.flatnonzero(dd <= dd.min() + TOL)]
m = min(v for v, _, _ in pool)
best = [e for e in pool if e[0] <= m + TOL]
pick = best[rng.integers(len(best))]
unk_hit[s] += pick[1] == 0
unk_found[s] += pick[2] == g
nr = np.array(noise_res)
print(f"data: sensor noise std {nr.std():.4f} (planned {SIGMA_S}); N = {N} candidates, "
f"T = {T} plates per condition, seed {SEED}; chance 1/N = {1 / N:.4f}")
print(f"C2 linearity: max |redact(plate) - (redacted background - redacted characters)| = "
f"{max(lin_err.values()):.2e} (< 1e-12)")
print("C1 noise-free capture: re-identified / injective trials, smallest decoy distance")
for n in names[:-1]:
print(f" {n:12s} {base_hit[n]:4d} / {base_inj[n]:4d} injective of {T} min d^2 = {base_min[n]:.3e}")
print(f"C4 solid box: candidates tied per trial min {min(box_ties)} max {max(box_ties)} (N = {N})")
print("\nAttack on N candidates (sensor noise only), exact 95% interval")
for n in names:
k = hit[(n, 0.0)]
lo, hi = ci(k, T)
print(f" {n:12s} {k:4d}/{T} rate {k / T:.3f} [{lo:.4f}, {hi:.4f}]")
print("\nNoise added after redaction (sigma 0.05 | sigma 0.2)")
for n in names:
row = []
for z in POST:
k = hit[(n, z)]
lo, hi = ci(k, T)
row.append(f"{k:4d}/{T} [{lo:.4f}, {hi:.4f}]")
print(f" {n:12s} " + " | ".join(row))
print("\nPixelation with the grid offset unknown (searched by the attacker)")
for b in (2, 4, 8, 16):
lo, hi = ci(unk_hit[b], T)
print(f" block {b:2d} {unk_hit[b]:4d}/{T} [{lo:.4f}, {hi:.4f}] offset found {unk_found[b]}/{T}")
print("\nPer-character decoder over all 10^7 plates (sensor noise only)")
for n in names:
lo, hi = ci(pc_char[n], 7 * T)
plo, phi = ci(pc_plate[n], T)
print(f" {n:12s} characters {pc_char[n] / (7 * T):.4f} [{lo:.4f}, {hi:.4f}] "
f"whole plates {pc_plate[n]:4d}/{T} [{plo:.4f}, {phi:.4f}]")
Output:
C3 data: min pairwise glyph distance 11.314 (> 0); pixel range [0.150, 0.850] in [0.15, 0.85]; min blank columns between glyphs 3 (>= 3)
data: sensor noise std 0.0199 (planned 0.02); N = 1000 candidates, T = 200 plates per condition, seed 0; chance 1/N = 0.0010
C2 linearity: max |redact(plate) - (redacted background - redacted characters)| = 4.44e-16 (< 1e-12)
C1 noise-free capture: re-identified / injective trials, smallest decoy distance
blur 1 200 / 200 injective of 200 min d^2 = 5.252e+00
blur 2 200 / 200 injective of 200 min d^2 = 2.113e+00
blur 4 200 / 200 injective of 200 min d^2 = 2.448e-01
blur 8 200 / 200 injective of 200 min d^2 = 2.598e-02
pixelate 2 200 / 200 injective of 200 min d^2 = 7.901e+00
pixelate 4 200 / 200 injective of 200 min d^2 = 4.104e+00
pixelate 8 200 / 200 injective of 200 min d^2 = 7.656e-01
pixelate 16 200 / 200 injective of 200 min d^2 = 1.029e-02
C4 solid box: candidates tied per trial min 1000 max 1000 (N = 1000)
Attack on N candidates (sensor noise only), exact 95% interval
blur 1 200/200 rate 1.000 [0.9817, 1.0000]
blur 2 200/200 rate 1.000 [0.9817, 1.0000]
blur 4 200/200 rate 1.000 [0.9817, 1.0000]
blur 8 200/200 rate 1.000 [0.9817, 1.0000]
pixelate 2 200/200 rate 1.000 [0.9817, 1.0000]
pixelate 4 200/200 rate 1.000 [0.9817, 1.0000]
pixelate 8 200/200 rate 1.000 [0.9817, 1.0000]
pixelate 16 200/200 rate 1.000 [0.9817, 1.0000]
box 0/200 rate 0.000 [0.0000, 0.0183]
Noise added after redaction (sigma 0.05 | sigma 0.2)
blur 1 200/200 [0.9817, 1.0000] | 200/200 [0.9817, 1.0000]
blur 2 200/200 [0.9817, 1.0000] | 200/200 [0.9817, 1.0000]
blur 4 200/200 [0.9817, 1.0000] | 196/200 [0.9496, 0.9945]
blur 8 197/200 [0.9568, 0.9969] | 69/200 [0.2794, 0.4153]
pixelate 2 200/200 [0.9817, 1.0000] | 200/200 [0.9817, 1.0000]
pixelate 4 200/200 [0.9817, 1.0000] | 200/200 [0.9817, 1.0000]
pixelate 8 200/200 [0.9817, 1.0000] | 200/200 [0.9817, 1.0000]
pixelate 16 199/200 [0.9725, 0.9999] | 142/200 [0.6418, 0.7718]
box 0/200 [0.0000, 0.0183] | 0/200 [0.0000, 0.0183]
Pixelation with the grid offset unknown (searched by the attacker)
block 2 200/200 [0.9817, 1.0000] offset found 200/200
block 4 200/200 [0.9817, 1.0000] offset found 200/200
block 8 200/200 [0.9817, 1.0000] offset found 200/200
block 16 200/200 [0.9817, 1.0000] offset found 200/200
Per-character decoder over all 10^7 plates (sensor noise only)
blur 1 characters 1.0000 [0.9974, 1.0000] whole plates 200/200 [0.9817, 1.0000]
blur 2 characters 1.0000 [0.9974, 1.0000] whole plates 200/200 [0.9817, 1.0000]
blur 4 characters 0.2707 [0.2476, 0.2948] whole plates 0/200 [0.0000, 0.0183]
blur 8 characters 0.1000 [0.0848, 0.1169] whole plates 0/200 [0.0000, 0.0183]
pixelate 2 characters 1.0000 [0.9974, 1.0000] whole plates 200/200 [0.9817, 1.0000]
pixelate 4 characters 1.0000 [0.9974, 1.0000] whole plates 200/200 [0.9817, 1.0000]
pixelate 8 characters 0.7536 [0.7301, 0.7760] whole plates 38/200 [0.1381, 0.2513]
pixelate 16 characters 0.2650 [0.2420, 0.2890] whole plates 0/200 [0.0000, 0.0183]
box characters 0.0979 [0.0828, 0.1146] whole plates 0/200 [0.0000, 0.0183]
Checks. C1 held: without sensor noise every decoy’s redaction differed from the true plate’s in all 200 trials of every blur and pixelation, and the true plate was found in every one, as it must be when the redaction does not map two candidates to the same image. In this run the smallest decoy distance shrinks with the strength of the redaction, from about 5 (squared, summed over the image) at blur to about 0.03 at and 0.01 at blocks of 16, but it never reaches zero. C2 held at , C3 held (the noise standard deviation printed 0.0199, within 0.0005 of 0.02), and C4 held: under the box every candidate produces the same black image, so the attacker’s choice among them is a uniform draw.
The attack. Under sensor noise, every blur and every block size re-identified all 200 plates. H1, that blocks of 2 and 4 pixels (smaller than the 6-pixel spacing of a glyph’s vertical strokes) and blur with of 1 and 2 are re-identified far above chance, with the lower end of the interval above 0.5, held: the lower end is 0.9817 in all four. H2 has three parts. H2a, that the counts do not increase with the block size or with , held with every count equal (200 at every block size and every ). H2b, that the lower end at , the glyph width, exceeds , held (0.9817). H2c, that at , the glyph height and more than the pitch, the count is at most half the count at , failed: both counts are 200. The box gave 0 of 200; H3, that the box gives exactly chance, held: C4 held, and the interval contains 0.001. Only the box, which removes everything the region contained, gave chance.
Noise after redaction. H4 says that at moderate strengths (blur of 2 and 4, blocks of 4 and 8) noise lowers re-identification but does not remove it. The “lowers” part, a lower count at noise 0.2 than without, failed at , and , where the counts stayed at 200, and held at , where the count fell to 196. The “does not remove” part, a lower interval end above 0.01 at both noise levels, held in all four conditions (lowest 0.9496, at with noise 0.2). At noise 0.2 the count fell to 69 of 200 at and to 142 at , conditions outside H4; even there both intervals lie far above chance. At noise 0.05 the counts at and were 197 and 199.
Unknown grid offset. H5, that searching the grid offset leaves re-identification unchanged (the known-offset rate inside the unknown-offset interval), held for every block size: the attacker re-identified all 200 plates and chose the true offset in every trial. A released mosaic shows its own grid: inside a block every pixel has the same value, and because the sensor noise is added before pixelation this remains exact, so the block boundaries can be read off the image.
Per-character decoding. H6, that the per-character decoder recovers at least 90% of characters and, with the lower interval end above 0.5, whole plates at blocks of 2 and 4 and of 1 and 2, held: it recovered every character and every plate there, choosing among all plates without a candidate list. On the box, its share of correct characters is 0.0979 with an interval containing 0.1, the chance of guessing a digit, which H6 also predicted (held). At and 8 and at it recovered 27%, 10% and 26.5% of characters and no whole plate, and at three quarters of characters and 38 plates. In those conditions the 1000-candidate attack, which compares all seven characters at once, re-identified every plate; the per-character decoder is our simplification, which treats the neighbouring characters as absent, and in our reading, an attacker who models the neighbours is not limited by it.
What the example shows, within its assumptions, is the point Hill et al. make for text: blur and pixelation at every strength tested, up to blocks as tall as a glyph, still leave enough to pick a plate out of a candidate list when the attacker can reproduce the redaction, and only removing the content reduces the attacker to chance. The assumptions favour the attacker (noise-free candidates rendered with the exact glyphs, offsets and parameters, no compression and no 8-bit rounding of the released image), so the numbers are not estimates for real plates or faces. Real redactions are made with tools (Hill et al. name Photoshop, GIMP and Facepixelizer, §1) whose parameters an attacker would first have to identify, as Hill et al. did by trial and error (§3.4).
Process note. The hypotheses and every bar except C3’s noise-level bar were written in a file before any script was written or run, including H5 and H6, which were added at planning and are not in the batch plan. Before the plan was completed, one planning script, a copy of this script’s set-up cut down to the noise-free checks C1, C2, C3 and C4, ran once on the pilot’s seed and size, under a timer used for the runtime estimate; no bar was changed after it ran. The plan listed nine departures from the batch plan’s description of this example: digits only; the attacker knows the sub-pixel offset; ties broken at random with the true plate as candidate 0; a per-character decoder that treats neighbours as absent, run on every redaction, with known offsets and sensor noise only; the unknown grid offset searched by within-block constancy, for pixelation without post-redaction noise, with an added count of offsets found; noise levels of our choosing; one stated blur ("nearest" mode) and edge-replication padding; the added checks, hypotheses H5 and H6 and the whole-plate measure; and a box over the whole plate. A pilot ran on seed 1 with 50 plates per condition; the editor approved the example as piloted, with no change, and the output above is the first run, with no change after it; two runs give identical output. One outcome differs between the pilot and the first run: H4’s “lowers” part at failed in the pilot, where the count stayed at 50 of 50 at noise 0.2, and held in the first run. Every other check and hypothesis outcome, including the failures of H2c and of H4’s “lowers” part at , and , is the same in both.
Learning Without Collecting
Instead of protecting images after they are collected, a system can avoid collecting them.
On-device processing. A model that runs where the images are captured need not send them anywhere; edge inference lists privacy among the reasons given for running models on the device, and notes that it protects the images only if the results and logs sent off the device do not reveal what the images showed. In our reading, the design choice for a vision system is what leaves the device: an image, an intermediate representation, a detection, a count or nothing, each revealing less than the one before only if it has been checked to do so.
Federated learning. McMahan et al. (2017) proposed leaving training data on the devices and learning a shared model by aggregating locally computed updates, under the name federated learning. Their algorithm, FederatedAveraging (FedAvg), combines local stochastic gradient descent on each client with a server that averages the resulting models. On privacy, the paper claims distinct privacy advantages over training on data persisted in a data centre, adds that the strength of the benefit depends on the content of the updates, and names differential privacy and secure multi-party computation, or their combination, as ways of providing stronger guarantees, left for future work (§1, §4). Keeping images on the device is therefore a statement about where the data are stored, not by itself a guarantee about what the updates reveal.
Differential privacy is one of the routes McMahan et al. name for such guarantees; they cite for it, among other works, Dwork and Roth (2014) and Abadi et al.’s “Deep Learning with Differential Privacy” (2016). Neither work was read for this article, and both are named only. Image generation describes the extraction results that motivate limiting what a trained model retains.
Data Protection in Outline
Law governs what may be recorded, kept and processed; this article draws no legal conclusions and describes no jurisdiction’s law. The site’s articles hold the summaries: biometric recognition quotes the UK GDPR’s definition of biometric data and its special-category rule (legislation.gov.uk revised version, read November 2026), and the conditions for biometric authentication in NIST SP 800-63B-4 (July 2025); video surveillance summarizes the European Data Protection Board’s Guidelines 3/2019 on video devices (version 2.0, adopted 29 January 2020) and its Joint Opinion 5/2021 with the European Data Protection Supervisor on the proposed AI Act (18 June 2021), including remote biometric identification; medical computer vision describes DICOM’s confidentiality profiles (PS3.15, 2026d edition), which the standard says are part of a de-identification process, not a replacement for one. Dataset documentation records how creators applied such rules: Oxford Buildings reports that VGG’s privacy notice (as of October 2026) cites a UK GDPR exemption for not notifying the people in its photographs, and FFHQ describes an opt-out process.
Common Misconceptions
- “A blurred or pixelated region is anonymous.” It is anonymous only to someone who cannot model the redaction. Hill et al. recovered mosaiced and blurred text, and the example re-identified every plate at every blur and block size tested when the candidates were known and no noise was added after redaction.
- “A stronger blur is always enough.” In the example, stronger redaction shrank the distance between the true plate and the nearest decoy but did not close it: plates at and at 16-pixel blocks were re-identified in every trial when no noise was added after redaction.
- “A solid box leaks nothing.” It removes the content, but not the region’s size, position or context; Hill et al. describe text under a black bar recovered from font metrics, by finding which of a short list of phrases best fits the redacted space, and recommend re-rendering with a placeholder where the source is available.
- “The dataset blurs faces, so it contains none.” The protection depends on the detector finding every face; what it misses is released as captured.
- “Federated learning is private.” McMahan et al. claim privacy advantages whose strength depends on what the updates contain, and point to differential privacy and secure computation for stronger guarantees.
- “Removing names and metadata de-identifies an image.” Faces, text burned into pixels and the scene itself can identify a person or place; DICOM’s profiles address burned-in text, and neuroimaging datasets deface structural scans because they contain the face.
Where It Is Used
Anonymization pipelines are run on driving datasets (nuScenes, autonomous driving perception), large web-scale collections (SA-1B), egocentric video (Ego4D) and surveillance datasets (video surveillance); medical imaging has its own de-identification standards (medical computer vision). Choices about what leaves a device shape edge inference, augmented reality, whose world-facing cameras record the user’s surroundings, and robots in shared spaces (robot perception). Template protection for stored biometrics is described in biometric recognition, consent and withdrawal of datasets of people in dataset bias, and consent for synthetic likenesses in deepfakes. Thermal cameras are one sensor choice made for this reason: Gade et al. chose them for long-term analysis in sports arenas because people cannot be identified in their images (thermal camera).
Related
- Edge Inference
Running a vision model on the device that captures the images, such as a phone, camera, robot or microcontroller, instead of in a data centre, covering why it is done, the limits of compute, memory, power and heat, the classes of hardware and runtimes, the roofline model for finding memory-bound layers, split and offloaded computation, and how latency and energy are measured.
- Biometric Recognition Systems
Recognizing people automatically from their face, iris, fingerprints or other body traits; how systems enrol people and then verify or identify them, how their errors are measured (FMR and FNMR, FAR and FRR, FPIR and FNIR, DET curves and the equal error rate), and how presentation attacks, template protection, demographic differentials and regulation shape their use.
- Video Surveillance and Security
Computer vision applied to video from fixed security and traffic cameras as its research literature describes it; the processing chain from detection to multi-camera tracking, re-identification, attributes, events and search, the PETS, DukeMTMC, CityFlow, AI City Challenge, VIRAT and MEVA benchmarks with their protocols and metrics, documented failure modes, NIST's accuracy and demographic findings, and the privacy concerns stated in official documents.
- Image Generation
The task of producing new images from random noise, or from noise and a class label, that look as if they came from the training distribution; how it is defined, the unconditional and class-conditional variants, the benchmarks it is measured on, and its failure modes, from mode dropping to memorized training images.
- Medical Computer Vision
An overview of computer vision on medical images, from X-ray, CT, MRI, ultrasound and microscopy to the tasks of reconstruction, segmentation, registration, detection and slide-level prediction, and the problems that set the field apart from vision on photographs, namely scarce and disputed labels, privacy, shift between scanners and sites, evaluation against clinical reference standards, and regulation.
- Face Detection
Finding every face in an image and returning a box, a confidence score and often a few facial landmarks for each, from boosted cascades and part models to the single-stage CNN detectors evaluated on FDDB and WIDER FACE.
References
- Hill, S., Zhou, Z., Saul, L. & Shacham, H. (2016). On the (In)effectiveness of Mosaicing and Blurring as Tools for Document Redaction. Proceedings on Privacy Enhancing Technologies, 2016(4), 403–417.
- McMahan, H. B., Moore, E., Ramage, D., Hampson, S. & Agüera y Arcas, B. (2017). Communication-Efficient Learning of Deep Networks from Decentralized Data. Proceedings of the 20th International Conference on Artificial Intelligence and Statistics (AISTATS), PMLR 54, 1273–1282.
- National Institute of Standards and Technology (2023). Artificial Intelligence Risk Management Framework (AI RMF 1.0). NIST AI 100-1, January 2023.
- Newton, E. M., Sweeney, L. & Malin, B. (2005). Preserving Privacy by De-identifying Face Images. IEEE Transactions on Knowledge and Data Engineering, 17(2), 232–243 (not read).
- Venkatraman, D. (2014). Why Blurring Sensitive Information Is a Bad Idea. Blog post (not read).
- Dwork, C. & Roth, A. (2014). The Algorithmic Foundations of Differential Privacy. Foundations and Trends in Theoretical Computer Science (not read).
- Abadi, M., Chu, A., Goodfellow, I., McMahan, B., Mironov, I., Talwar, K. & Zhang, L. (2016). Deep Learning with Differential Privacy. 23rd ACM Conference on Computer and Communications Security (CCS) (not read).
- McPherson, Shokri & Shmatikov (2016). Defeating Image Obfuscation with Deep Learning (not read).
- Frome et al. (2009). Large-scale Privacy Protection in Google Street View. IEEE International Conference on Computer Vision (ICCV) (not read).