classification - reconocimiento - Salome de imagen de computación a través del clasificador de red neuronal

redes neuronales programacion

Question

Supongamos que tenemos una red neuronal convolucional capacitada para clasificar imágenes (wlog en escala de grises) en Tensor-Flow .

Dada la red entrenada y una imagen de prueba, se puede rastrear qué píxeles son sobresalientes, o "equivalentemente" qué píxeles son los más responsables de la clasificación de salida de la imagen. Una buena explicación y detalles de implementación en Theano se dan en este artículo .

Supongamos que para la primera capa de convoluciones que está directamente relacionada con la imagen de entrada, tenemos el gradiente para los parámetros de cada kernel-wrt convolucional. la función de clasificación.

¿Cómo se puede propagar el degradado a la capa de entrada, para calcular una derivada parcial en cada píxel de la imagen?

1. Propagándose y acumulando el gradiente, nos daría los píxeles salientes (son aquellos con una gran derivada en magnitud).

2. Para encontrar el degradado wrt. los núcleos de la primera capa, hasta ahora lo hice:

   1. Se reemplazó el operador de pérdida usual con el operador de la capa de salida.
   2. Usó la función "compute_gradient",

En general, parece que:

• opt = tf.train.GradientDescentOptimizer (1)
• grads = opt.compute_gradients (salida)
• grad_var = [(grad 1 ) para graduado en graduados]
• g1 = sess.run ([grad_var [0]])

Donde, el "resultado" es el máximo de la capa de salida del NN. Y g1, es un tensor (k, k, 1, M), ya que utilicé núcleos convolucionales M: kxk en la primera capa.

Ahora, necesito encontrar la forma correcta de propagar g1 en cada píxel de entrada, para calcular su derivada wrt. La salida.

Answer 1

Para calcular los gradientes, no necesita usar un optimizador, y puede usar directamente tf.gradients .
Con esta función, puede calcular directamente el gradiente de output con respecto a la input imagen, mientras que el método optimizer compute_gradients solo puede calcular gradientes con respecto a las variables .

La otra ventaja de tf.gradients es que puedes especificar los gradientes de la salida que deseas relanzar.

Así que aquí es cómo obtener los gradientes de una imagen de entrada con respecto a la output[1, 1] :

• tenemos que establecer los gradientes de salida a 0 todas partes excepto en el indice [1, 1]

input = tf.ones([1, 4, 4, 1])
filter = tf.ones([3, 3, 1, 1])
output = tf.nn.conv2d(input, filter, [1, 1, 1, 1], ''SAME'')

grad_output = np.zeros((1, 4, 4, 1), dtype=np.float32)
grad_output[0, 1, 1, 0] = 1.

grads = tf.gradients(output, input, grad_output)

sess = tf.Session()
print sess.run(grads[0]).reshape((4, 4))
# prints [[ 1.  1.  1.  0.]
#         [ 1.  1.  1.  0.]
#         [ 1.  1.  1.  0.]
#         [ 0.  0.  0.  0.]]