implémentation variationnelle autoencoder

Question

J'essaye d'implémenter un autoencoder variationnel en utilisant python et tensorflow. J'ai vu diverses implémentations sur internet. J'ai réussi à créer le mien en utilisant les différentes parties que j'ai trouvées et les ai fait fonctionner avec mon cas spécifique. je conclus avec un autoencoder ici: my autoncoder on git

Brièvement I ont un autoencoder qui contient:

1) un codeur avec 2 couches de convolution et une couche d'aplatir,

2) l'espace latent (de la dimension 2),

3) et un décodeur avec les parties inverses du codeur.

Mon problème est lorsque j'essaie d'implémenter la partie variationnelle de l'autoencoder. J'entends par là la procédure mathématique dans l'espace latent. Atleast c'est là que j'identifie le problème.

Pour être plus clair, j'ai les 2 cas suivants:

Cas 1: Sans mettre en œuvre effectivement des mathématiques variationnelles, tout simplement définir les variables dans l'espace latent et les nourrir dans le décodeur sans mathématiques Dans ce cas, la fonction de coût est juste la différence entre l'entrée et la sortie. Vous pouvez voir le code pour ce cas dans ces chiffres sur le git (désolé de ne pas pouvoir envoyer plus de liens): figure1_code_part1.png, figure1_code_part2.png

Case2: Essayer de mettre en œuvre les mathématiques dans les variables latentes espace . Vous pouvez voir le code pour ce cas dans ces chiffres: figure_2_code_part1.png, figure_2_code_part2.png

L'intrigue de l'espace latent que je reçois dans chacun des cas est: figure_1.png figure_2.png

Je pense que quelque chose ne va pas dans la mise en œuvre variationnelle, mais je ne sais pas quoi. Tous ceux qui implémentent l'encodeur automatique variationnel utilisent ces formules mathématiques (au moins celles que j'ai trouvées sur Internet). Probablement, il me manque quelque chose.

Tous les commentaires/suggestions sont les bienvenus. Merci !!!

Answer 1

Voici comment à calculer la mu et sigma avec le KL_term: Je ne suis pas sûr de la partie linear de votre code. Par conséquent, j'ai suggéré ce qui suit:

Veuillez noter qu'ici, avant les couches entièrement connectées du côté du codeur, j'ai une couche de forme conv4: [7, 7, 256].

# These are the weights and biases of the mu and sigma on the encoder side 
w_c_mu = tf.Variable(tf.truncated_normal([7 * 7 * 256, latent_dim], stddev=0.1), name='weight_fc_mu') 
b_c_mu = tf.Variable(tf.constant(0.1, shape=[latent_dim]), name='biases_fc_mu') 
w_c_sig = tf.Variable(tf.truncated_normal([7 * 7 * 256, latent_dim], stddev=0.1), name='weight_fc_sig') 
b_c_sig = tf.Variable(tf.constant(0.1, shape=[latent_dim]), name='biases_fc_sig') 
epsilon = tf.random_normal([1, latent_dim]) 

with tf.variable_scope('mu'): 
    mu = tf.nn.bias_add(tf.matmul(conv4_reshaped, w_c_mu), b_c_mu) 
    tf.summary.histogram('mu', mu) 

with tf.variable_scope('stddev'): 
    stddev = tf.nn.bias_add(tf.matmul(conv4_reshaped, w_c_sig), b_c_sig) 
    tf.summary.histogram('stddev', stddev) 

with tf.variable_scope('z'): 
    # This formula was adopted from the following paper: http://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=7979344 
    latent_var = mu + tf.multiply(tf.sqrt(tf.exp(stddev)), epsilon) 
    tf.summary.histogram('features_sig', stddev) 

... 

with tf.name_scope('loss_KL'): 
    temp2 = 1 + tf.log(tf.square(stddev + 1e-9)) - tf.square(mu) - tf.square(stddev) 
    KL_term = - 0.5 * tf.reduce_sum(temp2, reduction_indices=1) 
    tf.summary.scalar('KL_term', tf.reduce_mean(KL_term)) 

with tf.name_scope('total_loss'): 
    variational_lower_bound = tf.reduce_mean(log_likelihood + KL_term) 
    tf.summary.scalar('loss', variational_lower_bound) 

with tf.name_scope('optimizer'): 
    update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) 
    with tf.control_dependencies(update_ops): 
     optimizer = tf.train.AdamOptimizer(0.00001).minimize(variational_lower_bound) 

Pour le code complet: https://gist.github.com/issa-s-ayoub/5267558c4f5694d479a84d960c265452

souhaits qui aide !!