इस पेज का अनुवाद Cloud Translation API से किया गया है.

TensorFlow गोपनीयता के साथ डिफरेंशियल प्राइवेसी लागू करें

TensorFlow.org पर देखें

Google Colab में चलाएं

GitHub पर स्रोत देखें

नोटबुक डाउनलोड करें

अवलोकन

अंतर गोपनीयता (डीपी) एक एल्गोरिथ्म द्वारा प्रदान की गोपनीयता की गारंटी देता है मापने के लिए एक रूपरेखा है। डिफरेंशियल प्राइवेसी के लेंस के माध्यम से, आप मशीन लर्निंग एल्गोरिदम डिज़ाइन कर सकते हैं जो निजी डेटा पर मॉडल को जिम्मेदारी से प्रशिक्षित करते हैं। डिफरेंशियल प्राइवेसी के साथ सीखना गोपनीयता की मापनीय गारंटी प्रदान करता है, मशीन लर्निंग में संवेदनशील प्रशिक्षण डेटा को उजागर करने के जोखिम को कम करने में मदद करता है। सहज रूप से, डिफरेंशियल प्राइवेसी के साथ प्रशिक्षित मॉडल अपने डेटा सेट में किसी एक प्रशिक्षण उदाहरण या प्रशिक्षण उदाहरणों के छोटे सेट से प्रभावित नहीं होना चाहिए। यह एमएल में संवेदनशील प्रशिक्षण डेटा को उजागर करने के जोखिम को कम करने में मदद करता है।

इस दृष्टिकोण का मूल विचार, जिसे डिफरेंशियल प्राइवेट स्टोकेस्टिक ग्रेडिएंट डिसेंट (DP-SGD) कहा जाता है, स्टोकेस्टिक ग्रेडिएंट डिसेंट (SGD) में उपयोग किए जाने वाले ग्रेडिएंट को संशोधित करना है, जो लगभग सभी डीप लर्निंग एल्गोरिदम के मूल में है। DP-SGD से प्रशिक्षित मॉडल अपने इनपुट डेटा के लिए सिद्ध अंतर गोपनीयता गारंटी प्रदान करते हैं। वेनिला SGD एल्गोरिथम में दो संशोधन किए गए हैं:

सबसे पहले, प्रत्येक ढाल की संवेदनशीलता को सीमित करने की आवश्यकता है। दूसरे शब्दों में, आपको यह सीमित करने की आवश्यकता है कि मिनीबैच में नमूना किया गया प्रत्येक व्यक्तिगत प्रशिक्षण बिंदु ग्रेडिएंट कंप्यूटेशंस और मॉडल मापदंडों पर लागू होने वाले अपडेट को कितना प्रभावित कर सकता है। यह प्रत्येक ढाल प्रत्येक प्रशिक्षण मुद्दे पर गणना की कतरन द्वारा किया जा सकता।
रैंडम शोर नमूना है और जब यह साथ या प्रशिक्षण डाटासेट में इस विशेष डेटा बिंदु के बिना संचालित SGD लागू होता है अद्यतन की तुलना द्वारा काटा गया ढ़ाल को जोड़ा गया यह सांख्यिकीय रूप से असंभव को पता है या नहीं, एक विशेष डेटा बिंदु प्रशिक्षण डाटासेट में शामिल किया गया था बनाने के लिए किया जाता है .

इस ट्यूटोरियल का उपयोग करता है tf.keras एक convolutional तंत्रिका नेटवर्क (सीएनएन) को प्रशिक्षित करने के डी पी-SGD TensorFlow गोपनीयता पुस्तकालय द्वारा प्रदान की अनुकूलक के साथ हस्तलिखित अंक पहचान करने के लिए। TensorFlow गोपनीयता कोड प्रदान करती है जो DP-SGD को लागू करने वाला एक संस्करण बनाने के लिए मौजूदा TensorFlow अनुकूलक को लपेटता है।

सेट अप

आवश्यक पुस्तकालयों को आयात करके प्रारंभ करें:

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 गोपनीयता स्थापित करें।

pip install tensorflow-privacy

import tensorflow_privacy

from tensorflow_privacy.privacy.analysis import compute_dp_sgd_privacy

डेटासेट को लोड और प्री-प्रोसेस करें

लोड MNIST डाटासेट और प्रशिक्षण के लिए डेटा तैयार करते हैं।

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

