Terapkan Privasi Diferensial dengan Privasi TensorFlow

Lihat di TensorFlow.org Jalankan di Google Colab Lihat sumber di GitHub Unduh buku catatan

Ringkasan

Privasi Differential (DP) adalah suatu kerangka kerja untuk mengukur jaminan privasi yang disediakan oleh algoritma. Melalui lensa privasi diferensial, Anda dapat merancang algoritme pembelajaran mesin yang secara bertanggung jawab melatih model pada data pribadi. Pembelajaran dengan privasi diferensial memberikan jaminan privasi yang terukur, membantu mengurangi risiko tereksposnya data pelatihan sensitif dalam pembelajaran mesin. Secara intuitif, model yang dilatih dengan privasi diferensial tidak boleh terpengaruh oleh contoh pelatihan tunggal, atau kumpulan kecil contoh pelatihan, dalam kumpulan datanya. Ini membantu mengurangi risiko pengungkapan data pelatihan sensitif di ML.

Ide dasar dari pendekatan ini, yang disebut penurunan gradien stokastik pribadi diferensial (DP-SGD), adalah untuk memodifikasi gradien yang digunakan dalam penurunan gradien stokastik (SGD), yang merupakan inti dari hampir semua algoritme pembelajaran mendalam. Model yang dilatih dengan DP-SGD memberikan jaminan privasi diferensial yang dapat dibuktikan untuk data masukannya. Ada dua modifikasi yang dilakukan pada algoritma vanilla SGD:

  1. Pertama, sensitivitas setiap gradien perlu dibatasi. Dengan kata lain, Anda perlu membatasi seberapa besar setiap titik pelatihan individu yang diambil sampelnya dalam minibatch dapat memengaruhi perhitungan gradien dan pembaruan yang dihasilkan diterapkan pada parameter model. Hal ini dapat dilakukan dengan menjepit setiap gradien dihitung pada setiap titik pelatihan.
  2. Acak kebisingan adalah sampel dan ditambahkan ke gradien terpotong untuk membuatnya statistik tidak mungkin untuk mengetahui apakah atau tidak titik data tertentu termasuk dalam dataset training dengan membandingkan update SGD berlaku ketika beroperasi dengan atau tanpa data titik tertentu dalam dataset training .

Menggunakan tutorial ini tf.keras untuk melatih jaringan saraf convolutional (CNN) untuk mengenali tulisan tangan digit dengan optimizer DP-SGD yang disediakan oleh TensorFlow perpustakaan Privasi. TensorFlow Privacy menyediakan kode yang menggabungkan pengoptimal TensorFlow yang ada untuk membuat varian yang mengimplementasikan DP-SGD.

Mempersiapkan

Mulailah dengan mengimpor perpustakaan yang diperlukan:

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

Instal Privasi TensorFlow.

pip install tensorflow-privacy

import tensorflow_privacy

from tensorflow_privacy.privacy.analysis import compute_dp_sgd_privacy

Muat dan pra-proses set data

Memuat MNIST dataset dan mempersiapkan data untuk pelatihan.

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

Tentukan hiperparameter

Mengatur nilai hyperparamter model pembelajaran.

epochs = 3
batch_size = 250

DP-SGD memiliki tiga hyperparameter khusus privasi dan satu hyperameter yang ada yang harus Anda sesuaikan:

  1. l2_norm_clip (float) - maksimum Euclidean (L2) norma setiap gradien yang diterapkan parameter model update. Hyperparameter ini digunakan untuk mengikat sensitivitas pengoptimal ke titik pelatihan individu.
  2. noise_multiplier (float) - Jumlah kebisingan sampel dan ditambahkan ke gradien selama pelatihan. Umumnya, lebih banyak kebisingan menghasilkan privasi yang lebih baik (seringkali, tetapi tidak harus, dengan mengorbankan utilitas yang lebih rendah).
  3. microbatches (int) - Setiap batch data yang dibagi dalam satuan kecil yang disebut microbatches. Secara default, setiap microbatch harus berisi satu contoh pelatihan. Ini memungkinkan kita untuk memotong gradien berdasarkan per-contoh daripada setelah mereka dirata-ratakan di seluruh minibatch. Hal ini pada gilirannya mengurangi efek (negatif) kliping pada sinyal yang ditemukan di gradien dan biasanya memaksimalkan utilitas. Namun, overhead komputasi dapat dikurangi dengan meningkatkan ukuran mikrobatch untuk memasukkan lebih dari satu contoh pelatihan. Gradien rata-rata di beberapa contoh pelatihan ini kemudian dipotong. Jumlah total contoh yang dikonsumsi dalam satu batch, yaitu, satu langkah penurunan gradien, tetap sama. Jumlah microbatch harus membagi ukuran batch secara merata.
  4. learning_rate (float) - hyperparameter ini sudah ada di vanili SGD. Semakin tinggi tingkat pembelajaran, semakin penting setiap pembaruan. Jika pembaruan berisik (seperti ketika kebisingan aditif besar dibandingkan dengan ambang kliping), tingkat pembelajaran yang rendah dapat membantu prosedur pelatihan menyatu.

