TensorFlow自编码

自编码

    Build a 2 layers auto-encoder with TensorFlow to compress images to a lower latent space and then reconstruct them.
    利用TensorFlow构建两层自动编码器，将图像压缩到一个较低的潜在空间，然后进行重构。

原理

代码引自github TensorFlow-Example

# https://www.baidu.com/s?wd=%E4%B8%AD%E5%9B%BD
wd后面的就是一种编码

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

# Import MNIST data
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("./", one_hot=True)

# Training Parameters
learning_rate = 0.01
num_steps = 30000
batch_size = 256

display_step = 1000
examples_to_show = 10

# Network Parameters
num_hidden_1 = 256 # 1st layer num features
num_hidden_2 = 128 # 2nd layer num features (the latent dim)
num_input = 784 # MNIST data input (img shape: 28*28)

# tf Graph input (only pictures)
X = tf.placeholder("float", [None, num_input])

weights = {
    'encoder_h1': tf.Variable(tf.random_normal([num_input, num_hidden_1])),
    'encoder_h2': tf.Variable(tf.random_normal([num_hidden_1, num_hidden_2])),
    'decoder_h1': tf.Variable(tf.random_normal([num_hidden_2, num_hidden_1])),
    'decoder_h2': tf.Variable(tf.random_normal([num_hidden_1, num_input])), #没有给数据类型 默认float32位
}
biases = {
    'encoder_b1': tf.Variable(tf.random_normal([num_hidden_1])),
    'encoder_b2': tf.Variable(tf.random_normal([num_hidden_2])),
    'decoder_b1': tf.Variable(tf.random_normal([num_hidden_1])),
    'decoder_b2': tf.Variable(tf.random_normal([num_input])),
}

建构编码

def encoder(x):#x [None,784]
    # Encoder Hidden layer with sigmoid activation #1
#     [None,256]
    layer_1 = tf.nn.sigmoid(tf.add(tf.matmul(x, weights['encoder_h1']),
                                   biases['encoder_b1']))
    # Encoder Hidden layer with sigmoid activation #2
#     [None,128]
    layer_2 = tf.nn.sigmoid(tf.add(tf.matmul(layer_1, weights['encoder_h2']),
                                   biases['encoder_b2']))
#     layer_2 [None,128]
    return layer_2

建构解码

# 建构解码器：对编码的数据进行解码
def decoder(x):#x == layer_2 [None,128]
    # Decoder Hidden layer with sigmoid activation #1
#     [None,256]
    layer_1 = tf.nn.sigmoid(tf.add(tf.matmul(x, weights['decoder_h1']),
                                   biases['decoder_b1']))
    # Decoder Hidden layer with sigmoid activation #2
#     [None,784]
    layer_2 = tf.nn.sigmoid(tf.add(tf.matmul(layer_1, weights['decoder_h2']),
                                   biases['decoder_b2']))
#     原数据
    return layer_2

构建模型

# Construct model
# 编码
encoder_op = encoder(X)
# 解码，应该和原数据X尽量相近
decoder_op = decoder(encoder_op)

# Prediction
y_pred = decoder_op
# Targets (Labels) are the input data.
y_true = X

# 损失函数
# Define loss and optimizer, minimize the squared error
# 最小二乘法
loss = tf.reduce_mean(tf.pow(y_true - y_pred, 2))
# 梯度下降
optimizer = tf.train.RMSPropOptimizer(learning_rate).minimize(loss)

# Initialize the variables (i.e. assign their default value)
init = tf.global_variables_initializer()

梯度下降 GradientBoost 是固定学习率 学习率是多少固定不变

训练

saver = tf.train.Saver()
with tf.Session() as sess:
    # Run the initializer
    sess.run(init)
    # Training
    for i in range(1, num_steps+1):
        # Prepare Data
        # Get the next batch of MNIST data (only images are needed, not labels)
        batch_x, _ = mnist.train.next_batch(batch_size)
        # Run optimization op (backprop) and cost op (to get loss value)
        _, l = sess.run([optimizer, loss], feed_dict={X: batch_x})
        # Display logs per step
        if i % display_step == 0 or i == 1:
            print('Step %i: Minibatch Loss: %f' % (i, l))
    saver.save(sess,'./model/auto_encoder')

with tf.Session() as sess:
    saver.restore(sess,'./model/auto_encoder')
    # Testing
    # Encode and decode images from test set and visualize their reconstruction.
    n = 4
    canvas_orig = np.empty((28 * n, 28 * n))
    canvas_recon = np.empty((28 * n, 28 * n))
    for i in range(n):
        # MNIST test set
        batch_x, _ = mnist.test.next_batch(n)
        # Encode and decode the digit image
#         算法根据系数，进行编码[4,128]进行解码[4,784]
        g = sess.run(decoder_op, feed_dict={X: batch_x})

        # Display original images
        for j in range(n):
            # Draw the original digits
            canvas_orig[i * 28:(i + 1) * 28, j * 28:(j + 1) * 28] = batch_x[j].reshape([28, 28])
        # Display reconstructed images
        for j in range(n):
            # Draw the reconstructed digits
            canvas_recon[i * 28:(i + 1) * 28, j * 28:(j + 1) * 28] = g[j].reshape([28, 28])

    print("Original Images")
    plt.figure(figsize=(n, n))
    plt.imshow(canvas_orig, origin="upper", cmap="gray")
    plt.show()

    print("Reconstructed Images")
    plt.figure(figsize=(n, n))
    plt.imshow(canvas_recon, origin="upper", cmap="gray")
    plt.show()

这就是编码 也可以说成是加密 base64是编码但不是加密因为base64是公开的 md5是加密但不能解密 它是不可逆的 具有唯一性
 
github.com/aymericdamien/TensorFlow-Examples
1.自编码：矩阵运算
2.CNN：卷积运算
3.RNN：卷积运算
4.DNN：矩阵运算
5.GAN：对抗神经网络