Contoh permusuhan menggunakan FGSM

Tutorial ini membuat contoh permusuhan menggunakan serangan Fast Gradient Signed Method (FGSM) seperti yang dijelaskan dalam Menjelaskan dan Memanfaatkan Contoh Permusuhan oleh Goodfellow et al . Ini adalah salah satu serangan pertama dan paling populer untuk mengelabui jaringan saraf.

Apa contoh permusuhan?

Contoh permusuhan adalah input khusus yang dibuat dengan tujuan membingungkan jaringan saraf, yang mengakibatkan kesalahan klasifikasi input yang diberikan. Input terkenal ini tidak dapat dibedakan dengan mata manusia, tetapi menyebabkan jaringan gagal mengidentifikasi konten gambar. Ada beberapa jenis serangan seperti itu, namun di sini fokusnya adalah pada serangan metode tanda gradien cepat, yang merupakan serangan kotak putih yang tujuannya adalah untuk memastikan kesalahan klasifikasi. Serangan kotak putih adalah di mana penyerang memiliki akses penuh ke model yang diserang. Salah satu contoh paling terkenal dari gambar permusuhan yang ditunjukkan di bawah ini diambil dari makalah yang disebutkan di atas.

Di sini, dimulai dengan gambar panda, penyerang menambahkan gangguan kecil (distorsi) ke gambar asli, yang mengakibatkan model melabeli gambar ini sebagai siamang, dengan keyakinan tinggi. Proses penambahan gangguan ini dijelaskan di bawah ini.

Metode tanda gradien cepat

Metode tanda gradien cepat bekerja dengan menggunakan gradien jaringan saraf untuk membuat contoh permusuhan. Untuk gambar input, metode ini menggunakan gradien kerugian sehubungan dengan gambar input untuk membuat gambar baru yang memaksimalkan kerugian. Citra baru ini disebut citra permusuhan. Ini dapat diringkas menggunakan ekspresi berikut:

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

di mana

• adv_x : Gambar permusuhan.
• x : Gambar masukan asli.
• y : Label masukan asli.
• \(\epsilon\) : Pengganda untuk memastikan gangguan kecil.
• \(\theta\) : Parameter model.
• \(J\) : Rugi.

Properti yang menarik di sini, adalah fakta bahwa gradien diambil sehubungan dengan gambar input. Hal ini dilakukan karena tujuannya adalah untuk menciptakan citra yang memaksimalkan kerugian. Sebuah metode untuk mencapai ini adalah untuk menemukan seberapa banyak setiap piksel dalam gambar berkontribusi pada nilai kerugian, dan menambahkan gangguan yang sesuai. Ini bekerja cukup cepat karena mudah untuk menemukan bagaimana setiap piksel input berkontribusi pada kerugian dengan menggunakan aturan rantai dan menemukan gradien yang diperlukan. Oleh karena itu, gradien diambil sehubungan dengan gambar. Selain itu, karena model tidak lagi dilatih (dengan demikian gradien tidak diambil sehubungan dengan variabel yang dapat dilatih, yaitu parameter model), dan parameter model tetap konstan. Satu-satunya tujuan adalah untuk menipu model yang sudah terlatih.

Jadi mari kita coba menipu model yang sudah terlatih. Dalam tutorial ini, modelnya adalah model MobileNetV2 , yang telah dilatih sebelumnya di 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

Mari kita muat model MobileNetV2 yang telah dilatih sebelumnya dan nama kelas 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 [==============================] - 0s 0us/step
14548992/14536120 [==============================] - 0s 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]

Gambar asli

Mari gunakan contoh gambar Labrador Retriever oleh Mirko CC-BY-SA 3.0 dari Wikimedia Common dan buat contoh permusuhan darinya. Langkah pertama adalah melakukan preprocess sehingga dapat dimasukkan sebagai input ke model 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
98304/83281 [===================================] - 0s 0us/step

Mari kita lihat gambarnya.

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
49152/35363 [=========================================] - 0s 0us/step

Buat gambar permusuhan

Menerapkan metode tanda gradien cepat

Langkah pertama adalah membuat gangguan yang akan digunakan untuk mendistorsi gambar asli sehingga menghasilkan gambar yang berlawanan. Seperti disebutkan, untuk tugas ini, gradien diambil sehubungan dengan gambar.

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

Gangguan yang dihasilkan juga dapat divisualisasikan.

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

Mari kita coba ini untuk nilai epsilon yang berbeda dan amati gambar yang dihasilkan. Anda akan melihat bahwa ketika nilai epsilon meningkat, jaringan menjadi lebih mudah untuk ditipu. Namun, ini datang sebagai trade-off yang menghasilkan gangguan menjadi lebih dapat diidentifikasi.

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

Langkah selanjutnya

Sekarang setelah Anda mengetahui tentang serangan adversarial, cobalah ini pada kumpulan data dan arsitektur yang berbeda. Anda juga dapat membuat dan melatih model Anda sendiri, lalu mencoba membodohinya menggunakan metode yang sama. Anda juga dapat mencoba dan melihat bagaimana kepercayaan pada prediksi bervariasi saat Anda mengubah epsilon.

Meskipun kuat, serangan yang ditunjukkan dalam tutorial ini hanyalah awal dari penelitian tentang serangan permusuhan, dan ada banyak makalah yang menciptakan serangan yang lebih kuat sejak saat itu. Selain serangan permusuhan, penelitian juga mengarah pada penciptaan pertahanan, yang bertujuan untuk menciptakan model pembelajaran mesin yang kuat. Anda dapat meninjau makalah survei ini untuk daftar lengkap serangan dan pertahanan permusuhan.

Untuk lebih banyak implementasi serangan dan pertahanan permusuhan, Anda mungkin ingin melihat perpustakaan contoh permusuhan CleverHans .