Implementa la privacy differenziale con TensorFlow Privacy

Visualizza su TensorFlow.org Esegui in Google Colab Visualizza la fonte su GitHub Scarica taccuino

Panoramica

Privacy differenziale (DP) è un framework per la misurazione delle garanzie sulla privacy forniti da un algoritmo. Attraverso la lente della privacy differenziale, puoi progettare algoritmi di machine learning che addestrano responsabilmente i modelli su dati privati. L'apprendimento con privacy differenziale fornisce garanzie misurabili di privacy, contribuendo a mitigare il rischio di esporre dati di formazione sensibili nell'apprendimento automatico. Intuitivamente, un modello addestrato con privacy differenziale non dovrebbe essere influenzato da alcun singolo esempio di addestramento o da un piccolo insieme di esempi di addestramento nel suo set di dati. Ciò aiuta a mitigare il rischio di esporre dati di training sensibili in ML.

L'idea di base di questo approccio, chiamato discesa del gradiente stocastico differenzialmente privato (DP-SGD), è quella di modificare i gradienti utilizzati nella discesa del gradiente stocastico (SGD), che è alla base di quasi tutti gli algoritmi di deep learning. I modelli addestrati con DP-SGD forniscono garanzie di privacy differenziali dimostrabili per i loro dati di input. Sono state apportate due modifiche all'algoritmo SGD vaniglia:

  1. Innanzitutto, la sensibilità di ciascun gradiente deve essere delimitata. In altre parole, è necessario limitare quanto ogni singolo punto di addestramento campionato in un minibatch può influenzare i calcoli del gradiente e gli aggiornamenti risultanti applicati ai parametri del modello. Questo può essere fatto da ogni ritaglio di pendenza calcolato su ogni punto di formazione.
  2. Rumore casuale viene campionato e ha aggiunto ai gradienti tagliate per rendere statisticamente impossibile sapere se un particolare punto di dati è stato incluso nel set di dati di formazione mettendo a confronto gli aggiornamenti applica SGD quando si opera con o senza questo particolare punto di dati nel set di dati di formazione .

Questo utilizza esercitazione tf.keras per addestrare una rete neurale convoluzionale (CNN) per riconoscere le cifre scritte a mano con l'ottimizzatore DP-SGD fornito dalla libreria Privacy tensorflow. TensorFlow Privacy fornisce il codice che esegue il wrapping di un ottimizzatore TensorFlow esistente per creare una variante che implementa DP-SGD.

Impostare

Inizia importando le librerie necessarie:

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

Installa TensorFlow Privacy.

pip install tensorflow-privacy

import tensorflow_privacy

from tensorflow_privacy.privacy.analysis import compute_dp_sgd_privacy

Carica e pre-elabora il set di dati

Caricare il MNIST set di dati e preparare i dati per la formazione.

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

Definire gli iperparametri

Imposta i valori degli iperparametri del modello di apprendimento.

epochs = 3
batch_size = 250

DP-SGD ha tre iperparametri specifici per la privacy e un iperamatore esistente che devi regolare:

  1. l2_norm_clip (float) - Il massimo euclidea (L2) norma di ogni sfumatura che viene applicato ai parametri del modello aggiornamento. Questo iperparametro viene utilizzato per vincolare la sensibilità dell'ottimizzatore ai singoli punti di allenamento.
  2. noise_multiplier (float) - La quantità di rumore campionato e ha aggiunto a gradienti durante l'allenamento. Generalmente, più rumore si traduce in una migliore privacy (spesso, ma non necessariamente, a scapito di una minore utilità).
  3. microbatches (int) - Ogni serie di dati è divisa in unità più piccole chiamate microbatches. Per impostazione predefinita, ogni microbatch dovrebbe contenere un singolo esempio di addestramento. Ciò ci consente di ritagliare i gradienti in base all'esempio anziché dopo che sono stati mediati nel minibatch. Questo a sua volta riduce l'effetto (negativo) del clipping sul segnale trovato nel gradiente e in genere massimizza l'utilità. Tuttavia, l'overhead computazionale può essere ridotto aumentando la dimensione dei microbatch per includere più di un esempio di addestramento. Il gradiente medio tra questi molteplici esempi di allenamento viene quindi ritagliato. Il numero totale di esempi consumati in un batch, ovvero un passo di discesa del gradiente, rimane lo stesso. Il numero di microbatch dovrebbe dividere equamente la dimensione del batch.
  4. learning_rate (float) - Questo iperparametro esiste già vaniglia SGD. Più alto è il tasso di apprendimento, più ogni aggiornamento è importante. Se gli aggiornamenti sono rumorosi (come quando il rumore additivo è grande rispetto alla soglia di clipping), un basso tasso di apprendimento può aiutare la procedura di addestramento a convergere.

