El dato de partida

Trabajamos con un censo sintético de 5.000 personas, con la estructura del dataset Adult del US Census que usa el libro.

censo.head(4)

La intuición: negación plausible

Si el resultado publicado hubiera sido casi el mismo con o sin Karen en la base, entonces observarlo no dice nada sobre ella.

Formalizamos “casi el mismo” con dos piezas:

• Bases vecinas: $D$ y $D'$ difieren en un solo individuo
• Indistinguibilidad: el mecanismo asigna probabilidades similares a cada salida, corra sobre $D$ o sobre $D'$

¿Qué tan grande es $e^{\varepsilon}$?

$\varepsilon$ acota cuánto puede cambiar la creencia de un atacante sobre Karen.

epsilon =  0.01   ->   razon de probabilidades <= e^eps =      1.01
epsilon =  0.10   ->   razon de probabilidades <= e^eps =      1.11
epsilon =  0.50   ->   razon de probabilidades <= e^eps =      1.65
epsilon =  1.00   ->   razon de probabilidades <= e^eps =      2.72
epsilon =  2.00   ->   razon de probabilidades <= e^eps =      7.39
epsilon = 10.00   ->   razon de probabilidades <= e^eps =  22026.47

El mecanismo de Laplace

La receta más simple que satisface la definición: sumar ruido de Laplace calibrado al presupuesto.

def mecanismo_laplace(valor, sensibilidad, epsilon):
    """Devuelve valor + ruido Laplace(0, sensibilidad/epsilon)."""
    escala = sensibilidad / epsilon
    return valor + np.random.laplace(loc=0.0, scale=escala)

print(f"Conteo real:          {total}")
for _ in range(3):
    print(f"Conteo con eps = 1.0: {mecanismo_laplace(total, 1, 1.0):.2f}")

Conteo real:          2738
Conteo con eps = 1.0: 2737.55
Conteo con eps = 1.0: 2737.43
Conteo con eps = 1.0: 2739.28

La sensibilidad de un conteo es $1$: una persona cambia el resultado en, como máximo, uno. Volveremos sobre esto en el capítulo 3.

$\varepsilon$ determina la sensibilidad

Menos $\varepsilon$ significa más dispersión: más privacidad y menos utilidad. El mismo parámetro gobierna ambas cosas.

Por qué una definición no basta

Nadie publica una sola consulta. Un instituto de estadística publica docenas de tablas; un modelo se entrena con miles de iteraciones.

• Post-procesamiento — transformar una salida privada no gasta presupuesto
• Composición secuencial — consultas repetidas suman sus $\varepsilon$
• Composición paralela — consultas sobre partes disjuntas no suman

Post-procesamiento

bruto = mecanismo_laplace(total, 1, 1.0)

redondeado = max(0, round(bruto))          # conteos negativos no tienen sentido
proporcion = redondeado / len(censo)       # reescalar a proporción

print(f"Salida cruda del mecanismo: {bruto:.3f}")
print(f"Redondeada y truncada:      {redondeado}      <- sigue siendo 1.0-DP")
print(f"Como proporcion:            {proporcion:.4f}  <- sigue siendo 1.0-DP")

Salida cruda del mecanismo: 2739.311
Redondeada y truncada:      2739      <- sigue siendo 1.0-DP
Como proporcion:            0.5478  <- sigue siendo 1.0-DP

Podemos limpiar, reescalar y graficar los resultados. La información privada ya fue protegida; ninguna función puede recuperarla.

Composición secuencial

El presupuesto se gasta: repetir una consulta permite promediar el ruido hasta hacerlo desaparecer.

def error_al_promediar(k, epsilon=1.0, repeticiones=400):
    """Error medio al promediar k respuestas ruidosas independientes."""
    estimaciones = np.array([
        np.mean([mecanismo_laplace(total, 1, epsilon) for _ in range(k)])
        for _ in range(repeticiones)
    ])
    return np.mean(np.abs(estimaciones - total))

