[PYTHON] J'ai essayé de visualiser AutoEncoder avec TensorFlow

TensorFlow?

J'ai commencé à toucher à la bibliothèque d'apprentissage automatique de Google TensorFlow. Comme son nom l'indique, lorsque vous assemblez un flux de données tensoriel (tableau multidimensionnel), il fournit un mécanisme qui se différencie automatiquement du graphe de calcul, il est donc très compatible avec le deep learning (deep learning). De plus, TensorFlow est livré avec un outil de visualisation de journaux appelé TensorBoard, ce qui est excellent. Vous pouvez avoir un sentiment d'accomplissement avec un peu de code, c'est donc parfait pour commencer. Ainsi, j'ai également implémenté et visualisé le Denoising AutoEncoder que j'ai étudié dans "Deep Learning Study Group AutoEncoder". Cette fois, nous intégrons également l'apprentissage par mini-lots.

TensorBoard!

Le flux de données visualisé avec TensorBoard ressemble à ceci.

Le bruit est appliqué à la couche d'entrée, codé dans la couche cachée, décodé dans la couche de sortie, et la perte est calculée en comparant l'entrée et la sortie. La série de flux est dessinée telle quelle. La figure ci-dessus est regroupée pour une meilleure compréhension. Par exemple, vous pouvez cliquer sur "caché" dans le calque caché pour voir un flux plus détaillé.

Il est intéressant de noter que la procédure de calcul de base du réseau neuronal, qui consiste à pondérer, à ajouter un biais et à alimenter la fonction d'activation, est dessinée sous forme de graphique. Les nœuds étiquetés Variable sont soumis à une optimisation de différenciation automatique.

TensorBoard peut également être visualisé de nombreuses autres manières. Cette fois, j'ai essayé de former l'image numérique manuscrite de MNIST à AutoEncoder, afin que je puisse vérifier si l'image de sortie peut vraiment ramener l'image d'entrée bruyante.

Vous pouvez également voir que la perte diminue à mesure que l'apprentissage progresse.

Si vous pouvez créer un modèle qui a l'air bien grâce à des essais et erreurs occasionnels de cette manière, ce serait très amusant si vous pouviez utiliser Google Cloud Machine Learning pour rebondir des données à grande échelle. Je suis d'accord. Vos rêves se répandront.

la mise en oeuvre

autoencoder.py

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

flags = tf.app.flags
FLAGS = flags.FLAGS
flags.DEFINE_integer('batch_size', 256, '')
flags.DEFINE_integer('epoch_num', 10, '')
flags.DEFINE_integer('hidden_num', 64, '')
flags.DEFINE_float('learning_rate', 0.01, '')
flags.DEFINE_float('noise_rate', 0.3, '')
flags.DEFINE_float('noise_strength', 0.2, '')
flags.DEFINE_string('summary_dir', 'summary', '')


def main():
    mnist_data = input_data.read_data_sets('MNIST_data', one_hot=True)

    with tf.name_scope('input'):
        input_layer = tf.placeholder(tf.float32, shape=[None, 784])
        input_summary = tf.image_summary('tag', tf.reshape(input_layer, [-1, 28, 28, 1]), 10)

    with tf.name_scope('noisy_input'):
        noise_layer = tf.maximum(tf.random_uniform(shape=tf.shape(input_layer),
                                                   minval=-FLAGS.noise_strength * (2 / FLAGS.noise_rate - 1),
                                                   maxval=FLAGS.noise_strength),
                                 -FLAGS.noise_strength)
        noisy_input_layer = tf.minimum(tf.maximum(input_layer + noise_layer, 0.0), 1.0)
        noisy_input_summary = tf.image_summary('tag', tf.reshape(noisy_input_layer, [-1, 28, 28, 1]), 10)

    with tf.name_scope('hidden'):
        w1 = tf.Variable(tf.random_uniform([784, FLAGS.hidden_num], minval=-1, maxval=1))
        b1 = tf.Variable(tf.zeros([FLAGS.hidden_num]))
        hidden_layer = tf.sigmoid(tf.matmul(noisy_input_layer, w1) + b1)

    with tf.name_scope('output'):
        w2 = tf.transpose(w1)
        b2 = tf.Variable(tf.zeros([784]))
        output_layer = tf.sigmoid(tf.matmul(hidden_layer, w2) + b2)
        output_summary = tf.image_summary('tag', tf.reshape(output_layer, [-1, 28, 28, 1]), 10)

    with tf.name_scope('loss'):
        loss = tf.nn.l2_loss(input_layer - output_layer)
        loss_summary = tf.scalar_summary('loss', loss)

    train_step = tf.train.GradientDescentOptimizer(FLAGS.learning_rate).minimize(loss)

    sess = tf.InteractiveSession()
    sess.run(tf.initialize_all_variables())

    if tf.gfile.Exists(FLAGS.summary_dir):
        tf.gfile.DeleteRecursively(FLAGS.summary_dir)

    input_writer = tf.train.SummaryWriter(FLAGS.summary_dir + '/input', sess.graph)
    noisy_input_writer = tf.train.SummaryWriter(FLAGS.summary_dir + '/noisy_input')
    output_writer = tf.train.SummaryWriter(FLAGS.summary_dir + '/output')

    step = 0
    while mnist_data.train.epochs_completed < FLAGS.epoch_num:
        step += 1
        images, _ = mnist_data.train.next_batch(FLAGS.batch_size)
        loss_result, _ = sess.run([loss_summary, train_step], feed_dict={input_layer: images})
        input_writer.add_summary(loss_result, step)

    input_result, noisy_input_result, output_result =\
        sess.run([input_summary, noisy_input_summary, output_summary], feed_dict={input_layer: images})
    input_writer.add_summary(input_result)
    noisy_input_writer.add_summary(noisy_input_result)
    output_writer.add_summary(output_result)


if __name__ == '__main__':
    main()

$ python autoencoder.py 
Extracting MNIST_data/train-images-idx3-ubyte.gz
Extracting MNIST_data/train-labels-idx1-ubyte.gz
Extracting MNIST_data/t10k-images-idx3-ubyte.gz
Extracting MNIST_data/t10k-labels-idx1-ubyte.gz

$ tensorboard --logdir=summary/

Environnement d'exécution

$ python --version
Python 3.5.1

requirements.txt

numpy==1.11.1             # via tensorflow
protobuf==3.0.0b2         # via tensorflow
six==1.10.0               # via protobuf, tensorflow
tensorflow==0.9.0
wheel==0.29.0             # via tensorflow