Gunakan nilai hyperparameter di bawah ini untuk mendapatkan model yang cukup akurat (akurasi uji 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')

Bangun modelnya

Tentukan jaringan saraf convolutional sebagai model pembelajaran.

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

Tentukan fungsi pengoptimal dan kehilangan untuk model pembelajaran. Hitung kerugian sebagai vektor kerugian per contoh daripada sebagai rata-rata pada minibatch untuk mendukung manipulasi gradien pada setiap titik pelatihan.

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)

Latih modelnya

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>

Ukur jaminan privasi diferensial

Lakukan analisis privasi untuk mengukur jaminan DP yang dicapai oleh algoritme pelatihan. Mengetahui tingkat DP yang dicapai memungkinkan perbandingan objektif dari dua pelatihan untuk menentukan mana dari keduanya yang lebih menjaga privasi. Pada tingkat tinggi, analisis privasi mengukur seberapa banyak musuh potensial dapat meningkatkan tebakan mereka tentang properti dari setiap titik pelatihan individu dengan mengamati hasil dari prosedur pelatihan (misalnya, pembaruan model dan parameter).

Jaminan ini kadang-kadang disebut sebagai anggaran privasi. Anggaran privasi yang lebih rendah membatasi lebih ketat kemampuan musuh untuk meningkatkan tebakan mereka. Ini memastikan jaminan privasi yang lebih kuat. Secara intuitif, ini karena lebih sulit untuk satu titik pelatihan memengaruhi hasil pembelajaran: misalnya, informasi yang terkandung dalam titik pelatihan tidak dapat diingat oleh algoritme ML dan privasi individu yang menyumbangkan poin pelatihan ini ke kumpulan data dipertahankan.

Dalam tutorial ini, analisis privasi dilakukan dalam rangka Rényi Differential Privasi (RDP), yang merupakan relaksasi dari DP murni berdasarkan makalah ini yang sangat baik cocok untuk DP-SGD.

Dua metrik digunakan untuk menyatakan jaminan DP dari algoritme ML:

  1. Delta (\(\delta\)) - batas probabilitas jaminan privasi tidak memegang. Aturan praktisnya adalah mengaturnya menjadi kurang dari kebalikan dari ukuran dataset pelatihan. Dalam tutorial ini, sudah diatur untuk 10 ^ -5 sebagai dataset MNIST memiliki 60.000 poin pelatihan.
  2. Epsilon (\(\epsilon\)) - ini adalah anggaran privasi. Ini mengukur kekuatan jaminan privasi dengan membatasi seberapa besar kemungkinan keluaran model tertentu dapat bervariasi dengan memasukkan (atau mengecualikan) satu titik pelatihan. Sebuah nilai yang lebih kecil untuk \(\epsilon\) menyiratkan jaminan privasi yang lebih baik. Namun, \(\epsilon\) nilai hanya merupakan batas atas dan nilai yang besar masih bisa berarti baik privasi dalam praktek.

Tensorflow Privasi menyediakan alat, compute_dp_sgd_privacy , untuk menghitung nilai \(\epsilon\) diberi nilai tetap dari \(\delta\) dan hyperparameters berikut dari proses pelatihan:

  1. Jumlah total poin dalam data pelatihan, n .
  2. The batch_size .
  3. The noise_multiplier .
  4. Jumlah epochs pelatihan.
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)

Laporan alat yang untuk hyperparameters dipilih di atas, model dilatih memiliki \(\epsilon\) nilai 1,18.

Ringkasan

Dalam tutorial ini, Anda mempelajari tentang privasi diferensial (DP) dan bagaimana Anda dapat menerapkan prinsip-prinsip DP dalam algoritme ML yang ada untuk memberikan jaminan privasi untuk data pelatihan. Secara khusus, Anda telah mempelajari cara:

  • Bungkus pengoptimal yang ada (mis., SGD, Adam) ke dalam mitra pribadi mereka yang berbeda menggunakan Privasi TensorFlow
  • Tune hyperparameters yang diperkenalkan oleh pembelajaran mesin pribadi yang berbeda
  • Ukur jaminan privasi yang diberikan menggunakan alat analisis yang disertakan dalam TensorFlow Privacy