Implementar privacidad diferencial con TensorFlow Privacy

Ver en TensorFlow.org Ejecutar en Google Colab Ver fuente en GitHub Descargar cuaderno

Descripción general

Privacidad diferencial (DP) es un marco para la medición de las garantías de privacidad proporcionadas por un algoritmo. A través de la lente de la privacidad diferencial, puede diseñar algoritmos de aprendizaje automático que entrenen modelos de manera responsable en datos privados. El aprendizaje con privacidad diferencial brinda garantías medibles de privacidad, lo que ayuda a mitigar el riesgo de exponer datos de capacitación confidenciales en el aprendizaje automático. Intuitivamente, un modelo entrenado con privacidad diferencial no debería verse afectado por ningún ejemplo de entrenamiento único, o un pequeño conjunto de ejemplos de entrenamiento, en su conjunto de datos. Esto ayuda a mitigar el riesgo de exponer datos de entrenamiento confidenciales en ML.

La idea básica de este enfoque, llamado descenso de gradiente estocástico diferencialmente privado (DP-SGD), es modificar los gradientes utilizados en el descenso de gradiente estocástico (SGD), que se encuentra en el núcleo de casi todos los algoritmos de aprendizaje profundo. Los modelos entrenados con DP-SGD brindan garantías de privacidad diferencial comprobables para sus datos de entrada. Hay dos modificaciones hechas al algoritmo Vanilla SGD:

  1. En primer lugar, es necesario acotar la sensibilidad de cada gradiente. En otras palabras, debe limitar cuánto puede influir cada punto de entrenamiento individual muestreado en un minilote en los cálculos de gradiente y las actualizaciones resultantes aplicadas a los parámetros del modelo. Esto se puede hacer por medio de cortes cada gradiente calculado en cada punto de la formación.
  2. Ruido aleatorio se muestrea y se añade a los gradientes recortadas para que sea estadísticamente imposible saber si es o no un punto de datos particular, se incluyó en la formación de datos mediante la comparación de las actualizaciones se aplica SGD cuando se opera con o sin este punto de datos particular en el conjunto de datos de entrenamiento .

Este sistema utiliza tutorial tf.keras para entrenar una red neuronal de convolución (CNN) para reconocer los dígitos escritos a mano con el optimizador DP-SGD proporcionada por la biblioteca de privacidad TensorFlow. TensorFlow Privacy proporciona un código que envuelve un optimizador de TensorFlow existente para crear una variante que implementa DP-SGD.

Configuración

Comience importando las bibliotecas necesarias:

import tensorflow as tf
tf.compat.v1.disable_v2_behavior()

import numpy as np

tf.get_logger().setLevel('ERROR')

WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/compat/v2_compat.py:101: disable_resource_variables (from tensorflow.python.ops.variable_scope) is deprecated and will be removed in a future version.
Instructions for updating:
non-resource variables are not supported in the long term

Instale la privacidad de TensorFlow.

pip install tensorflow-privacy

import tensorflow_privacy

from tensorflow_privacy.privacy.analysis import compute_dp_sgd_privacy

Cargar y preprocesar el conjunto de datos

Cargar el MNIST conjunto de datos y preparar los datos para el entrenamiento.

train, test = tf.keras.datasets.mnist.load_data()
train_data, train_labels = train
test_data, test_labels = test

train_data = np.array(train_data, dtype=np.float32) / 255
test_data = np.array(test_data, dtype=np.float32) / 255

train_data = train_data.reshape(train_data.shape[0], 28, 28, 1)
test_data = test_data.reshape(test_data.shape[0], 28, 28, 1)

train_labels = np.array(train_labels, dtype=np.int32)
test_labels = np.array(test_labels, dtype=np.int32)

train_labels = tf.keras.utils.to_categorical(train_labels, num_classes=10)
test_labels = tf.keras.utils.to_categorical(test_labels, num_classes=10)

assert train_data.min() == 0.
assert train_data.max() == 1.
assert test_data.min() == 0.
assert test_data.max() == 1.

Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11493376/11490434 [==============================] - 0s 0us/step
11501568/11490434 [==============================] - 0s 0us/step

Definir los hiperparámetros

Establecer valores de hiperparámetros del modelo de aprendizaje.

epochs = 3
batch_size = 250

