AutoEncoder transformieren

Ich habe gerade Geoff Hintons Artikel über die Transformation von Autoencodern gelesen

Hinton, Krizhevsky und Wang: Auto-Encoder transformieren . In Künstlichen Neuronalen Netzen und Maschinellem Lernen, 2011.

und würde gerne mit so etwas herumspielen. Aber nachdem ich es gelesen hatte, konnte ich nicht genug Details aus dem Papier bekommen, wie ich es tatsächlich implementieren könnte.

• Weiß jemand, wie die Zuordnung zwischen Eingabepixeln zu Kapseln funktionieren soll?
• Was genau soll in den Erkennungseinheiten passieren?
• Wie soll es trainiert werden? Ist es nur eine Standard-Stütze zwischen jeder Verbindung?

Noch besser wäre ein Link zu einem Quellcode für dieses oder ähnliches.

Ich habe einen Beispiel-Tensorflow-Code zusammengestellt, um die Erklärung zu erleichtern (der vollständige Arbeitscode befindet sich in dieser Übersicht ). Dieser Code implementiert das Kapselnetzwerk aus dem ersten Teil von Abschnitt 2 des von Ihnen verlinkten Dokuments:

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)

Weiß jemand, wie die Zuordnung zwischen Eingabepixeln zu Kapseln funktionieren soll?

Dies hängt von der Netzwerkstruktur ab. Für das erste Experiment in diesem Artikel (und den obigen Code) hat jede Kapsel ein Empfangsfeld, das das gesamte Eingabebild enthält. Das ist die einfachste Anordnung. In diesem Fall handelt es sich um eine vollständig verbundene Ebene zwischen dem Eingabebild und der ersten verborgenen Ebene in jeder Kapsel.

Alternativ können die Kapselrezeptionsfelder eher wie CNN-Kerne mit Schritten angeordnet werden, wie in den späteren Experimenten in diesem Artikel.

Was genau soll in den Erkennungseinheiten passieren?

Die Erkennungseinheiten sind eine interne Darstellung, die jede Kapsel hat. Jede Kapsel berechnet anhand dieser internen Darstellung pdie Wahrscheinlichkeit, dass das Merkmal der Kapsel vorhanden ist, und xydie abgeleiteten Übersetzungswerte. In Abbildung 2 dieses Dokuments wird überprüft, ob das Netzwerk die xykorrekte Verwendung lernt (dies ist der Fall).

Wie soll es trainiert werden? Ist es nur eine Standard-Stütze zwischen jeder Verbindung?

Insbesondere sollten Sie es als Autoencoder trainieren und dabei einen Verlust verwenden, der die Ähnlichkeit zwischen der generierten Ausgabe und dem Original erzwingt. Der mittlere quadratische Fehler funktioniert hier gut. Abgesehen davon müssen Sie den Gradientenabstieg mit Backprop propagieren.

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