for k in [1, 10, 100]:
    err = error_al_promediar(k)
    print(f"k = {k:3d} publicaciones  ->  error medio = {err:6.3f}")

k =   1 publicaciones  ->  error medio =  0.973
k =  10 publicaciones  ->  error medio =  0.346
k = 100 publicaciones  ->  error medio =  0.109

El ruido no se acumula: se cancela

Con $k$ publicaciones el error cae como $1/\sqrt{k}$: con suficientes consultas el atacante recupera el valor exacto. Por eso el presupuesto debe sumar.

Composición paralela

Un histograma es el caso canónico: cada persona cae en exactamente un nivel educativo, así que solo afecta a una barra.

conteos = censo.educacion.value_counts().sort_index()
ruidosos = {nivel: mecanismo_laplace(c, 1, 0.5) for nivel, c in conteos.items()}

for nivel in list(conteos.index)[:4]:
    print(f"educacion = {nivel:2d} anios  |  real: {conteos[nivel]:5d}  |  "
          f"privado: {ruidosos[nivel]:9.2f}")
print(f"\nCosto total del histograma completo: eps = 0.5  (no 0.5 x "
      f"{len(conteos)} = {0.5*len(conteos)})")

educacion =  9 anios  |  real:  1620  |  privado:   1617.71
educacion = 10 anios  |  real:  1067  |  privado:   1068.83
educacion = 12 anios  |  real:   202  |  privado:    196.46
educacion = 13 anios  |  real:  1228  |  privado:   1225.96

Costo total del histograma completo: eps = 0.5  (no 0.5 x 6 = 3.0)

El histograma privado

La diferencia es visualmente imperceptible porque el ruido es de orden $1/0{,}5 = 2$ personas sobre barras de cientos. Los histogramas son el caso exitoso de la privacidad diferencial.

¿Cuánto ruido es suficiente?

Hasta ahora usamos sensibilidad $=1$ sin justificarlo. Esa es la pieza que conecta la consulta con el ruido.

El mecanismo de Laplace con escala $\Delta f / \varepsilon$ satisface $\varepsilon$-DP. Todo el trabajo está en calcular $\Delta f$ correctamente.

Sumas: el problema

suma_real = censo.ganancia_capital.sum()
maximo = censo.ganancia_capital.max()

print(f"Suma de ganancias de capital: {suma_real:>15,.0f}")
print(f"Maximo individual observado:  {maximo:>15,.0f}")
print(f"Sensibilidad = el mayor valor *posible*, no el observado -> sin cota")

Suma de ganancias de capital:       4,224,162
Maximo individual observado:          545,772
Sensibilidad = el mayor valor *posible*, no el observado -> sin cota

La solución: recortar (clipping)

Forzamos una cota. Si ningún valor puede exceder $b$, entonces $\Delta f = b$ por construcción.

def suma_recortada(serie, b):
    return serie.clip(upper=b).sum()

print(f"{'b':>9} | {'suma recortada':>15} | {'sesgo':>7} | {'ruido':>8}")
print("-" * 50)
for b in [5_000, 20_000, 100_000, 500_000]:
    real = suma_recortada(censo.ganancia_capital, b)
    desvios = [abs(mecanismo_laplace(real, b, 1.0) - real) for _ in range(300)]
    sesgo = (real - suma_real) / suma_real
    print(f"{b:>9,} | {real:>15,.0f} | {sesgo:>6.1%} | "
          f"{np.mean(desvios)/suma_real:>7.1%}")

        b |  suma recortada |   sesgo |    ruido
--------------------------------------------------
    5,000 |       1,146,931 | -72.8% |    0.1%
   20,000 |       2,233,632 | -47.1% |    0.5%
  100,000 |       3,485,208 | -17.5% |    2.4%
  500,000 |       4,178,390 |  -1.1% |   12.4%

El dilema del recorte: $b$ pequeño sesga la suma hacia abajo; $b$ grande exige más ruido. Hay un óptimo intermedio.

Encontrar el codo

