सहायता Kaggle पर TensorFlow साथ ग्रेट बैरियर रीफ की रक्षा चैलेंज में शामिल हों

FGSM का उपयोग करते हुए प्रतिकूल उदाहरण

TensorFlow.org पर देखें GitHub पर स्रोत देखें नोटबुक डाउनलोड करें

इस ट्यूटोरियल एक विरोधात्मक उदाहरण में बताए अनुसार फास्ट ढाल हस्ताक्षर विधि (FGSM) हमले का उपयोग कर बनाता है यह समझाते हुए और दोहन विरोधात्मक उदाहरण गुडफेलो एट अल द्वारा। यह तंत्रिका नेटवर्क को मूर्ख बनाने वाले पहले और सबसे लोकप्रिय हमलों में से एक था।

एक प्रतिकूल उदाहरण क्या है?

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

प्रतिकूल उदाहरण

यहां, एक पांडा की छवि से शुरू करते हुए, हमलावर मूल छवि में छोटे गड़बड़ी (विकृतियां) जोड़ता है, जिसके परिणामस्वरूप मॉडल इस छवि को एक गिब्बन के रूप में लेबल करता है, उच्च आत्मविश्वास के साथ। इन गड़बड़ियों को जोड़ने की प्रक्रिया को नीचे समझाया गया है।

तेजी से ढाल संकेत विधि

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

\[adv\_x = x + \epsilon*\text{sign}(\nabla_xJ(\theta, x, y))\]

कहां

  • adv_x : प्रतिकूल छवि।
  • एक्स: मूल इनपुट छवि।
  • y: मूल इनपुट लेबल।
  • \(\epsilon\) : गुणक सुनिश्चित करने के लिए विचलन छोटे हैं।
  • \(\theta\) : मॉडल मापदंडों।
  • \(J\) : घटाने।

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

तो चलिए कोशिश करते हैं और एक ढोंगी मॉडल को बेवकूफ बनाते हैं। इस ट्यूटोरियल में, मॉडल है MobileNetV2 मॉडल, पर pretrained ImageNet

import tensorflow as tf
import matplotlib as mpl
import matplotlib.pyplot as plt

mpl.rcParams['figure.figsize'] = (8, 8)
mpl.rcParams['axes.grid'] = False

आइए पहले से प्रशिक्षित MobileNetV2 मॉडल और ImageNet वर्ग के नाम लोड करें।

pretrained_model = tf.keras.applications.MobileNetV2(include_top=True,
                                                     weights='imagenet')
pretrained_model.trainable = False

# ImageNet labels
decode_predictions = tf.keras.applications.mobilenet_v2.decode_predictions
Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/mobilenet_v2/mobilenet_v2_weights_tf_dim_ordering_tf_kernels_1.0_224.h5
14540800/14536120 [==============================] - 1s 0us/step
# Helper function to preprocess the image so that it can be inputted in MobileNetV2
def preprocess(image):
  image = tf.cast(image, tf.float32)
  image = tf.image.resize(image, (224, 224))
  image = tf.keras.applications.mobilenet_v2.preprocess_input(image)
  image = image[None, ...]
  return image

# Helper function to extract labels from probability vector
def get_imagenet_label(probs):
  return decode_predictions(probs, top=1)[0][0]

मूल छवि

चलो एक का एक नमूना छवि का उपयोग करते हैं लेब्राडार कुत्ता मिरको द्वारा CC-BY-SA 3.0 विकिमीडिया आम से और इसे से विरोधात्मक उदाहरण पैदा करते हैं। पहला कदम इसे प्रीप्रोसेस करना है ताकि इसे MobileNetV2 मॉडल में इनपुट के रूप में फीड किया जा सके।

image_path = tf.keras.utils.get_file('YellowLabradorLooking_new.jpg', 'https://storage.googleapis.com/download.tensorflow.org/example_images/YellowLabradorLooking_new.jpg')
image_raw = tf.io.read_file(image_path)
image = tf.image.decode_image(image_raw)

image = preprocess(image)
image_probs = pretrained_model.predict(image)
Downloading data from https://storage.googleapis.com/download.tensorflow.org/example_images/YellowLabradorLooking_new.jpg
90112/83281 [================================] - 0s 0us/step

आइए एक नजर डालते हैं छवि पर।

plt.figure()
plt.imshow(image[0] * 0.5 + 0.5)  # To change [-1, 1] to [0,1]
_, image_class, class_confidence = get_imagenet_label(image_probs)
plt.title('{} : {:.2f}% Confidence'.format(image_class, class_confidence*100))
plt.show()
Downloading data from https://storage.googleapis.com/download.tensorflow.org/data/imagenet_class_index.json
40960/35363 [==================================] - 0s 0us/step

पीएनजी

प्रतिकूल छवि बनाएं

तेजी से ढाल संकेत पद्धति को लागू करना

पहला कदम गड़बड़ी पैदा करना है जिसका उपयोग मूल छवि को विकृत करने के लिए किया जाएगा जिसके परिणामस्वरूप एक प्रतिकूल छवि होगी। जैसा कि उल्लेख किया गया है, इस कार्य के लिए, छवि के संबंध में ग्रेडिएंट्स लिए गए हैं।

loss_object = tf.keras.losses.CategoricalCrossentropy()

def create_adversarial_pattern(input_image, input_label):
  with tf.GradientTape() as tape:
    tape.watch(input_image)
    prediction = pretrained_model(input_image)
    loss = loss_object(input_label, prediction)

  # Get the gradients of the loss w.r.t to the input image.
  gradient = tape.gradient(loss, input_image)
  # Get the sign of the gradients to create the perturbation
  signed_grad = tf.sign(gradient)
  return signed_grad

परिणामी गड़बड़ी को भी देखा जा सकता है।

# Get the input label of the image.
labrador_retriever_index = 208
label = tf.one_hot(labrador_retriever_index, image_probs.shape[-1])
label = tf.reshape(label, (1, image_probs.shape[-1]))

perturbations = create_adversarial_pattern(image, label)
plt.imshow(perturbations[0] * 0.5 + 0.5);  # To change [-1, 1] to [0,1]
<matplotlib.image.AxesImage at 0x7f4171d66690>

पीएनजी

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

def display_images(image, description):
  _, label, confidence = get_imagenet_label(pretrained_model.predict(image))
  plt.figure()
  plt.imshow(image[0]*0.5+0.5)
  plt.title('{} \n {} : {:.2f}% Confidence'.format(description,
                                                   label, confidence*100))
  plt.show()
epsilons = [0, 0.01, 0.1, 0.15]
descriptions = [('Epsilon = {:0.3f}'.format(eps) if eps else 'Input')
                for eps in epsilons]

for i, eps in enumerate(epsilons):
  adv_x = image + eps*perturbations
  adv_x = tf.clip_by_value(adv_x, -1, 1)
  display_images(adv_x, descriptions[i])

पीएनजी

पीएनजी

पीएनजी

पीएनजी

अगला कदम

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

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

विरोधात्मक हमलों और सुरक्षा के कई और अधिक कार्यान्वयन के लिए, आप विरोधात्मक उदाहरण लाइब्रेरी को देखने के लिए चाहते हो सकता है CleverHans