Implémenter la confidentialité différentielle avec TensorFlow Privacy

Voir sur TensorFlow.org Exécuter dans Google Colab Voir la source sur GitHub Télécharger le cahier

Aperçu

Intimité différentielle (DP) est un cadre de mesure des garanties de confidentialité fournies par un algorithme. À travers le prisme de la confidentialité différentielle, vous pouvez concevoir des algorithmes d'apprentissage automatique qui entraînent de manière responsable des modèles sur des données privées. L'apprentissage avec une confidentialité différentielle offre des garanties mesurables de confidentialité, aidant à atténuer le risque d'exposer des données de formation sensibles dans l'apprentissage automatique. Intuitivement, un modèle formé avec une confidentialité différentielle ne devrait pas être affecté par un seul exemple de formation, ou un petit ensemble d'exemples de formation, dans son ensemble de données. Cela permet d'atténuer le risque d'exposer des données d'entraînement sensibles dans ML.

L'idée de base de cette approche, appelée descente de gradient stochastique différentiellement privée (DP-SGD), est de modifier les gradients utilisés dans la descente de gradient stochastique (SGD), qui est au cœur de presque tous les algorithmes d'apprentissage en profondeur. Les modèles entraînés avec DP-SGD fournissent des garanties de confidentialité différentielles démontrables pour leurs données d'entrée. Deux modifications ont été apportées à l'algorithme vanilla SGD :

  1. Premièrement, la sensibilité de chaque gradient doit être limitée. En d'autres termes, vous devez limiter dans quelle mesure chaque point d'apprentissage individuel échantillonné dans un mini-lot peut influencer les calculs de gradient et les mises à jour résultantes appliquées aux paramètres du modèle. Cela peut être fait par clipsage chaque gradient calculé sur chaque point de formation.
  2. Le bruit aléatoire est prélevé et ajouté aux gradients rognées pour le rendre statistiquement impossible de savoir si oui ou non un point de données particulier a été inclus dans l'ensemble de données de formation en comparant les mises à jour SGD s'applique lorsqu'il fonctionne avec ou sans ce point de données particulier dans l'ensemble de données de formation .

Ce tutoriel utilise tf.keras pour former un réseau neuronal convolutif (CNN) pour reconnaître les chiffres écrits à la main avec l'optimiseur DP-SGD fournies par la bibliothèque de confidentialité tensorflow. TensorFlow Privacy fournit un code qui encapsule un optimiseur TensorFlow existant pour créer une variante qui implémente DP-SGD.

Installer

Commencez par importer les bibliothèques nécessaires :

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

Installez TensorFlow Privacy.

pip install tensorflow-privacy

import tensorflow_privacy

from tensorflow_privacy.privacy.analysis import compute_dp_sgd_privacy

Charger et pré-traiter l'ensemble de données

Chargez le MNIST ensemble de données et préparer les données pour la formation.

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

Définir les hyperparamètres

Définissez les valeurs des hyperparamètres du modèle d'apprentissage.

epochs = 3
batch_size = 250

DP-SGD a trois hyperparamètres spécifiques à la confidentialité et un hyperamater existant que vous devez régler :

  1. l2_norm_clip (float) - La norme euclidienne maximale (L2) de chaque gradient qui est appliqué à la mise à jour des paramètres du modèle. Cet hyperparamètre est utilisé pour lier la sensibilité de l'optimiseur aux points d'entraînement individuels.
  2. noise_multiplier (float) - La quantité de bruit échantillonné et ajouté à des gradients pendant la formation. Généralement, plus de bruit se traduit par une meilleure intimité (souvent, mais pas nécessairement, au détriment d'une moindre utilité).
  3. microbatches (int) - Chaque lot de données est divisé en unités plus petites appelées microbatches. Par défaut, chaque microlot doit contenir un seul exemple d'apprentissage. Cela nous permet de découper les dégradés par exemple plutôt qu'après avoir fait la moyenne sur le mini-lot. Cela diminue à son tour l'effet (négatif) de l'écrêtage sur le signal trouvé dans le gradient et maximise généralement l'utilité. Cependant, la surcharge de calcul peut être réduite en augmentant la taille des microlots pour inclure plus d'un exemple d'apprentissage. Le gradient moyen sur ces multiples exemples d'entraînement est ensuite écrêté. Le nombre total d'exemples consommés dans un lot, c'est-à-dire une étape de descente de gradient, reste le même. Le nombre de microlots doit diviser uniformément la taille du lot.
  4. learning_rate (float) - Cette hyperparam'etre existe déjà dans la vanille SGD. Plus le taux d'apprentissage est élevé, plus chaque mise à jour compte. Si les mises à jour sont bruyantes (comme lorsque le bruit additif est important par rapport au seuil d'écrêtage), un faible taux d'apprentissage peut aider la procédure d'apprentissage à converger.

Utilisez les valeurs d'hyperparamètres ci-dessous pour obtenir un modèle raisonnablement précis (précision de test à 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')

Construire le modèle

Définir un réseau de neurones convolutifs comme modèle d'apprentissage.

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

Définissez l'optimiseur et la fonction de perte pour le modèle d'apprentissage. Calculez la perte en tant que vecteur de pertes par exemple plutôt que comme moyenne sur un mini-lot pour prendre en charge la manipulation du gradient sur chaque point d'apprentissage.

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)