DP-SGD tiene tres hiperparámetros específicos de privacidad y un hiperámetro existente que debe ajustar:

  1. l2_norm_clip (float) - El euclidiana (L2) norma máxima de cada gradiente que se aplica a los parámetros del modelo de actualización. Este hiperparámetro se utiliza para limitar la sensibilidad del optimizador a puntos de entrenamiento individuales.
  2. noise_multiplier (float) - La cantidad de ruido muestreada y se añade a los gradientes durante el entrenamiento. Generalmente, más ruido da como resultado una mejor privacidad (a menudo, pero no necesariamente, a expensas de una menor utilidad).
  3. microbatches (int) - Cada lote de datos se divide en unidades más pequeñas llamadas microbatches. De forma predeterminada, cada microlote debe contener un solo ejemplo de entrenamiento. Esto nos permite recortar gradientes por ejemplo en lugar de después de que se hayan promediado en el minilote. Esto, a su vez, reduce el efecto (negativo) del recorte en la señal que se encuentra en el gradiente y normalmente maximiza la utilidad. Sin embargo, la sobrecarga computacional se puede reducir aumentando el tamaño de los microlotes para incluir más de un ejemplo de entrenamiento. Luego se recorta el gradiente promedio a través de estos múltiples ejemplos de entrenamiento. El número total de ejemplos consumidos en un lote, es decir, un paso de descenso de gradiente, sigue siendo el mismo. El número de microlotes debe dividir uniformemente el tamaño del lote.
  4. learning_rate (float) - Este hiperparámetro ya existe en la vainilla SGD. Cuanto mayor sea la tasa de aprendizaje, más importante será cada actualización. Si las actualizaciones son ruidosas (como cuando el ruido aditivo es grande en comparación con el umbral de recorte), una tasa de aprendizaje baja puede ayudar a que el procedimiento de entrenamiento converja.

Utilice los valores de los hiperparámetros a continuación para obtener un modelo razonablemente preciso (95 % de precisión de la prueba):

l2_norm_clip = 1.5
noise_multiplier = 1.3
num_microbatches = 250
learning_rate = 0.25

if batch_size % num_microbatches != 0:
  raise ValueError('Batch size should be an integer multiple of the number of microbatches')

Construye el modelo

Defina una red neuronal convolucional como modelo de aprendizaje.

model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(16, 8,
                           strides=2,
                           padding='same',
                           activation='relu',
                           input_shape=(28, 28, 1)),
    tf.keras.layers.MaxPool2D(2, 1),
    tf.keras.layers.Conv2D(32, 4,
                           strides=2,
                           padding='valid',
                           activation='relu'),
    tf.keras.layers.MaxPool2D(2, 1),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(32, activation='relu'),
    tf.keras.layers.Dense(10)
])

Defina el optimizador y la función de pérdida para el modelo de aprendizaje. Calcule la pérdida como un vector de pérdidas por ejemplo en lugar de como la media de un minilote para admitir la manipulación de gradientes en cada punto de entrenamiento.

optimizer = tensorflow_privacy.DPKerasSGDOptimizer(
    l2_norm_clip=l2_norm_clip,
    noise_multiplier=noise_multiplier,
    num_microbatches=num_microbatches,
    learning_rate=learning_rate)

loss = tf.keras.losses.CategoricalCrossentropy(
    from_logits=True, reduction=tf.losses.Reduction.NONE)

entrenar al modelo

model.compile(optimizer=optimizer, loss=loss, metrics=['accuracy'])

model.fit(train_data, train_labels,
          epochs=epochs,
          validation_data=(test_data, test_labels),
          batch_size=batch_size)

