Dalam era digital yang semakin berkembang, Artifical Intelligence telah mengambil peran utama dalam berbagai aspek kehidupan manusia. Model deep learning, terutama neural network telah mengungkapkan kemampuan luar biasa dalam tugas-tugas seperti klasifikasi gambar, analisis teks, bahkan autonomous vehicle. Namun, seperti halnya teknologi lainnya, model deep learning juga rentan terhadap berbagai tantangan, termasuk ancaman yang datang dari apa yang dikenal sebagai Adversarial Attack.

Dikutip dari viso.ai, adversarial attack adalah metode untuk menipu model machine learning dengan cara mengubah input yang tidak dapat dirasakan oleh manusia, tetapi dapat menyebabkan model melakukan kesalahan klasifikasi. Metode ini sudah diterapkan ke dalam beberapa kasus seperti klasifikasi gambar dan spam filter.

Kenapa Adversarial Attack Penting?

Serangan adversarial memiliki signifikansi yang besar dalam konteks pengembangan dan keamanan model deep learning serta sistem kecerdasan buatan. Apalagi jika ingin digunakan untuk kebutuhan industri seperti autonomous-vehicle, kebutuhan medis, chatbot, dll.

File:Https://miro.medium.com/v2/resize:fit:480/1*5DQpMn6rJSZpvatnZgm77Q.png

source: owasp.org

Kita ambil contoh gambar di atas, Misalkan adversarial attack yang dilancarkan ke autonomous-vehicle. alih-alih autonomous-vehicle mendeteksi rambu-rambu “stop” dan berhenti, yang terjadi malah autonomous-vehicle mendeteksinya sebagai tanda untuk membatasi kecepatan maximal 35Mh. Bayangkan kalau ini beneran terjadi, lalu lintas pasti akan tidak karuan. Contoh lain adalah jika adversarial attack dilancarkan pada klasifikasi tumor pada dunia medis, yang seharusnya dideteksi tumor; tetapi outputnya malah tidak mendeteksi adanya tumor. Kalau sudah begini tentunya akan game over dan pasien mungking akan banyak yang tewas. Nah berikut adalah beberapa poin kenapa adversarial attack perlu diperhatikan.

Untuk menguji ketahanan model: Adversarial attack memungkinkan pengujian sejauh mana model tahan terhadap manipulasi data yang dirancang khusus untuk memberikan output yang salah. Ini membantu mengungkapkan kerentanan dan kelemahan yang mungkin tidak terlihat selama evaluasi standar.
Peningkatan Pengembangan Algoritma: Adversarial attack memacu pengembangan algoritma baru yang lebih tahan terhadap serangan. Ini memicu inovasi dalam bidang keamanan dan pertahanan.
Meningkatkan Keamanan siber: Adversarial attack dapat membantu praktisi keamanan siber untuk selalu menjaga resource datanya dari pihak yang tidak bertanggung jawab. Salah satu contohnya adalah menjaga sistem agar orang asing tidak memiliki akses langsung kepada data yang akan dijadikan data latih sehingga model akan menghasilkan output yang baik

Istilah-Istilah pada Adversarial Attack

Istilah dalam adversarial attack mirip-mirip dengan istilah di dunia pentesting/ethical hacking. Btw saya pernah belajar tentang ethical hacking tapi gak jago-jago amat😁, karena saya fokus di bidang machine learning dan data science. Ok, Kita akan membagi istilah-istilah tersebut ke beberapa kategori:

Attack Scenario

Evasion Attack: Jenis serangan yang paling banyak ditemui, penyerang memanipulasi input sekecil mungkin hingga menyebabkan model salah prediksi
Poisoning Attack: jenis serangan di mana penyerang mencoba memanipulasi data latih yang digunakan untuk melatih model deep learning. Tujuannya adalah untuk menyuntikkan sampel data yang telah dimodifikasi ke dalam set pelatihan, dengan harapan bahwa model yang dilatih akan lebih rentan dan memberikan prediksi yang salah atau tidak diinginkan ketika menghadapi data dunia nyata.
Exploratory Attack: penyerang mencoba untuk mengeksplorasi area sensitivitas model deep learning dengan mengamati respons model terhadap berbagai data input yang dimodifikasi. Tujuannya adalah untuk mengidentifikasi titik-titik lemah di mana model rentan terhadap manipulasi data. Exploratory attack dapat membantu penyerang memahami lebih baik model yang diserang dan menemukan cara-cara baru untuk mengeksploitasi kelemahan dalam model. Dengan memahami bagaimana model merespons berbagai jenis modifikasi input, penyerang dapat mengembangkan serangan yang lebih canggih dan lebih sulit dideteksi.

