Transformando AutoEncoders

Acabei de ler o artigo de Geoff Hinton sobre a transformação de autoencodificadores

Hinton, Krizhevsky e Wang: transformando codificadores automáticos . Em Redes Neurais Artificiais e Machine Learning, 2011.

e gostaria muito de brincar com algo assim. Mas, depois de ler, não consegui obter detalhes suficientes do artigo sobre como realmente poderia implementá-lo.

• Alguém sabe como o mapeamento entre pixels de entrada para cápsulas deve funcionar?
• O que exatamente deveria estar acontecendo nas unidades de reconhecimento?
• Como deve ser treinado? É apenas suporte traseiro padrão entre todas as conexões?

Melhor ainda seria um link para algum código-fonte para isso ou algo semelhante.

Reunimos alguns exemplos de código tensorflow para ajudar a explicar (o código completo e de trabalho está nessa essência ). Este código implementa a rede de cápsulas da primeira parte da seção 2 no documento que você vinculou:

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)

Alguém sabe como o mapeamento entre pixels de entrada para cápsulas deve funcionar?

Isso depende da estrutura da rede. Para a primeira experiência nesse artigo (e o código acima), cada cápsula possui um campo receptivo que inclui toda a imagem de entrada. Esse é o arranjo mais simples. Nesse caso, é uma camada totalmente conectada entre a imagem de entrada e a primeira camada oculta em cada cápsula.

Alternativamente, os campos receptivos da cápsula podem ser organizados mais como núcleos da CNN com passos, como nas experiências posteriores desse artigo.

O que exatamente deveria estar acontecendo nas unidades de reconhecimento?

As unidades de reconhecimento são uma representação interna que cada cápsula possui. Cada cápsula usa essa representação interna para calcular p, a probabilidade de que o recurso da cápsula esteja presente e xyos valores de conversão inferidos. A Figura 2 desse documento é uma verificação para garantir que a rede esteja aprendendo a usar xycorretamente (é).

Como deve ser treinado? É apenas suporte traseiro padrão entre todas as conexões?

Especificamente, você deve treiná-lo como um auto-codificador, usando uma perda que imponha semelhança entre a saída gerada e a original. O erro quadrático médio funciona bem aqui. Além disso, sim, você precisará propagar a descida do gradiente com o backprop.

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