Train on 60000 samples, validate on 10000 samples
Epoch 1/3
60000/60000 [==============================] - ETA: 0s - loss: 1.0431 - acc: 0.6637
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/keras/engine/training.py:2470: UserWarning: `Model.state_updates` will be removed in a future version. This property should not be used in TensorFlow 2.0, as `updates` are applied automatically.
  warnings.warn('`Model.state_updates` will be removed in a future version. '
60000/60000 [==============================] - 93s 2ms/sample - loss: 1.0431 - acc: 0.6637 - val_loss: 0.4862 - val_acc: 0.8606
Epoch 2/3
60000/60000 [==============================] - 67s 1ms/sample - loss: 0.4733 - acc: 0.8779 - val_loss: 0.3887 - val_acc: 0.9063
Epoch 3/3
60000/60000 [==============================] - 67s 1ms/sample - loss: 0.4061 - acc: 0.9094 - val_loss: 0.3532 - val_acc: 0.9258
<keras.callbacks.History at 0x7f0bc449ffd0>

Medir la garantía de privacidad diferencial

Realice un análisis de privacidad para medir la garantía de DP lograda por un algoritmo de entrenamiento. Conocer el nivel de DP alcanzado permite la comparación objetiva de dos carreras de entrenamiento para determinar cuál de los dos preserva más la privacidad. En un nivel alto, el análisis de privacidad mide cuánto puede mejorar un adversario potencial su suposición sobre las propiedades de cualquier punto de entrenamiento individual al observar el resultado del procedimiento de entrenamiento (p. ej., actualizaciones y parámetros del modelo).

Esta garantía se refiere a veces como el presupuesto de privacidad. Un presupuesto de privacidad más bajo limita más estrechamente la capacidad de un adversario para mejorar su suposición. Esto asegura una mayor garantía de privacidad. Intuitivamente, esto se debe a que es más difícil que un solo punto de entrenamiento afecte el resultado del aprendizaje: por ejemplo, la información contenida en el punto de entrenamiento no puede ser memorizada por el algoritmo ML y la privacidad de la persona que contribuyó con este punto de entrenamiento al se conserva el conjunto de datos.

En este tutorial, el análisis privacidad se realiza en el marco de Rényi diferencial de privacidad (RDP), que es una relajación de DP puro basado en este documento que está particularmente bien adaptado para DP-SGD.

Se utilizan dos métricas para expresar la garantía de DP de un algoritmo de ML:

  1. Delta (\(\delta\)) - Bounds la probabilidad de que la garantía de la privacidad no sostiene. Una regla general es configurarlo para que sea menor que el inverso del tamaño del conjunto de datos de entrenamiento. En este tutorial, se establece en 10 ^ -5 como el conjunto de datos MNIST tiene 60.000 puntos de entrenamiento.
  2. Epsilon (\(\epsilon\)) - Este es el presupuesto de privacidad. Mide la fuerza de la garantía de privacidad limitando cuánto puede variar la probabilidad de un resultado de modelo particular al incluir (o excluir) un solo punto de entrenamiento. Un valor más pequeño para \(\epsilon\) implica una mejor garantía de privacidad. Sin embargo, la \(\epsilon\) valor sólo es un límite superior y un valor grande podría todavía media buena privacidad en la práctica.

Tensorflow de privacidad proporciona una herramienta, compute_dp_sgd_privacy , para calcular el valor de \(\epsilon\) dado un valor fijo de \(\delta\) y los siguientes hiperparámetros del proceso de formación:

  1. El número total de puntos en los datos de entrenamiento, n .
  2. El batch_size .
  3. El noise_multiplier .
  4. El número de epochs de entrenamiento.
compute_dp_sgd_privacy.compute_dp_sgd_privacy(n=train_data.shape[0],
                                              batch_size=batch_size,
                                              noise_multiplier=noise_multiplier,
                                              epochs=epochs,
                                              delta=1e-5)

DP-SGD with sampling rate = 0.417% and noise_multiplier = 1.3 iterated over 720 steps satisfies differential privacy with eps = 0.563 and delta = 1e-05.
The optimal RDP order is 18.0.
(0.5631726490328062, 18.0)

Los informes de la herramienta que para los hiperparámetros elegidos anteriormente, el modelo entrenado tiene un \(\epsilon\) valor de 1,18.

Resumen

En este tutorial, aprendió sobre la privacidad diferencial (DP) y cómo puede implementar los principios de DP en los algoritmos de ML existentes para proporcionar garantías de privacidad para los datos de entrenamiento. En particular, aprendiste a:

  • Envuelva los optimizadores existentes (por ejemplo, SGD, Adam) en sus contrapartes diferencialmente privadas usando TensorFlow Privacy
  • Sintonice los hiperparámetros introducidos por el aprendizaje automático diferencialmente privado
  • Medir la garantía de privacidad proporcionada utilizando las herramientas de análisis incluidas en TensorFlow Privacy