Engañar a el algoritmo de reconocimiento de imagen

import tensorflow as tf
import keras
import matplotlib.pyplot as plt
import numpy as np

from keras.applications.inception_v3 import InceptionV3, decode_predictions
from keras import backend as K

iv3 = InceptionV3() #tocho libreria

print(iv3.summary()) #resumen de la topologia inseptionv3

from keras.preprocessing import image

#cargar imagen en array y ajustar al objetivo de tamaño deseado
x = image.img_to_array(image.load_img("./Direccion_de_la_imagen/imagen.jpg", target_size=(299,299)))
print(x,shape)
#reescalar el rango de intensidades de la imagen de 255 a 1 y de 0 a -1
x /= 255 #dividir x por 255 para obtener rango de 0 y 1
x -= 0.5 #restar 0.5 para reducir el rango de 0 a -0,5 y de 1 a 0,5
x *= 2 #multiplicar por 2 para obtener el rango de -1 a 1

x = x.reshape([1,x.shape[0], x.shape[1], x.shape[2]])#añadir nueva dimension
#para visualizar: print(x.shape)

y = iv3.predict(x) #resultado de x

#para saber el tamaño del vector: print(y.shape)
#para saber que imagen predice el modelo: decode_predictions(y)


#____Ataques adversarios________
inp_layer = iv3.layer[0].input
out_layer = iv3.layer[-1].output

target_class = 951 #la clase objetivo es un limón

out_layer[0, target_class] #maximizar la clase de salida

grad = K.gradients(loss, inp_layer)[0]

#valores de entrada para la optimizacion de inclinacion: [entrada de capa, fase de aprendizaje],[inclinacion y valor de error]
optimize_gradient = K.function([inp_layer, K.learning_phase()],[grad, loss])

adv = np.copy(x) #copia de la imagen (variable X)

pert = 0.01 #perturbacion de la imagen

max_pert = x + 0.01 #limite superior
min_pert = x - 0.01 #limite inferior

cost = 0.0

while cost < 0.95:
gr = optimize_gradient([adv, 0]) #guarda el gradiante en gr optimizado
adv += gr #manipular pixeles en la copia original
adv = np.clip(adv, min_pert, max_pert) #limita los valores de las variables int
adv = np.clip(adv, -1, 1) #limita los valores de las variables float

print("coste objetivo(limon): ", cost) #solo con el GPU de tensorflow instalado

hacked = np.copy(adv)

#revertir el valor de adv [/2][+0.5][*255]
adv /= 2
adv += 0.5
adv *= 255

#visualiza la salida con la conversion de float a int
plt.imshow(adv[0].astype(np.uint8))
plt.show()

from PIL import image
im = image.formarray(adv[0].astype(np.uin8)) #convertir matriz integer a imagen
im.save("./Direccion_de_la_imagen/hacked.png") #guardar la nueva imagen