Training Phase Attack

Serangan yang dilakukan selama pelatihan untuk merusak model secara langsung dengan mengubah dataset yang digunakan untuk pelatihan ataupun memanipulasi model.

Data Injection: Penyerang tidak memiliki akses ke data pelatihan serta ke algoritma model, tetapi memiliki kemampuan untuk menambah data baru ke set data latih. Tujuannya adalah untuk mengganggu proses pelatihan model deep learning dan menghasilkan model yang memiliki performa yang buruk atau rentan terhadap serangan.
Data Modification: Hampir sama seperti data injection, yang membedakannya adalah penyerang memiliki akses langsung sehingga dapat memodifikasi data latih.
Logic Corruption: Serangan yang mungkin paling sulit untuk dilakukan, penyerang memiliki akses langsung ke model sehingga dapat mengubah parameter atau struktur dari model yang diserang.

Testing Phase Attack

Testing phase adversarial attack mengacu pada jenis serangan adversarial yang terjadi selama tahap pengujian atau evaluasi suatu model deep learning. Pada tahap ini, model dievaluasi pada data pengujian yang belum pernah dilihat sebelumnya untuk mengukur performanya. Serangan adversarial pada tahap pengujian adalah upaya untuk mengungkapkan kerentanan atau kelemahan model yang mungkin tidak terdeteksi selama pelatihan.

White-box Attack: Dalam serangan white-box, penyerang memiliki pengetahuan lengkap tentang arsitektur, parameter, dan cara kerja model yang diserang.
Black-box Attack: Dalam serangan black-box, penyerang memiliki keterbatasan pengetahuan tentang model yang diserang. Mungkin penyerang hanya tahu output dari model untuk beberapa input yang diberikan atau mungkin hanya mengetahui arsitektur umum model tanpa rincian internalnya.

Nah itu istilah-istilah pada adversarial attack. Selanjutnya kita akan praktekan dengan python dan tensorflow, Let’s Code!

Contoh Adversarial Attack (python & tensorflow)

kita akan praktekan dua contoh metode adversarial attack yaitu FGSM dan one-pixel attack. Sebenarnya masih banyak metode lain seperti deepFool, carlini & wagner attack, projected gradient descent, dll.

FGSM (Fast Gradient Sign Method)

File:Https://miro.medium.com/v2/resize:fit:700/1*imEb5NKCLxx6IHu2xa dLQ.jpeg

FGSM adalah salah satu metode adversarial attack paling sederhana. Ide dasarnya adalah dengan cara menambah gambar berupa noise (perturbation image) ke dalam gambar input. Tahap-tahapnya adalah secara berikut:

Masukan gambar input
Buat prediksi dengan CNN
Hitung loss prediksi dengan label aslinya, bisa dengan binary cross entropy untuk binary classification atau categorical crossentropy untu multilclass classification
Menghitung gradient loss terhadap gambar input
Mengoperasikan element-wise operation untuk menghasilkan perturbation image

Terdengar sangat complicated, oleh karena itu kita akan langsung praktekan. Sebelumnya saya sudah melatih model CNN untuk klasifikasi buah dengan akurasi yaitu 92%. Label ada enam yaitu: apple, banana, bitter gourd, capsicum, orange, dan tomato. Pertama-tama kita import library yang dibutuhkan

import os  
import cv2 as cv  
import numpy as np  
import tensorflow as tf  
import matplotlib.pyplot as plt  
from tensorflow.keras.preprocessing import image  
from tensorflow.keras.utils import to_categorical  
  
import warnings  
warnings.filterwarnings("ignore")

Selanjutnya load model yang sudah dilatih dan disave dalam format .h5

model = tf.keras.models.load_model('fruits.h5')

Sebelumnya kita akan membuat function pembantu untuk menampilkan hasil prediksi disertai dengan confidence ratenya dan function untuk meng-convert true label ke dalam bentuk one hot encoding.

#Function untuk menampilkan hasil prediksi dan confidence rate  
def get_confidence(y_pred):   
    labels = ['Apple','Banana','Bitter Gourd','Capsicum','Orange','Tomato']  
    logits_index = np.argmax(y_pred)  
    predicted_label = labels[logits_index]  
    confidence = y_pred[0][logits_index] * 100  
    return f"Predicted: {predicted_label}\nConfidence: {format(confidence, '.2f')}%"  
  