Utilizzare i valori dell'iperparametro di seguito per ottenere un modello ragionevolmente accurato (accuratezza del test del 95%):

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')

Costruisci il modello

Definire una rete neurale convoluzionale come modello di apprendimento.

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)
])

Definire l'ottimizzatore e la funzione di perdita per il modello di apprendimento. Calcolare la perdita come vettore di perdite per esempio anziché come media su un minibatch per supportare la manipolazione del gradiente su ciascun punto di addestramento.

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)

Allena il modello

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>

Misura la garanzia differenziale sulla privacy

Eseguire un'analisi della privacy per misurare la garanzia DP ottenuta da un algoritmo di addestramento. Conoscere il livello di DP raggiunto consente il confronto oggettivo di due sessioni di formazione per determinare quale delle due è più rispettosa della privacy. Ad alto livello, l'analisi della privacy misura quanto un potenziale avversario può migliorare le proprie congetture sulle proprietà di ogni singolo punto di addestramento osservando l'esito della procedura di addestramento (ad esempio, aggiornamenti del modello e parametri).

Tale garanzia è a volte indicato come il bilancio privacy. Un budget per la privacy inferiore limita più strettamente la capacità di un avversario di migliorare la propria ipotesi. Ciò garantisce una maggiore garanzia di privacy. Intuitivamente, questo perché è più difficile che un singolo punto di formazione influisca sull'esito dell'apprendimento: ad esempio, le informazioni contenute nel punto di formazione non possono essere memorizzate dall'algoritmo ML e la privacy dell'individuo che ha contribuito a questo punto di formazione set di dati è conservato.

In questa esercitazione, l'analisi privacy è eseguita nell'ambito della Privacy Rényi differenziale (RDP), che è un rilassamento di DP puro basato su questo documento che è particolarmente adatto per DP-SGD.

Per esprimere la garanzia DP di un algoritmo ML vengono utilizzate due metriche:

  1. Delta (\(\delta\)) - delimita la probabilità della privacy garanzia non tiene. Una regola pratica consiste nell'impostarlo in modo che sia inferiore all'inverso della dimensione del set di dati di addestramento. In questo tutorial, è impostato a 10 ^ -5 come il set di dati MNIST ha 60.000 punti di formazione.
  2. Epsilon (\(\epsilon\)) - Questo è il bilancio della privacy. Misura la forza della garanzia di privacy limitando quanto può variare la probabilità di un particolare modello di output includendo (o escludendo) un singolo punto di addestramento. Un valore inferiore per \(\epsilon\) implica una maggiore garanzia della privacy. Tuttavia, la \(\epsilon\) valore è solo un limite superiore e un grande valore potrebbe Privacy Buona ancora media nella pratica.

Tensorflow Privacy fornisce uno strumento, compute_dp_sgd_privacy , per calcolare il valore di \(\epsilon\) dato un valore fisso di \(\delta\) e le seguenti iperparametri dal processo di formazione:

  1. Il numero totale di punti nei dati di addestramento, n .
  2. Il batch_size .
  3. Il noise_multiplier .
  4. Il numero di epochs di formazione.
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)

I rapporti strumento che per le iperparametri scelti in precedenza, il modello addestrato ha un \(\epsilon\) valore 1,18.

Riepilogo

In questo tutorial, hai appreso la privacy differenziale (DP) e come puoi implementare i principi DP negli algoritmi ML esistenti per fornire garanzie di privacy per i dati di addestramento. In particolare hai imparato a:

  • Avvolgi gli ottimizzatori esistenti (ad es. SGD, Adam) nelle loro controparti differenzialmente private utilizzando TensorFlow Privacy
  • Ottimizza gli iperparametri introdotti dal machine learning differenzialmente privato
  • Misurare la garanzia sulla privacy fornita utilizzando gli strumenti di analisi inclusi in TensorFlow Privacy