A la izquierda, el sesgo desaparece al crecer $b$. A la derecha, el ruido lo compensa: el error total tiene un mínimo interior.

Promedios: dos consultas, no una

Un promedio no es una consulta lineal, así que no tiene sensibilidad simple. La descomponemos y usamos composición secuencial.

def media_privada(serie, cota, epsilon):
    suma = mecanismo_laplace(serie.clip(upper=cota).sum(), cota, epsilon / 2)
    conteo = mecanismo_laplace(len(serie), 1, epsilon / 2)
    return suma / conteo

print(f"Edad media real:     {censo.edad.mean():.4f}")
for _ in range(3):
    m = media_privada(censo.edad, 90, 1.0)
    print(f"Edad media privada:  {m:.4f}   (eps = 1.0)")

Edad media real:     37.6352
Edad media privada:  37.6372   (eps = 1.0)
Edad media privada:  37.6700   (eps = 1.0)
Edad media privada:  37.6075   (eps = 1.0)

El presupuesto se parte: $\varepsilon/2$ para la suma (sensibilidad $90$, la edad máxima) y $\varepsilon/2$ para el conteo (sensibilidad $1$).

Por qué relajar la definición

La $\varepsilon$-DP pura es exigente: prohíbe cualquier salida que sea más de $e^{\varepsilon}$ veces más probable bajo $D$ que bajo $D'$, incluso las de probabilidad ínfima.

• acceso al mecanismo Gaussiano y a la sensibilidad $L_2$
• composición avanzada, que crece como $\sqrt{k}$ en vez de $k$
• mejor comportamiento en consultas de alta dimensión

La regla práctica sobre $\delta$

La convención habitual es $\delta \approx 1/n^{2}$ o, directamente, $\delta = 10^{-5}$ para bases del orden de decenas de miles.

Diferencia conceptual clave:

• $\varepsilon$ acota la cantidad de información filtrada, siempre
• $\delta$ acota la probabilidad de que esa cota no valga

Son dos ejes distintos, no dos formas del mismo parámetro.

El mecanismo Gaussiano en código

def mecanismo_gaussiano(valor, sens_l2, epsilon, delta):
    """Valido para epsilon < 1 (analisis clasico de Dwork & Roth)."""
    sigma = np.sqrt(2 * np.log(1.25 / delta)) * sens_l2 / epsilon
    return valor + np.random.normal(0.0, sigma, size=np.shape(valor))

print(f"Conteo real: {total}")
for _ in range(3):
    print(f"Gaussiano (eps=0.5, delta=1e-5): "
          f"{mecanismo_gaussiano(float(total), 1.0, 0.5, 1e-5):.2f}")

Conteo real: 2738
Gaussiano (eps=0.5, delta=1e-5): 2749.89
Gaussiano (eps=0.5, delta=1e-5): 2727.40
Gaussiano (eps=0.5, delta=1e-5): 2727.91

Nótese el precio: para una consulta escalar, $\sigma$ incorpora el factor $\sqrt{2\ln(1{,}25/\delta)} \approx 4{,}8$ cuando $\delta = 10^{-5}$.

Laplace contra Gauss: escalar

En una consulta escalar Laplace gana: con el mismo $\varepsilon$ concentra mucha más masa cerca de cero, mientras Gauss paga el precio de $\delta$ sin recibir nada a cambio.

Laplace contra Gauss: vectorial

A partir de $k \approx 12$ componentes, Gauss domina — y sigue mejorando. Por eso el aprendizaje automático privado usa Gauss: un gradiente tiene tantas componentes como parámetros el modelo.

Variantes

• Rényi DP — divergencia de Rényi de orden $\alpha$; composición: suma exacta, sin pérdida

El problema

Queremos entrenar un clasificador que prediga ingreso alto a partir de edad y educación — sin que el modelo memorice a nadie.

X_bruto = censo[["edad", "educacion"]].values.astype(float)
X = (X_bruto - X_bruto.mean(0)) / X_bruto.std(0)
X = np.hstack([X, np.ones((len(X), 1))])          # término constante
y = np.where(censo.ingreso_alto.values == 1, 1, -1)