#Function untuk menconvrt true label ke dalam bentuk one hot encoding  
def get_true_label(true_label:str):  
    labels = ['Apple','Banana','Bitter Gourd','Capsicum','Orange','Tomato']  
    true_label_index = labels.index(true_label)  
    one_hot = [0. for i in range(0,len(labels))]  
    one_hot[true_label_index] = 1.  
      
    return tf.convert_to_tensor([one_hot])    
# contoh:   
# get_true_label('Banana')  
# output: <tf.Tensor: shape=(1, 6), dtype=float32, numpy=array([[0., 1., 0., 0., 0., 0.]], dtype=float32)>

Selanjutnya kita akan coba prediksi terlebih dahulu. Seperti biasa, kita perlu melakukan preprocessing untuk input gambar agar bisa diterima oleh model.

path = "Capsicum.jpg"  
  
# Preprocessing  
img = image.load_img(path, target_size=(280, 280))  
img_array = image.img_to_array(img)  
img_array = img_array.reshape((280, 280, 3))  
img_array = img_array / 255.0  # Normalisasi  
img_array = np.expand_dims(img_array, axis=0)  
  
# Prediksi  
y_pred = model.predict(img_array)  
plt.imshow(img)  
plt.title(get_confidence(y_pred))  
plt.show()

Hasil outputnya adalah sebagai berikut, dengan confidence sempurna

File:Https://miro.medium.com/v2/resize:fit:425/1* YkH8AktYd2igDvsUS0n4w.png

Selanjutnya kita akan membuat function FGSM untuk membentuk sebuah gambar adversarial/perturbations untuk digabung dengan input aslinya untuk menipu model.

# Categorical crossentropy karena kasus kita adalah multiclass classification  
loss_object = tf.keras.losses.CategoricalCrossentropy()   
  
def create_adversarial_pattern(input_image, input_label):  
    with tf.GradientTape() as tape:  
        tape.watch(input_image)  
        prediction = model(input_image) #prediksi  
        loss = loss_object(input_label, prediction) #hitung loss  
  
    gradient = tape.gradient(loss, input_image) #hitung gradient loss  
  
    # sign(x) = -1 if x < 0; 0 if x == 0; 1 if x > 0.  
    signed_grad = tf.sign(gradient)  
    return signed_grad  
  
# Membuat perturbations/noise  
label = get_true_label('Capsicum')  
perturbations = create_adversarial_pattern(tf.convert_to_tensor(img_array), label)  
  
# Menampilkan gambart  
plt.imshow(perturbations[0] * 0.5 + 0.5) # To change [-1, 1] to [0,1]  
plt.title("Noise")  
plt.show()

Outputnya adalah sebagai berikut:

File:Https://miro.medium.com/v2/resize:fit:425/1*uJdaN q2Hf8PrgPWUd2vGg.png

Selanjutnya kita perlu mengabungkan noise tersebut dengan input asli gambar. Kita memerlukan sebuah parameter baru yaitu epsilon agar input asli tidak terlihat sudah dicampur oleh noise tetapi cukup untuk menipu model.

epsilon = 0.01  
adv_x = img_array + epsilon * perturbations  
adv_x = tf.clip_by_value(adv_x, -1, 1)  
y_pred_adv = model.predict(adv_x)  
  
  
plt.imshow(adv_x[0])  
plt.title(get_confidence(y_pred_adv))  
plt.show()

File:Https://miro.medium.com/v2/resize:fit:425/1*SH9F-bd7O9JrGXpjG774ag.png

Dan serangan pun berhasil😁. Model salah memprediksi dengan confidence rate yang tinggi! True label adalah capsicum, tetapi yang diprediksi model adalah apple.

Nah, apakah selalu berhasil? pastinya tidak, coba kita ambil satu contoh lagi untuk memprediksi apple.

File:Https://miro.medium.com/v2/resize:fit:425/1*kRLdMw5rFpreP9m-M 5MPQ.png

Model kita berhasil memprediksi benar dengan 100% confidence. Selanjutnya coba kita prediksi dengan campuran teknik FGSM. Hasilnya akan seperti ini:

File:Https://miro.medium.com/v2/resize:fit:425/1*fFDFdj 9VLiuEaPGfzglvA.png