Former le modèle

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>

Mesurer la garantie différentielle de confidentialité

Effectuez une analyse de confidentialité pour mesurer la garantie DP obtenue par un algorithme d'apprentissage. Connaître le niveau de DP atteint permet de comparer objectivement deux parcours d'entraînement pour déterminer lequel des deux est le plus respectueux de la vie privée. À un niveau élevé, l'analyse de confidentialité mesure dans quelle mesure un adversaire potentiel peut améliorer son estimation des propriétés d'un point d'entraînement individuel en observant le résultat de la procédure d'entraînement (par exemple, les mises à jour et les paramètres du modèle).

Cette garantie est parfois appelée le budget de la vie privée. Un budget de confidentialité inférieur limite plus étroitement la capacité d'un adversaire à améliorer sa supposition. Cela garantit une garantie de confidentialité plus forte. Intuitivement, c'est parce qu'il est plus difficile pour un seul point d'entraînement d'affecter le résultat de l'apprentissage : par exemple, les informations contenues dans le point d'entraînement ne peuvent pas être mémorisées par l'algorithme ML et la vie privée de la personne qui a contribué ce point d'entraînement au l'ensemble de données est préservé.

Dans ce tutoriel, l'analyse de la vie privée est effectuée dans le cadre de Rényi différentiel vie privée (RDP), qui est une relaxation du pur DP basé sur ce document qui est particulièrement bien adapté pour les DP-SGD.

Deux métriques sont utilisées pour exprimer la garantie DP d'un algorithme ML :

  1. Delta (\(\delta\)) - Bounds la probabilité de la garantie de confidentialité ne tenant pas. Une règle empirique consiste à le définir pour qu'il soit inférieur à l'inverse de la taille de l'ensemble de données d'apprentissage. Dans ce tutoriel, il est réglé sur 10 ^ -5 comme l'ensemble de données MNIST a 60.000 points de formation.
  2. Epsilon (\(\epsilon\)) - C'est le budget de la vie privée. Il mesure la force de la garantie de confidentialité en limitant à quel point la probabilité d'une sortie de modèle particulière peut varier en incluant (ou en excluant) un seul point d'apprentissage. Une valeur plus petite pour \(\epsilon\) implique une meilleure garantie de confidentialité. Cependant, la \(\epsilon\) valeur est seulement une limite supérieure et une grande valeur pourrait encore moyenne bonne vie privée dans la pratique.

Tensorflow confidentialité fournit un outil, compute_dp_sgd_privacy , pour calculer la valeur de \(\epsilon\) donné une valeur fixe de \(\delta\) et les hyperparamètres suivantes dans le processus de formation:

  1. Le nombre total de points dans les données de formation, n .
  2. Le batch_size .
  3. Le noise_multiplier .
  4. Le nombre d' epochs de formation.
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)

Les rapports d'outils que pour les hyperparamètres choisis ci - dessus, le modèle formé a une \(\epsilon\) valeur de 1,18.

Résumé

Dans ce didacticiel, vous avez découvert la confidentialité différentielle (DP) et comment vous pouvez implémenter les principes DP dans les algorithmes ML existants pour fournir des garanties de confidentialité pour les données d'entraînement. Vous avez notamment appris à :

  • Enveloppez les optimiseurs existants (par exemple, SGD, Adam) dans leurs homologues différentiellement privés à l'aide de TensorFlow Privacy
  • Ajustez les hyperparamètres introduits par l'apprentissage automatique différentiellement privé
  • Mesurer la garantie de confidentialité fournie à l'aide des outils d'analyse inclus dans TensorFlow Privacy