Transformer les encodeurs automatiques

Je viens de lire l'article de Geoff Hinton sur la transformation des encodeurs automatiques

Hinton, Krizhevsky et Wang: Transformer les auto-encodeurs . Dans Artificial Neural Networks and Machine Learning, 2011.

et je voudrais bien jouer avec quelque chose comme ça. Mais après l'avoir lu, je n'ai pas pu obtenir suffisamment de détails du document sur la façon dont je pourrais le mettre en œuvre.

• Quelqu'un sait-il comment le mappage entre les pixels d'entrée et les capsules devrait fonctionner?
• Que doit-il se passer exactement dans les unités de reconnaissance?
• Comment devrait-il être formé? Est-ce juste un accessoire arrière standard entre chaque connexion?

Encore mieux serait un lien vers du code source pour ceci ou quelque chose de similaire.

J'ai mis en place un exemple de code tensorflow pour aider à expliquer (le code complet et fonctionnel est dans cet esprit ). Ce code implémente le réseau de capsules de la première partie de la section 2 de l'article que vous avez lié:

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)

Quelqu'un sait-il comment le mappage entre les pixels d'entrée et les capsules devrait fonctionner?

Cela dépend de la structure du réseau. Pour la première expérience dans cet article (et le code ci-dessus), chaque capsule a un champ récepteur qui inclut l'image d'entrée entière. C'est l'arrangement le plus simple. Dans ce cas, c'est une couche entièrement connectée entre l'image d'entrée et la première couche cachée dans chaque capsule.

Alternativement, les champs récepteurs de la capsule peuvent être arrangés plus comme des noyaux CNN avec des foulées, comme dans les expériences ultérieures de cet article.

Que doit-il se passer exactement dans les unités de reconnaissance?

Les unités de reconnaissance sont une représentation interne de chaque capsule. Chaque capsule utilise cette représentation interne pour calculer p, la probabilité que la caractéristique de la capsule soit présente et xyles valeurs de traduction déduites. La figure 2 dans ce document est une vérification pour vous assurer que le réseau apprend à utiliser xycorrectement (c'est le cas).

Comment devrait-il être formé? Est-ce juste un accessoire arrière standard entre chaque connexion?

Plus précisément, vous devez le former en tant qu'encodeur automatique, en utilisant une perte qui renforce la similitude entre la sortie générée et l'original. L'erreur quadratique moyenne fonctionne bien ici. En dehors de cela, oui, vous devrez propager la descente du gradient avec backprop.

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