Dan serangan pun tidak berhasil, ini bisa terjadi karena kita memberi nilai yang kecil untuk epsilon nya. Kita bisa coba untuk menaikan nilai epsilon untuk melihat hasilnya:

epsilon = [0.01, 0.1, 0.2, 0.3, 0.5]  
  
fig = plt.figure(figsize=(15,15))  
  
for idx,eps in enumerate(epsilon):   
    adv_x = img_array + eps * perturbations  
    adv_x = tf.clip_by_value(adv_x, -1, 1)  
    y_pred_adv = model.predict(adv_x, verbose=0)  
      
    fig.add_subplot(1, len(epsilon), idx+1)  
    plt.imshow(adv_x[0])  
    plt.title(get_confidence(y_pred_adv) + f"\n Epsilon: {eps}")  
    plt.axis('off')  
plt.show()

hasilnya sebagai berikut:

File:Https://miro.medium.com/v2/resize:fit:700/1*DRknnAUxgU-LzZ8eOpxSug.png

Nah, serangan berhasil ketika epsilon kita naikan ke 0.2; tetapi akibatnya adalah noise akan semakin terlihat jika epsilonnya kita naikan juga.

Ok, cukup untuk serangan menggunakan metode FGSM. Kita akan coba menggunakan teknik lainnya yaitu one-pixel attack.

One-Pixel Attack

One-Pixel Attack adalah metode adversarial attack di mana penyerang mengubah hanya satu piksel pada gambar input dengan tujuan mengelabui model machine learning sehingga menghasilkan prediksi yang salah. Meskipun hanya merubah satu piksel, perubahan ini dapat mempengaruhi model dan menghasilkan hasil prediksi yang sangat berbeda.

Pertama-tama kita akan membuat function untuk mengubah sebuah pixel pada gambarnya. Function menerima parameter gambar dan koordinat pixel yang ingin diubah serta warnanya dalam RGB.

def one_pixel(image, xs:list, expand_dims=False):  
    x,y,r,g,b = xs  
    if len(image.shape) > 3:   
        image = np.squeeze(image)  
    image[x][y] = (r,g,b)  
      
    if expand_dims:  
        image = np.expand_dims(image, axis=0)  
      
    return image

Kita tes terlebih dahulu dengan sebuah gambar kosong berukuran 30x30.

# Membuat gambar kosong 30x30 (RGB)  
blank_image = np.zeros((30, 30, 3), dtype=np.uint8)   
  
'''  
x = 15  
y = 15   
RGB = (0,0,255) #warna biru  
'''  
coba = one_pixel(blank_image, [15, 15, 0,0,255])  
plt.imshow(coba)  
plt.show()

Hasilnya adalah sebagai berikut:

File:Https://miro.medium.com/v2/resize:fit:416/1*8Y9OC1Jfp3PodetZwNn5pw.png

Nah, kita bisa coba untuk melakukan penyerangan dengan studi kasus kita. Kali ini kita akan coba memakai gambar banana.

import random  
  
# ambil koordinat random  
x_random = random.randint(1, 280)   
y_random = random.randint(1, 280)  
  
# ubah satu pixel dalam gambar  
image_perturbed = one_pixel(img_array, [x_random, y_random, 255,0,255], expand_dims=False)  
  
# prediksi  
image_perturbed_for_prediction = np.expand_dims(image_perturbed, axis=0)  
one_pixel_attack = model.predict(image_perturbed_for_prediction)  
  
# menampilkan hasil  
plt.imshow(image_perturbed)  
plt.title(get_confidence(one_pixel_attack))  
plt.show()

hasilnya adalah sebagai berikut:

File:Https://miro.medium.com/v2/resize:fit:425/1*nFqs gMFL9pUGHmPLy4TPQ.png

Serangan berhasil walaupun kita hanya mengubah satu pixel 😁. True label adalah banana, tetapi model malah memprediksi capsicum dengan confidence rate 100%. Ini disebabkan karena model sangat sensitif walau hanya ada sedikit perubahan.

Penutup

Itulah sedikit tentang adversarial attack dan contohnya. Mengingat perkembangan AI yang pesat; maka tidak hanya bidang cyber security saja yang perlu ditingkatkan, tetapi keamanan AI juga perlu ditingkatkan agar dapat memberikan dampak positif dan tidak merugikan masyarakat. Solusi dari adverasial attack juga dapat ditangani seperti melakukan penelitian yang mendalam untuk menghasilkan model yang kebal, atau memodifikasi set data latih untuk menghasilkan model yang kebal pula.