Wdrażaj zróżnicowaną prywatność dzięki prywatności TensorFlow

Zobacz na TensorFlow.org Uruchom w Google Colab Wyświetl źródło na GitHub Pobierz notatnik

Przegląd

Prywatność różnicowego (DP) stanowi ramy dla pomiaru gwarancje prywatności dostarczonych przez algorytm. Przez pryzmat prywatności różnicowej możesz projektować algorytmy uczenia maszynowego, które odpowiedzialnie szkolą modele na danych prywatnych. Uczenie się z prywatnością różnicową zapewnia wymierne gwarancje prywatności, pomagając zmniejszyć ryzyko ujawnienia poufnych danych szkoleniowych w uczeniu maszynowym. Intuicyjnie na model uczony z prywatnością różnicową nie powinien mieć wpływu żaden pojedynczy przykład uczący ani mały zestaw przykładów uczących w swoim zestawie danych. Pomaga to zmniejszyć ryzyko ujawnienia poufnych danych szkoleniowych w ML.

Podstawową ideą tego podejścia, zwanego różnicowo prywatnym stochastycznym spadkiem gradientu (DP-SGD), jest modyfikacja gradientów wykorzystywanych w stochastycznym zejściu gradientu (SGD), który leży u podstaw prawie wszystkich algorytmów uczenia głębokiego. Modele wytrenowane za pomocą DP-SGD zapewniają dające się udowodnić gwarancje prywatności różnicowej dla swoich danych wejściowych. Do algorytmu waniliowego SGD wprowadzono dwie modyfikacje:

  1. Po pierwsze, czułość każdego gradientu musi być ograniczona. Innymi słowy, musisz ograniczyć, w jakim stopniu każdy pojedynczy punkt treningowy próbkowany w minipartii może wpływać na obliczenia gradientów i wynikające z nich aktualizacje zastosowane do parametrów modelu. Można to zrobić przez wycinek każdego gradientu obliczana na każdy punkt szkolenia.
  2. Losowy szum jest próbkowany i dodawano do obciętych gradientów, aby statystycznie niemożliwe, aby wiedzieć, czy dany punkt danych został zawarty w zbiorze treningowym porównując aktualizacje stosuje SGD gdy działa z lub bez tego konkretnego punktu danych w zbiorze treningowym .

Ten tutorial użyje tf.keras szkolić splotowego sieci neuronowych (CNN), aby rozpoznać odręczny cyfry z optymalizatora DP-SGD dostarczonych przez bibliotekę prywatności TensorFlow. TensorFlow Privacy zapewnia kod, który opakowuje istniejący optymalizator TensorFlow, tworząc wariant implementujący DP-SGD.

Ustawiać

Zacznij od zaimportowania niezbędnych bibliotek:

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

Zainstaluj Prywatność TensorFlow.

pip install tensorflow-privacy

import tensorflow_privacy

from tensorflow_privacy.privacy.analysis import compute_dp_sgd_privacy

Załaduj i wstępnie przetwórz zbiór danych

Załaduj MNIST zbiór danych i przygotować dane do szkolenia.

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

Zdefiniuj hiperparametry

Ustaw wartości hiperparametrów modelu uczenia.

epochs = 3
batch_size = 250

DP-SGD ma trzy hiperparametry związane z prywatnością i jeden istniejący hiperamat, który należy dostroić:

  1. l2_norm_clip (rzeczywista) - maksymalna euklidesowa (L2) normą każdego gradientu, który jest stosowany do aktualizacji parametrów modelu. Ten hiperparametr służy do ograniczania czułości optymalizatora do poszczególnych punktów treningowych.
  2. noise_multiplier (rzeczywista) - ilość hałasu próbki i dodawano do nachylenia podczas treningu. Ogólnie rzecz biorąc, większy hałas oznacza lepszą prywatność (często, ale niekoniecznie, kosztem mniejszej użyteczności).
  3. microbatches (int) - Każda partia danych jest podzielona na mniejsze jednostki zwane microbatches. Domyślnie każda mikropartia powinna zawierać jeden przykład uczący. Pozwala nam to przycinać gradienty na podstawie przykładu, a nie po ich uśrednieniu w minipartii. To z kolei zmniejsza (negatywny) efekt przycinania sygnału znajdującego się w gradiencie i zazwyczaj maksymalizuje użyteczność. Jednak narzut obliczeniowy można zmniejszyć, zwiększając rozmiar mikropartii, tak aby obejmowały więcej niż jeden przykład uczący. Średni gradient w tych wielu przykładach treningowych jest następnie obcinany. Całkowita liczba przykładów wykorzystanych w partii, tj. jeden stopień opadania gradientu, pozostaje taka sama. Liczba mikropartii powinna równomiernie dzielić wielkość partii.
  4. learning_rate (float) - Ten hyperparameter już istnieje w waniliowym SGD. Im wyższy wskaźnik uczenia się, tym większe znaczenie ma każda aktualizacja. Jeśli aktualizacje są zaszumione (np. gdy szum addytywny jest duży w porównaniu z progiem obcinania), niska szybkość uczenia się może pomóc w zbieżności procedury uczenia.