हाइपरपैरामीटर को परिभाषित करें

लर्निंग मॉडल हाइपरपरमेटर मान सेट करें।

epochs = 3
batch_size = 250

DP-SGD में तीन गोपनीयता-विशिष्ट हाइपरपैरामीटर और एक मौजूदा हाइपरमैटर है जिसे आपको ट्यून करना चाहिए:

l2_norm_clip (नाव) - अधिकतम इयूक्लिडियन (एल 2) प्रत्येक ढाल कि अद्यतन मॉडल मापदंडों को लागू किया जाता का आदर्श। इस हाइपरपैरामीटर का उपयोग व्यक्तिगत प्रशिक्षण बिंदुओं के लिए अनुकूलक की संवेदनशीलता को बाध्य करने के लिए किया जाता है।
noise_multiplier (नाव) - शोर की मात्रा नमूना और प्रशिक्षण के दौरान ढ़ाल को जोड़ा गया। आम तौर पर, अधिक शोर के परिणामस्वरूप बेहतर गोपनीयता होती है (अक्सर, लेकिन जरूरी नहीं कि कम उपयोगिता की कीमत पर)।
microbatches (पूर्णांक) - डेटा के प्रत्येक बैच छोटी इकाइयों microbatches कहा जाता है में विभाजित है। डिफ़ॉल्ट रूप से, प्रत्येक माइक्रोबैच में एक प्रशिक्षण उदाहरण होना चाहिए। यह हमें ग्रेडिएंट को मिनीबैच में औसत किए जाने के बजाय प्रति-उदाहरण के आधार पर क्लिप करने की अनुमति देता है। यह बदले में ढाल में पाए जाने वाले सिग्नल पर क्लिपिंग के (नकारात्मक) प्रभाव को कम करता है और आमतौर पर उपयोगिता को अधिकतम करता है। हालांकि, एक से अधिक प्रशिक्षण उदाहरणों को शामिल करने के लिए माइक्रोबैच के आकार को बढ़ाकर कम्प्यूटेशनल ओवरहेड को कम किया जा सकता है। फिर इन कई प्रशिक्षण उदाहरणों में औसत ढाल काटा जाता है। एक बैच में खपत किए गए उदाहरणों की कुल संख्या, यानी ग्रेडिएंट डिसेंट का एक चरण, वही रहता है। माइक्रोबैच की संख्या को बैच आकार को समान रूप से विभाजित करना चाहिए।
learning_rate (नाव) - यह पहले से ही hyperparameter वेनिला SGD में मौजूद है। सीखने की दर जितनी अधिक होगी, प्रत्येक अपडेट उतना ही अधिक मायने रखता है। यदि अपडेट शोर हैं (जैसे कि जब क्लिपिंग थ्रेशोल्ड की तुलना में एडिटिव शोर बड़ा होता है), तो कम सीखने की दर प्रशिक्षण प्रक्रिया को अभिसरण करने में मदद कर सकती है।

उचित रूप से सटीक मॉडल (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')

मॉडल बनाएं

सीखने के मॉडल के रूप में एक दृढ़ तंत्रिका नेटवर्क को परिभाषित करें।

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

लर्निंग मॉडल के लिए ऑप्टिमाइज़र और लॉस फंक्शन को परिभाषित करें। प्रत्येक प्रशिक्षण बिंदु पर ढाल हेरफेर का समर्थन करने के लिए एक मिनीबैच पर माध्य के बजाय प्रति-उदाहरण के नुकसान के वेक्टर के रूप में नुकसान की गणना करें।

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)

मॉडल को प्रशिक्षित करें

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>

अंतर गोपनीयता गारंटी को मापें

एक प्रशिक्षण एल्गोरिथ्म द्वारा प्राप्त डीपी गारंटी को मापने के लिए गोपनीयता विश्लेषण करें। प्राप्त डीपी के स्तर को जानने से दो प्रशिक्षण रनों की उद्देश्य तुलना यह निर्धारित करने में सक्षम होती है कि दोनों में से कौन अधिक गोपनीयता-संरक्षण है। उच्च स्तर पर, गोपनीयता विश्लेषण यह मापता है कि प्रशिक्षण प्रक्रिया के परिणाम (जैसे, मॉडल अपडेट और पैरामीटर) को देखकर एक संभावित विरोधी किसी भी व्यक्तिगत प्रशिक्षण बिंदु के गुणों के बारे में अपने अनुमान में कितना सुधार कर सकता है।

