top of page

Come hackerare una rete neurale usando il metodo Fast Gradient Sign ? Con esempio pratico in python


Come hackerare una rete neurale
Come hackerare una rete neurale

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.



Come hackerare una rete neurale usando il metodo Fast Gradient Sign ? Con esempio pratico in python
Come hackerare una rete neurale usando il metodo Fast Gradient Sign ? Con esempio pratico in python

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_predictions

Funzioni 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

Risultato Previsione modello NON HACKERATA
Risultato Previsione modello NON HACKERATA

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_grad

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

Immagine Contradditoria per hackerare la rete
Immagine Contradditoria per hackerare la rete



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.



Hackerare una Rete Neurale .ipynb - Colaboratory
.pdf
Download PDF • 2.35MB

Hackerare_una_Rete_Neurale_
.ipynb
Download IPYNB • 2.47MB


1 commentaire

Noté 0 étoile sur 5.
Pas encore de note

Ajouter une note
Martina Giasi
Martina Giasi
06 août 2021

Continuo a rimanere fermamente convinta che almeno in Italia non esista un sito internet che possa competere con questo, sia sotto il punto di vista di assistenza, anche solo per domande sciocche ti rispondono in giornata, che per la qualità degli articoli che portano.

Questo articolo mi ha davvero impressionato, complimenti, utilissimo anche il file per provarlo e il PDF per dargli uno sguardo anche off line. Che dire Complimenti !!

J'aime
PCR (5).gif
PCR (4).gif
PCR.gif
PCR.gif
PCR.gif