Użyj poniższych wartości hiperparametrów, aby uzyskać dość dokładny model (95% dokładności testu):

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

Zbuduj model

Zdefiniuj splotową sieć neuronową jako model uczenia się.

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

Zdefiniuj optymalizator i funkcję straty dla modelu uczenia. Oblicz stratę jako wektor strat na przykład, a nie jako średnią z minipartii, aby wesprzeć manipulację gradientem w każdym punkcie treningowym.

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)

Trenuj modelkę

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>

Zmierz różnicową gwarancję prywatności

Przeprowadź analizę prywatności, aby zmierzyć gwarancję DP osiągniętą przez algorytm uczący. Znajomość osiągniętego poziomu DP umożliwia obiektywne porównanie dwóch przebiegów treningowych w celu określenia, który z nich bardziej chroni prywatność. Na wysokim poziomie analiza prywatności mierzy, o ile potencjalny przeciwnik może poprawić swoje przypuszczenia dotyczące właściwości dowolnego pojedynczego punktu szkoleniowego, obserwując wynik procedury szkoleniowej (np. aktualizacje modelu i parametry).

Niniejsza gwarancja jest czasem określane jako budżet prywatności. Niższy budżet na prywatność ściślej ogranicza zdolność przeciwnika do poprawy swoich przypuszczeń. Zapewnia to silniejszą gwarancję prywatności. Intuicyjnie dzieje się tak dlatego, że pojedynczy punkt treningowy trudniej wpłynąć na wynik uczenia się: na przykład informacje zawarte w punkcie treningowym nie mogą być zapamiętane przez algorytm ML i prywatność osoby, która wniosła ten punkt treningowy do zbiór danych jest zachowywany.

W tym tutorialu, analiza prywatność jest wykonywana w ramach Renyi Differential Prywatność (RDP), która jest relaks czystego DP opartego na tym papierze , który jest szczególnie dobrze nadaje się do DP-SGD.

Do wyrażenia gwarancji DP algorytmu ML używane są dwie metryki:

  1. Delta (\(\delta\)) - granice prawdopodobieństwa gwarancji prywatności nie trzyma. Ogólną zasadą jest ustawienie go tak, aby był mniejszy niż odwrotność rozmiaru uczącego zestawu danych. W tym ćwiczeniu jest ona ustawiona na 10 ^ -5 jako zbiór danych MNIST ma 60.000 punktów szkoleniowych.
  2. Epsilon (\(\epsilon\)) - Jest to budżet prywatności. Mierzy siłę gwarancji prywatności, ograniczając, jak bardzo może się różnić prawdopodobieństwo wystąpienia określonego modelu wyjściowego, włączając (lub wykluczając) pojedynczy punkt treningowy. Mniejsza wartość dla \(\epsilon\) oznacza gwarancję lepszej ochrony prywatności. Jednak \(\epsilon\) wartość jest jedynie górna granica i duża wartość może nadal średni dobry prywatności w praktyce.

Tensorflow prywatności dostarcza narzędzia, compute_dp_sgd_privacy , aby obliczyć wartość \(\epsilon\) danym stałą wartość \(\delta\) oraz następujące hiperparametrów z procesu szkolenia:

  1. Całkowita liczba punktów danych uczących, n .
  2. batch_size .
  3. noise_multiplier .
  4. Liczba epochs szkolenia.
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)

Raporty narzędziowe, że dla hiperparametrów wskazanych powyżej, przeszkolony model ma \(\epsilon\) wartość 1,18.

Streszczenie

W tym samouczku dowiedziałeś się o prywatności różnicowej (DP) i sposobie implementacji zasad DP w istniejących algorytmach ML, aby zapewnić gwarancje prywatności dla danych szkoleniowych. W szczególności nauczyłeś się:

  • Zapakuj istniejące optymalizatory (np. SGD, Adam) do ich zróżnicowanych, prywatnych odpowiedników za pomocą TensorFlow Privacy
  • Dostrajanie hiperparametrów wprowadzanych przez zróżnicowane prywatne uczenie maszynowe
  • Zmierz gwarancję prywatności za pomocą narzędzi analitycznych zawartych w TensorFlow Privacy