TensorFlow Privacy ile Diferansiyel Gizliliği Uygulayın

TensorFlow.org'da görüntüleyin Google Colab'da çalıştırın Kaynağı GitHub'da görüntüleyin Not defterini indir

genel bakış

Diferansiyel gizlilik (DP), bir algoritma tarafından sağlanan gizlilik garanti ölçülmesi için bir çerçevedir. Farklı gizlilik merceğinden, modelleri özel veriler üzerinde sorumlu bir şekilde eğiten makine öğrenimi algoritmaları tasarlayabilirsiniz. Diferansiyel gizlilikle öğrenme, ölçülebilir gizlilik garantileri sağlayarak makine öğreniminde hassas eğitim verilerinin açığa çıkma riskini azaltmaya yardımcı olur. Sezgisel olarak, farklı gizlilikle eğitilmiş bir model, veri setindeki tek bir eğitim örneğinden veya küçük eğitim örneklerinden etkilenmemelidir. Bu, makine öğreniminde hassas eğitim verilerinin açığa çıkma riskini azaltmaya yardımcı olur.

Diferansiyel olarak özel stokastik gradyan inişi (DP-SGD) olarak adlandırılan bu yaklaşımın temel fikri, neredeyse tüm derin öğrenme algoritmalarının merkezinde yer alan stokastik gradyan inişinde (SGD) kullanılan gradyanları değiştirmektir. DP-SGD ile eğitilmiş modeller, giriş verileri için kanıtlanabilir farklı gizlilik garantileri sağlar. Vanilya SGD algoritmasında yapılan iki değişiklik vardır:

  1. İlk olarak, her degradenin duyarlılığı sınırlandırılmalıdır. Başka bir deyişle, bir mini partide örneklenen her bir eğitim noktasının gradyan hesaplamalarını ve model parametrelerine uygulanan sonuçtaki güncellemeleri ne kadar etkileyebileceğini sınırlamanız gerekir. Bu, her eğitim noktasında hesaplanan her gradyan kırpma yoluyla yapılabilir.
  2. Rastgele gürültü onunla veya eğitim veri kümesindeki bu özel veri noktası olmadan çalışır zaman SGD geçerlidir güncelleştirmeleri karşılaştırarak örneklenmiş ve istatistiksel imkansız belirli bir veri noktası eğitim veri kümesi dahil olsun veya olmasın bilmek yapmak için kırpılmış gradyanlar eklenir .

Bu eğitimde kullanımları tf.keras TensorFlow Gizlilik kitaplığı tarafından sağlanan DP-SGD optimizer ile el yazısı rakamları tanımak üzere bir sarmal sinir ağı (CNN) yetiştirmek. TensorFlow Privacy, DP-SGD'yi uygulayan bir değişken oluşturmak için mevcut bir TensorFlow optimize edicisini saran kod sağlar.

Kurmak

Gerekli kitaplıkları içe aktararak başlayın:

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

TensorFlow Privacy'yi yükleyin.

pip install tensorflow-privacy

import tensorflow_privacy

from tensorflow_privacy.privacy.analysis import compute_dp_sgd_privacy

Veri kümesini yükleyin ve önceden işleyin

Yük MNIST veri kümesini ve eğitim verileri hazırlamak.

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

Hiperparametreleri tanımlayın

Öğrenme modeli hiper parametre değerlerini ayarlayın.

epochs = 3
batch_size = 250

DP-SGD, gizlilikle ilgili üç hiper parametreye ve ayarlamanız gereken bir mevcut hiperametreye sahiptir:

  1. l2_norm_clip (float) - güncelleme model parametreleri uygulandığı her bir gradyanın en Öklid (L2) normuna. Bu hiperparametre, optimize edicinin hassasiyetini bireysel eğitim noktalarına sınırlamak için kullanılır.
  2. noise_multiplier (float) - örneklenmiş ve eğitim sırasında gradyanlar ilave gürültü miktarı. Genel olarak, daha fazla gürültü daha iyi mahremiyetle sonuçlanır (genellikle, ancak zorunlu olmamakla birlikte, daha düşük fayda pahasına).
  3. microbatches (int) - verilerin her parti microbatches adı verilen daha küçük birimler halinde bölünmüştür. Varsayılan olarak, her mikro parti tek bir eğitim örneği içermelidir. Bu, gradyanları mini parti genelinde ortalaması alındıktan sonra değil, örnek bazında kırpmamızı sağlar. Bu da, degradede bulunan sinyal üzerindeki kırpmanın (negatif) etkisini azaltır ve tipik olarak faydayı en üst düzeye çıkarır. Bununla birlikte, mikro yığınların boyutu birden fazla eğitim örneğini içerecek şekilde artırılarak hesaplama yükü azaltılabilir. Bu çoklu eğitim örnekleri arasındaki ortalama gradyan daha sonra kırpılır. Bir partide tüketilen örneklerin toplam sayısı, yani gradyan inişinin bir adımı aynı kalır. Mikro partilerin sayısı, parti boyutunu eşit olarak bölmelidir.
  4. learning_rate (şamandıra) - Bu hyperparameter zaten vanilya SGD bulunmaktadır. Öğrenme oranı ne kadar yüksek olursa, her güncelleme o kadar önemlidir. Güncellemeler gürültülü ise (örneğin, kırpma eşiğine kıyasla ek gürültünün büyük olması gibi), düşük bir öğrenme oranı eğitim prosedürünün yakınsamasına yardımcı olabilir.

