Molti modelli di apprendimento automatico , comprese le reti neurali, classificano costantemente in modo errato gli esempi contraddittori. Gli esempi contraddittori non sono altro che input specializzati creati per confondere le reti neurali, con conseguente errata classificazione del risultato. Questi famigerati input sono quasi gli stessi dell'immagine originale per gli occhi umani, ma fanno sì che una rete neurale non riesca a identificare il contenuto dell'immagine. Tali input si sono formati applicando una perturbazione piccola ma intenzionalmente peggiore all'esempio dal set di dati in modo tale che l'input perturbato risulti nel modello che fornisce una risposta errata anch'essa con elevata confidenza.
I classificatori basati su moderne tecniche di apprendimento automatico che hanno ottenuto prestazioni più elevate sui dati di test non stanno imparando il vero concetto sottostante che determina la correttezza delle etichette di output. Invece, questi algoritmi sono impressionanti sui dati presenti in natura, ma essere esposti a dati falsi o temperati dà un'alta probabilità su altre etichette. Ciò è particolarmente deludente perché un approccio popolare nella visione artificiale consiste nell'utilizzare le caratteristiche della rete convoluzionale come spazio in cui la distanza euclidea si avvicina alla distanza percettiva. Tuttavia, questa somiglianza è imperfetta se le immagini con distanze percettive incommensurabilmente piccole corrispondono a diverse classi di rappresentazione della rete.
Esistono diversi tipi di attacchi, ma l'attenzione si concentra sull'attacco Fast Gradient Sign Method, che è l'attacco whitebox. Gli attacchi Whitebox sono quelli in cui gli hacker o gli aggressori hanno accesso completo al modello attaccato.
Fonte: originale
L'esempio sopra è l'esempio più comune utilizzato per spiegare il metodo; qui, inizialmente, il modello prevede l'immagine come un panda con discreta sicurezza, ora gli aggressori hanno introdotto un'immagine perturbata rispetto a quella originale, i cui risultati del modello lo classificano erroneamente come un gibbone che ha una confidenza troppo alta.
Il metodo utilizzato per introdurre il disturbo è FGSM e discuteremo di questo metodo.
Come funziona il metodo Fast Gradient Sign?
Il FGSM fa pieno uso dei gradienti di una rete neurale per costruire un'immagine contraddittoria; calcola i gradienti della funzione di perdita , ad esempio MSE o Cross-entropia, all'immagine di input e quindi usa il segno di quel gradiente per creare una nuova immagine contraddittoria.
I gradienti vengono presi rispetto alle immagini di input perché l'obiettivo è creare l'immagine che massimizza la perdita. Questo viene fatto trovando quanto ogni pixel contribuisce al valore di perdita e i metodi aggiungono perturbazioni di conseguenza. Ciò non influirà su alcuna modifica del parametro del modello poiché è già stato addestrato; abbiamo preso solo gli stati del gradiente.
In breve, il metodo funziona nei seguenti passaggi:
Prende un'immagine
Prevede l'immagine utilizzando la rete CNN
Calcola la perdita sulla previsione rispetto all'etichetta vera
Calcola i gradienti della perdita rispetto all'immagine di input
Calcola il segno del gradiente
L'uso del segno genera una nuova immagine
Implementiamo questo metodo. Per spiegare questo metodo, abbiamo utilizzato il codice ufficiale di questo metodo di Tensorflow.
Implementazione di FGSM in Python
Importa tutte le dipendenze:
import tensorflow as tf
import matplotlib.pyplot as plt
import matplotlib as mpl
mpl.rcParams['figure.figsize'] = (7,7)Carica il modello preaddestrato: Qui stiamo usando MobileNetV2 sul set di dati imagenet;
pre_trained_model = tf.keras.applications.MobileNetV2( include_top = True, weights = 'imagenet')
pre_trained_model.trainable = False
decode_prediction = tf.keras.applications.mobilenet_v2.decode_predictionsFunzioni di supporto: Di seguito vengono utilizzate due funzioni di supporto per elaborare l'immagine di input in modo che possa essere gestita dal nostro modello e un'altra per estrarre le etichette previste;
def process(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
def imagenet_label(probs):
return decode_prediction(probs, top=1)[0][0]Carica l'immagine: Qui caricheremo l'immagine dal web e verificheremo la previsione; puoi provare l'immagine anche da una macchina locale;
image_path = tf.keras.utils.get_file('Labrador_on_Quantock_%282175262184%29.jpg','https://upload.wikimedia.org/wikipedia/commons/thumb/3/34/Labrador_on_Quantock_%282175262184%29.jpg/1200px-Labrador_on_Quantock_%282175262184%29.jpg')
image_raw = tf.io.read_file(image_path)
image = tf.image.decode_image(image_raw)
image_processed = process(image)
img_probs = pre_trained_model.predict(image_processed) plt.imshow(image_processed[0] * 0.5 + 0.5)
_, image_class, class_confidence = imagenet_label(img_probs)
plt.title('{} : {:.2f}% Confidence'.format(image_class, class_confidence*100))
plt.axis('off')
plt.show()OUTPUT
Crea un'immagine contraddittoria:
Come spiegato sopra, qui, estrai il gradiente dell'immagine prevista per creare una perturbazione che verrà utilizzata per distorcere l'immagine originale.
loss = tf.keras.losses.CategoricalCrossentropy()
def adv_pattern(input_image, input_label):
with tf.GradientTape() as tape:
tape.watch(input_image)
prediction = pre_trained_model(input_image)
loss_ = loss(input_label, prediction)
gradient = tape.gradient(loss_, input_image)
signed_grad = tf.sign(gradient)
return signed_gradVediamo l'immagine contraddittoria generata;
labrador_retriever_index = 208
label = tf.one_hot(labrador_retriever_index,img_probs.shape[-1])
label = tf.reshape(label, (1, img_probs.shape[-1]))
perturbations = adv_pattern(image_processed, label)
plt.imshow(perturbations[0] * 0.5 + 0.5)
Confondere la rete:
L'utilizzo di più valori di epsilon (un valore per impostare il livello di perturbazione) aiuterà ad osservare l'effetto; in seguito, vedrai mentre aumentiamo i valori, la rete tende a classificare erroneamente rapidamente.
def display_images(image, description):
_, label, confidence = imagenet_label(pre_trained_model.predict(image))
plt.figure()
plt.imshow(image[0]*0.5+0.5)
plt.title('{} \n {} : {:.2f}% Confidence'.format(description,
label, confidence*100))
plt.axis('off')
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_processed + eps*perturbations
adv_x = tf.clip_by_value(adv_x, -1, 1)
display_images(adv_x, descriptions[i])Di seguito sono riportati i risultati per diversi valori di epsilon:
Conclusione
La difesa più comune consiste nell'addestrare la propria rete ad immagini contraddittorie di ciascuna classe generata utilizzando il modello di destinazione. Ciò migliora la generalizzazione complessiva del modello, ma non fornisce una robustezza significativa al modello. In questo caso, possiamo utilizzare diverse tecniche difensive come il denoiser guidato o le distillazioni difensive per ottenere una vera robustezza.
.png)
