RSVP untuk acara TensorFlow Everywhere lokal Anda hari ini!
Halaman ini diterjemahkan oleh Cloud Translation API.
Switch to English

Contoh permusuhan menggunakan FGSM

Lihat di TensorFlow.org Jalankan di Google Colab Lihat sumber di GitHub Unduh buku catatan

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

Apa itu contoh permusuhan?

Contoh adversarial adalah input khusus yang dibuat dengan tujuan untuk membingungkan jaringan neural, yang mengakibatkan kesalahan klasifikasi dari 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 serangan metode fast gradient sign, yaitu serangan white box yang bertujuan untuk memastikan kesalahan klasifikasi. Serangan kotak putih adalah saat penyerang memiliki akses penuh ke model yang diserang. Salah satu contoh paling terkenal dari gambar permusuhan yang ditunjukkan di bawah ini diambil dari kertas yang disebutkan di atas.

Contoh Adversarial

Di sini, dimulai dengan gambar panda, penyerang menambahkan gangguan kecil (distorsi) ke gambar aslinya, yang menghasilkan model yang memberi label gambar ini sebagai owa, dengan keyakinan tinggi. Proses penambahan gangguan ini dijelaskan di bawah.

Metode tanda gradien cepat

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

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

dimana

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

Properti menarik di sini, adalah kenyataan bahwa gradien diambil sehubungan dengan gambar masukan. Hal ini dilakukan karena tujuannya untuk menciptakan citra yang memaksimalkan kerugian. Metode untuk melakukannya adalah dengan menemukan seberapa besar kontribusi setiap piksel pada gambar terhadap 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. Karenanya, gradien diambil sehubungan dengan gambar. Selain itu, karena model tidak lagi dilatih (sehingga gradien tidak diambil sehubungan dengan variabel yang dapat dilatih, yaitu parameter model), sehingga parameter model tetap konstan. Satu-satunya tujuan adalah menipu model yang sudah terlatih.

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

# 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 praproses sehingga dapat diumpankan 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

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

png

Buat gambar permusuhan

Menerapkan metode tanda gradien cepat

Langkah pertama adalah membuat gangguan yang akan digunakan untuk mendistorsi citra asli sehingga menghasilkan citra yang bermusuhan. Seperti yang 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]

png

Mari kita coba ini untuk nilai epsilon yang berbeda dan amati gambar yang dihasilkan. Anda akan melihat bahwa saat nilai epsilon ditingkatkan, akan lebih mudah untuk mengelabui jaringan. 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])

png

png

png

png

Langkah selanjutnya

Sekarang setelah Anda mengetahui tentang serangan permusuhan, coba ini pada kumpulan data yang berbeda dan arsitektur yang berbeda. Anda juga dapat membuat dan melatih model Anda sendiri, lalu mencoba membodohi model tersebut dengan menggunakan metode yang sama. Anda juga dapat mencoba dan melihat bagaimana kepercayaan dalam prediksi bervariasi saat Anda mengubah epsilon.

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

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