Makul düzeyde doğru bir model (%95 test doğruluğu) elde etmek için aşağıdaki hiperparametre değerlerini kullanın:

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

Modeli oluşturun

Öğrenme modeli olarak bir evrişimsel sinir ağı tanımlayın.

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

Öğrenme modeli için optimize edici ve kayıp işlevini tanımlayın. Kaybı, her eğitim noktasında gradyan manipülasyonunu desteklemek için bir mini parti üzerinden ortalama olarak değil, örnek başına bir kayıp vektörü olarak hesaplayın.

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)

Modeli eğit

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>

Diferansiyel gizlilik garantisini ölçün

Bir eğitim algoritması tarafından elde edilen DP garantisini ölçmek için bir gizlilik analizi yapın. Elde edilen DP seviyesinin bilinmesi, ikisinden hangisinin daha fazla gizliliği koruduğunu belirlemek için iki eğitim çalışmasının nesnel karşılaştırmasını sağlar. Yüksek düzeyde, gizlilik analizi, potansiyel bir düşmanın, eğitim prosedürünün sonucunu (örneğin, model güncellemeleri ve parametreleri) gözlemleyerek herhangi bir bireysel eğitim noktasının özellikleri hakkındaki tahminlerini ne kadar geliştirebileceğini ölçer.

Bu garanti bazen gizlilik bütçe olarak adlandırılır. Daha düşük bir gizlilik bütçesi, bir rakibin tahminlerini geliştirme yeteneğini daha sıkı sınırlar. Bu, daha güçlü bir gizlilik garantisi sağlar. Sezgisel olarak bunun nedeni, tek bir eğitim noktasının öğrenmenin sonucunu etkilemesinin daha zor olmasıdır: örneğin, eğitim noktasında yer alan bilgiler ML algoritması tarafından ezberlenemez ve bu eğitim noktasına katkıda bulunan bireyin mahremiyeti, veri seti korunur.

Bu eğitimde, gizlilik analizi göre saf bir DP gevşeme Rényi Diferansiyel Gizlilik çerçevesinde (RDP) gerçekleştirilir , bu kağıdın , özellikle de DP-SGD için uygundur.

Bir ML algoritmasının DP garantisini ifade etmek için iki ölçüm kullanılır:

  1. Delta (\(\delta\)) - taşınmaması gizlilik garantisi olasılığını aut. Temel kural, onu eğitim veri kümesinin boyutunun tersinden daha küçük olacak şekilde ayarlamaktır. Bu eğitimde, görüşmenin 10 olarak ayarlanır ^ -5 MNIST veri kümesi 60.000 eğitim noktaları vardır olarak.
  2. Epsilon (\(\epsilon\)) - Bu gizlilik bütçedir. Tek bir eğitim noktası dahil ederek (veya hariç tutarak) belirli bir model çıktısının olasılığının ne kadar değişebileceğini sınırlayarak gizlilik garantisinin gücünü ölçer. İçin daha küçük bir değer \(\epsilon\) daha iyi bir gizlilik garantisi ima eder. Ancak, \(\epsilon\) değeri yalnızca bir üst bağlı olup, büyük bir değer olabilir pratikte hala ortalama iyi gizlilik.

Tensorflow Gizlilik bir araç sağlar compute_dp_sgd_privacy değerini hesaplamak için, \(\epsilon\) sabit bir değer verildi \(\delta\) ve eğitim işlemi aşağıdaki hyperparameters:

  1. Eğitim seti içerisinde puan sayısı, n .
  2. batch_size .
  3. noise_multiplier .
  4. Sayısı epochs eğitimi.
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)

Aracı raporları yukarıda seçilmiş hyperparameters için, eğitilmiş model olduğu \(\epsilon\) 1.18 değerini.

Özet

Bu öğreticide, farklı gizlilik (DP) ve eğitim verileri için gizlilik garantileri sağlamak üzere DP ilkelerini mevcut ML algoritmalarında nasıl uygulayabileceğinizi öğrendiniz. Özellikle, şunları nasıl yapacağınızı öğrendiniz:

  • TensorFlow Privacy'yi kullanarak mevcut optimize edicileri (ör. SGD, Adam) diferansiyel olarak özel karşılıklarına sarın
  • Diferansiyel olarak özel makine öğrenimi tarafından sunulan hiperparametreleri ayarlayın
  • TensorFlow Privacy'de bulunan analiz araçlarını kullanarak sağlanan gizlilik garantisini ölçün