यह गारंटी कभी कभी गोपनीयता बजट के रूप में जाना जाता है। एक कम गोपनीयता बजट अपने अनुमान को बेहतर बनाने के लिए एक विरोधी की क्षमता को और अधिक मजबूती से सीमित करता है। यह एक मजबूत गोपनीयता गारंटी सुनिश्चित करता है। सहज रूप से, ऐसा इसलिए है क्योंकि एक प्रशिक्षण बिंदु के लिए सीखने के परिणाम को प्रभावित करना कठिन होता है: उदाहरण के लिए, प्रशिक्षण बिंदु में निहित जानकारी को एमएल एल्गोरिथम द्वारा याद नहीं किया जा सकता है और इस प्रशिक्षण बिंदु में योगदान देने वाले व्यक्ति की गोपनीयता को याद नहीं किया जा सकता है। डाटासेट संरक्षित है।

इस ट्यूटोरियल में, गोपनीयता विश्लेषण Rényi विभेदक गोपनीयता के ढांचे (RDP) है, जो शुद्ध के आधार पर डी पी के एक विश्राम है में किया जाता है इस पत्र है कि विशेष रूप से अच्छी तरह से डी पी-SGD के लिए उपयुक्त है।

एक एमएल एल्गोरिथम की डीपी गारंटी को व्यक्त करने के लिए दो मेट्रिक्स का उपयोग किया जाता है:

डेल्टा (\(\delta\)) - गोपनीयता गारंटी पकड़े नहीं की संभावना सीमा। अंगूठे का एक नियम इसे प्रशिक्षण डेटासेट के आकार के व्युत्क्रम से कम पर सेट करना है। इस ट्यूटोरियल में, यह 10 के लिए सेट है ^ -5 के रूप में MNIST डाटासेट 60,000 प्रशिक्षण अंक हैं।
एप्सिलॉन (\(\epsilon\)) - यह गोपनीयता बजट है। यह एक प्रशिक्षण बिंदु को शामिल (या छोड़कर) करके किसी विशेष मॉडल आउटपुट की संभावना कितनी भिन्न हो सकती है, इसे सीमित करके गोपनीयता गारंटी की ताकत को मापता है। के लिए एक छोटे मूल्य \(\epsilon\) एक बेहतर गोपनीयता की गारंटी निकलता है। हालांकि, \(\epsilon\) मूल्य केवल एक ऊपरी बाध्य है और एक बड़ा मूल्य व्यवहार में अभी भी मतलब अच्छा गोपनीयता सकता है।

Tensorflow गोपनीयता के लिए एक उपकरण प्रदान करता है compute_dp_sgd_privacy के मूल्य की गणना करने, \(\epsilon\) की एक निश्चित मान दिया \(\delta\) और प्रशिक्षण प्रक्रिया से निम्नलिखित hyperparameters:

प्रशिक्षण डेटा में अंकों की कुल संख्या, n ।
batch_size ।
noise_multiplier ।
की संख्या epochs प्रशिक्षण के।

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)

उपकरण रिपोर्ट hyperparameters ऊपर चुने के लिए, प्रशिक्षित मॉडल एक है कि \(\epsilon\) 1.18 का मूल्य।

सारांश

इस ट्यूटोरियल में, आपने डिफरेंशियल प्राइवेसी (डीपी) के बारे में सीखा और प्रशिक्षण डेटा के लिए गोपनीयता की गारंटी प्रदान करने के लिए आप मौजूदा एमएल एल्गोरिदम में डीपी सिद्धांतों को कैसे लागू कर सकते हैं, इसके बारे में सीखा। विशेष रूप से, आपने सीखा कि कैसे:

TensorFlow गोपनीयता का उपयोग करके मौजूदा अनुकूलक (जैसे, SGD, एडम) को उनके अलग-अलग निजी समकक्षों में लपेटें
अलग-अलग निजी मशीन लर्निंग द्वारा पेश किए गए ट्यून हाइपरपैरामीटर
TensorFlow गोपनीयता में शामिल विश्लेषण टूल का उपयोग करके प्रदान की गई गोपनीयता गारंटी को मापें