 Ver no TensorFlow.org |  Executar no Google Colab |  Ver fonte no GitHub |  Baixar caderno |
Visão geral
Privacidade diferencial (DP) é uma estrutura para medir as garantias de privacidade fornecidas por um algoritmo. Através das lentes da privacidade diferencial, você pode projetar algoritmos de aprendizado de máquina que treinam modelos de forma responsável em dados privados. O aprendizado com privacidade diferencial fornece garantias mensuráveis de privacidade, ajudando a mitigar o risco de exposição de dados de treinamento confidenciais no aprendizado de máquina. Intuitivamente, um modelo treinado com privacidade diferencial não deve ser afetado por nenhum exemplo de treinamento único ou pequeno conjunto de exemplos de treinamento em seu conjunto de dados. Isso ajuda a mitigar o risco de expor dados de treinamento confidenciais no ML.
A ideia básica dessa abordagem, chamada de gradiente descendente estocástico diferencialmente privado (DP-SGD), é modificar os gradientes usados no gradiente descendente estocástico (SGD), que está no centro de quase todos os algoritmos de aprendizado profundo. Modelos treinados com DP-SGD fornecem garantias de privacidade diferencial comprovadas para seus dados de entrada. Existem duas modificações feitas no algoritmo SGD vanilla:
- Primeiro, a sensibilidade de cada gradiente precisa ser limitada. Em outras palavras, você precisa limitar o quanto cada ponto de treinamento individual amostrado em um minilote pode influenciar os cálculos de gradiente e as atualizações resultantes aplicadas aos parâmetros do modelo. Isso pode ser feito por recorte cada gradiente calculado em cada ponto de formação.
- Ruído aleatório é amostrado e adicionados aos gradientes cortadas para torná-lo estatisticamente impossível saber se ou não um ponto de dados específico foi incluído no conjunto de dados de treinamento, comparando as atualizações SGD se aplica quando se opera com ou sem esse ponto de dados particular no conjunto de dados de treinamento .
Isto usa tutoriais tf.keras para treinar uma rede neural convolutional (CNN) para reconhecer dígitos escritos à mão com o otimizador DP-SGD fornecido pelo TensorFlow biblioteca de Privacidade. A privacidade do TensorFlow fornece código que envolve um otimizador do TensorFlow existente para criar uma variante que implementa o DP-SGD.
Configurar
Comece importando as bibliotecas necessárias:
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
Instale a privacidade do TensorFlow.
pip install tensorflow-privacy
import tensorflow_privacy
from tensorflow_privacy.privacy.analysis import compute_dp_sgd_privacy
Carregar e pré-processar o conjunto de dados
Carregar o MNIST conjunto de dados e preparar os dados para o treinamento.
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
Defina os hiperparâmetros
Defina os valores dos hiperparâmetros do modelo de aprendizado.
epochs = 3
batch_size = 250
O DP-SGD tem três hiperparâmetros específicos de privacidade e um hiperamador existente que você deve ajustar:
-
l2_norm_clip(flutuador) - O máximo Euclidiano (L2) de cada gradiente norma que é aplicado com os parâmetros de actualização do modelo. Este hiperparâmetro é usado para limitar a sensibilidade do otimizador a pontos de treinamento individuais. -
noise_multiplier(flutuador) - A quantidade de ruído amostrado e adicionado a gradientes durante o treino. Geralmente, mais ruído resulta em melhor privacidade (geralmente, mas não necessariamente, às custas de menor utilidade). -
microbatches(int) - Cada lote de dados são divididos em unidades mais pequenas chamadas microbatches. Por padrão, cada microlote deve conter um único exemplo de treinamento. Isso nos permite cortar gradientes por exemplo, em vez de depois de terem sido calculadas a média no minilote. Isso, por sua vez, diminui o efeito (negativo) do corte no sinal encontrado no gradiente e normalmente maximiza a utilidade. No entanto, a sobrecarga computacional pode ser reduzida aumentando o tamanho dos microlotes para incluir mais de um exemplo de treinamento. O gradiente médio nesses vários exemplos de treinamento é então cortado. O número total de exemplos consumidos em um lote, ou seja, um passo de gradiente descendente, permanece o mesmo. O número de microlotes deve dividir igualmente o tamanho do lote. -
learning_rate(float) - Este hiperparâmetro já existe no baunilha SGD. Quanto maior a taxa de aprendizado, mais importa cada atualização. Se as atualizações forem ruidosas (como quando o ruído aditivo é grande em comparação com o limite de corte), uma baixa taxa de aprendizado pode ajudar o procedimento de treinamento a convergir.
Use os valores de hiperparâmetros abaixo para obter um modelo razoavelmente preciso (95% de precisão do teste):
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')
Construir o modelo
Defina uma rede neural convolucional como o modelo de aprendizado.
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)
])
Defina o otimizador e a função de perda para o modelo de aprendizado. Calcule a perda como um vetor de perdas por exemplo e não como a média em um minilote para suportar a manipulação de gradiente em cada ponto de treinamento.
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)
Treine o modelo
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>
Meça a garantia de privacidade diferencial
Realize uma análise de privacidade para medir a garantia de DP alcançada por um algoritmo de treinamento. Conhecer o nível de DP alcançado permite a comparação objetiva de duas execuções de treinamento para determinar qual das duas preserva mais a privacidade. Em um nível alto, a análise de privacidade mede o quanto um adversário em potencial pode melhorar seu palpite sobre as propriedades de qualquer ponto de treinamento individual observando o resultado do procedimento de treinamento (por exemplo, atualizações e parâmetros do modelo).
Esta garantia é por vezes referido como o orçamento privacidade. Um orçamento de privacidade menor limita mais fortemente a capacidade de um adversário de melhorar sua suposição. Isso garante uma garantia de privacidade mais forte. Intuitivamente, isso ocorre porque é mais difícil para um único ponto de treinamento afetar o resultado do aprendizado: por exemplo, as informações contidas no ponto de treinamento não podem ser memorizadas pelo algoritmo de ML e a privacidade do indivíduo que contribuiu com esse ponto de treinamento para o conjunto de dados é preservado.
Neste tutorial, a análise de privacidade é realizada no âmbito de Privacidade Rényi Diferencial (RDP), que é um relaxamento da DP puro com base em este papel que é particularmente adequado para a DP-SGD.
Duas métricas são usadas para expressar a garantia DP de um algoritmo de ML:
- Delta (\(\delta\)) - limites a probabilidade da garantia de privacidade não segurando. Uma regra prática é defini-lo como menor que o inverso do tamanho do conjunto de dados de treinamento. Neste tutorial, ela é definida como 10 ^ -5 como o conjunto de dados MNIST tem 60.000 pontos de treinamento.
- Epsilon (\(\epsilon\)) - Este é o orçamento privacidade. Ele mede a força da garantia de privacidade limitando o quanto a probabilidade de uma saída de modelo específica pode variar incluindo (ou excluindo) um único ponto de treinamento. Um valor menor para \(\epsilon\) implica uma melhor garantia de privacidade. No entanto, a \(\epsilon\) valor é apenas um limite superior e um grande valor ainda podia média boa privacidade na prática.
Tensorflow Privacidade fornece uma ferramenta, compute_dp_sgd_privacy , para calcular o valor da \(\epsilon\) dado um valor fixo de \(\delta\) e as seguintes hiperparâmetros do processo de formação:
- O número total de pontos nos dados de treinamento,
n. - O
batch_size. - O
noise_multiplier. - O número de
epochsde treinamento.
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)
Os relatórios de ferramentas que para os hiperparâmetros escolhidos acima, o modelo treinado tem uma \(\epsilon\) valor de 1,18.
Resumo
Neste tutorial, você aprendeu sobre privacidade diferencial (DP) e como implementar princípios de DP em algoritmos de ML existentes para fornecer garantias de privacidade para dados de treinamento. Em particular, você aprendeu a:
- Envolva os otimizadores existentes (por exemplo, SGD, Adam) em suas contrapartes privadas diferenciadas usando o TensorFlow Privacy
- Ajustar hiperparâmetros introduzidos pelo aprendizado de máquina diferencialmente privado
- Meça a garantia de privacidade fornecida usando as ferramentas de análise incluídas no TensorFlow Privacy