Transformando AutoEncoders

Acabo de leer el artículo de Geoff Hinton sobre la transformación de autoencoders

Hinton, Krizhevsky y Wang: Transformando codificadores automáticos . En Redes Neuronales Artificiales y Aprendizaje Automático, 2011.

y me gustaría jugar con algo como esto. Pero después de leerlo, no pude obtener suficientes detalles del documento sobre cómo podría implementarlo.

• ¿Alguien sabe cómo debería funcionar la asignación entre los píxeles de entrada a las cápsulas?
• ¿Qué debería estar sucediendo exactamente en las unidades de reconocimiento?
• ¿Cómo debe ser entrenado? ¿Es solo un respaldo estándar entre cada conexión?

Aún mejor sería un enlace a algún código fuente para esto o algo similar.

He reunido algunos ejemplos de código de tensorflow para ayudar a explicar (el código completo y funcional está en esta esencia ). Este código implementa la red de cápsulas de la primera parte de la sección 2 en el documento que ha vinculado:

N_REC_UNITS = 10
N_GEN_UNITS = 20
N_CAPSULES = 30

# input placeholders
img_input_flat = tf.placeholder(tf.float32, shape=(None, 784))
d_xy = tf.placeholder(tf.float32, shape=(None, 2))

# translate the image according to d_xy
img_input = tf.reshape(img_input_flat, (-1, 28, 28, 1))
trans_img = image.translate(img_input, d_xy)
flat_img = tf.layers.flatten(trans_img)

capsule_img_list = []

# build several capsules and store the generated output in a list
for i in range(N_CAPSULES):
    # hidden recognition layer
    h_rec = tf.layers.dense(flat_img, N_REC_UNITS, activation=tf.nn.relu)
    # inferred xy values
    xy = tf.layers.dense(h_rec, 2) + d_xy
    # inferred probability of feature
    p = tf.layers.dense(h_rec, 1, activation=tf.nn.sigmoid)
    # hidden generative layer
    h_gen = tf.layers.dense(xy, N_GEN_UNITS, activation=tf.nn.relu)
    # the flattened generated image
    cap_img = p*tf.layers.dense(h_gen, 784, activation=tf.nn.relu)

    capsule_img_list.append(cap_img)

# combine the generated images
gen_img_stack = tf.stack(capsule_img_list, axis=1)
gen_img = tf.reduce_sum(gen_img_stack, axis=1)

¿Alguien sabe cómo debería funcionar la asignación entre los píxeles de entrada a las cápsulas?

Esto depende de la estructura de la red. Para el primer experimento en ese documento (y el código anterior), cada cápsula tiene un campo receptivo que incluye toda la imagen de entrada. Ese es el arreglo más simple. En ese caso, es una capa completamente conectada entre la imagen de entrada y la primera capa oculta en cada cápsula.

Alternativamente, los campos receptivos de la cápsula pueden organizarse más como núcleos CNN con zancadas, como en los experimentos posteriores en ese documento.

¿Qué debería estar sucediendo exactamente en las unidades de reconocimiento?

Las unidades de reconocimiento son una representación interna que tiene cada cápsula. Cada cápsula utiliza esta representación interna para calcular p, la probabilidad de que la característica de la cápsula esté presente y xylos valores de traducción inferidos. La Figura 2 en ese documento es una verificación para asegurarse de que la red está aprendiendo a usarxy correctamente (lo es).

¿Cómo debe ser entrenado? ¿Es solo un respaldo estándar entre cada conexión?

Específicamente, debe entrenarlo como un autoencoder, utilizando una pérdida que imponga similitud entre la salida generada y el original. El error cuadrático medio funciona bien aquí. Aparte de eso, sí, deberá propagar el descenso del gradiente con backprop.

loss = tf.losses.mean_squared_error(img_input_flat, gen_img)
train_step = tf.train.GradientDescentOptimizer(0.1).minimize(loss)