corte = 4_000
X_ent, y_ent, X_test, y_test = X[:corte], y[:corte], X[corte:], y[corte:]

def exactitud(theta):
    return np.mean(np.sign(X_test @ theta) == y_test)

print(f"Entrenamiento: {len(X_ent)} filas  |  Prueba: {len(X_test)} filas")
piso_trivial = max(np.mean(y_test == 1), np.mean(y_test == -1))
print(f"Clase mayoritaria (piso trivial): {piso_trivial:.3f}")

Entrenamiento: 4000 filas  |  Prueba: 1000 filas
Clase mayoritaria (piso trivial): 0.546

Dónde vive la información privada

Regresión logística por descenso de gradiente. El gradiente es una suma sobre personas — y cada término depende de una sola.

def gradientes(theta, X, y):
    """Matriz de gradientes: una fila por persona."""
    margen = y * (X @ theta)
    return (-y * expit(-margen))[:, None] * X

g = gradientes(np.zeros(3), X_ent, y_ent)
print(f"Forma de la matriz de gradientes: {g.shape}   (una fila por persona)")
print(f"Gradiente de Karen:               {g[0].round(4)}")
print(f"Gradiente agregado (lo que usamos): {g.sum(axis=0).round(2)}")

Forma de la matriz de gradientes: (4000, 3)   (una fila por persona)
Gradiente de Karen:               [ 0.305   0.2961 -0.5   ]
Gradiente agregado (lo que usamos): [-481.78 -566.81 -192.  ]

Recortar gradientes

La sensibilidad de la suma de gradientes no está acotada — igual que la suma de ganancias de capital. Misma solución: recortar, ahora en norma $L_2$.

def recortar_filas(G, b):
    """Escala cada fila para que su norma L2 no exceda b."""
    normas = np.linalg.norm(G, axis=1, keepdims=True)
    return G * np.minimum(1.0, b / np.maximum(normas, 1e-12))

normas = np.linalg.norm(g, axis=1)
print(f"Norma L2 de los gradientes: mediana {np.median(normas):.3f}, "
      f"maxima {normas.max():.3f}")
tras = np.linalg.norm(recortar_filas(g, 1.0), axis=1).max()
print(f"Tras recortar con b = 1:    maxima {tras:.3f}")
print(f"Sensibilidad L2 de la suma recortada = b = 1  (por construccion)")

Norma L2 de los gradientes: mediana 0.779, maxima 2.135
Tras recortar con b = 1:    maxima 1.000
Sensibilidad L2 de la suma recortada = b = 1  (por construccion)

El compromiso privacidad–utilidad

La curva es la respuesta honesta a “¿cuánto cuesta la privacidad?”: depende del régimen. Arriba de $\varepsilon \approx 1$ el costo es casi nulo; abajo de $0{,}2$ el modelo colapsa hacia la clase mayoritaria.

DP-SGD en la práctica

Lo que implementamos es noisy gradient descent de lote completo. El algoritmo estándar, DP-SGD, agrega dos piezas:

• Muestreo de Poisson de lotes, que aporta privacy amplification by subsampling: muestrear una fracción $q$ de los datos reduce el $\varepsilon$ efectivo aproximadamente en un factor $q$
• Contabilidad por momentos (moments accountant / Rényi DP) en lugar de composición secuencial, lo que recorta el presupuesto de forma drástica en miles de iteraciones

Lo que no cubrimos

• Mecanismo exponencial — para salidas no numéricas (elegir una categoría)
• Privacidad diferencial local — sin curador de confianza; es el modelo de RAPPOR en Chrome y de la telemetría de Apple
• Datos sintéticos privados — publicar una base entera, no una estadística
• Aprendizaje profundo — DP-SGD sobre redes, moments accountant en detalle
• Unidad de privacidad — proteger a una persona con múltiples registros (user-level frente a record-level) cambia toda la contabilidad