TensorFlow课程：深入理解自编码器及其实现-优快云博客

本文链接：https://blog.youkuaiyun.com/gitblog_00947/article/details/148375795

TensorFlow课程：深入理解自编码器及其实现

TensorFlow-Course :satellite: Simple and ready-to-use tutorials for TensorFlow 项目地址: https://gitcode.com/gh_mirrors/te/TensorFlow-Course

自编码器(Autoencoder)是深度学习领域中一种非常有趣且实用的神经网络结构。本文将基于TensorFlow-Course项目中的自编码器教程，深入浅出地讲解自编码器的原理、类型及实现方法。

自编码器概述

自编码器是一种特殊的神经网络，其核心思想是将输入数据复制到输出。它通常由两部分组成：

编码器(Encoder)：将输入数据映射到一个隐藏层空间（称为"编码"或"潜在表示"）
解码器(Decoder)：从编码中重构原始输入

自编码器的神奇之处在于，它能够学习数据的高效表示，这种表示通常比原始数据维度更低，但保留了最重要的特征。

自编码器的类型

1. 欠完备自编码器(Undercomplete Autoencoders)

这是最基本的自编码器类型，其编码维度小于输入维度。通过限制编码维度，网络被迫学习数据中最显著的特征。

当使用线性解码器时，欠完备自编码器相当于执行主成分分析(PCA)
添加非线性激活函数后，它成为PCA的非线性推广

2. 正则化自编码器(Regularized Autoencoders)

这类自编码器不限制编码维度，而是通过添加正则化项来防止网络简单地记忆输入数据。

稀疏自编码器(Sparse Autoencoders)

在损失函数中添加稀疏性惩罚项，通常用于分类等下游任务。

去噪自编码器(Denoising Autoencoders, DAE)

输入是经过噪声污染的数据，网络需要先去除噪声再重构原始数据。

收缩自编码器(Contractive Autoencoders, CAE)

学习对输入微小变化具有鲁棒性的数据表示。

3. 变分自编码器(Variational Autoencoders)

这类自编码器不是简单复制输入到输出，而是最大化训练数据的概率，因此不需要正则化就能捕获有用信息。

TensorFlow实现：MNIST图像的自编码器

下面我们将实现一个用于MNIST手写数字识别的欠完备自编码器。

网络结构设计

我们构建一个3层编码器和3层解码器的结构：

编码器：每层使用步长为2的卷积操作，将空间维度(宽、高)减半
解码器：每层使用转置卷积(步长为2)将空间维度加倍

import tensorflow.contrib.layers as lays

def autoencoder(inputs):
    # 编码器部分
    # 32x32x1 → 16x16x32 → 8x8x16 → 2x2x8
    net = lays.conv2d(inputs, 32, [5, 5], stride=2, padding='SAME')
    net = lays.conv2d(net, 16, [5, 5], stride=2, padding='SAME')
    net = lays.conv2d(net, 8, [5, 5], stride=4, padding='SAME')
    
    # 解码器部分
    # 2x2x8 → 8x8x16 → 16x16x32 → 32x32x1
    net = lays.conv2d_transpose(net, 16, [5, 5], stride=4, padding='SAME')
    net = lays.conv2d_transpose(net, 32, [5, 5], stride=2, padding='SAME')
    net = lays.conv2d_transpose(net, 1, [5, 5], stride=2, padding='SAME', 
                              activation_fn=tf.nn.tanh)
    return net

数据预处理

由于MNIST图像原始大小为28×28，我们将其调整为32×32（2的幂次方，便于网络设计）：

import numpy as np
from skimage import transform

def resize_batch(imgs):
    imgs = imgs.reshape((-1, 28, 28, 1))
    resized_imgs = np.zeros((imgs.shape[0], 32, 32, 1))
    for i in range(imgs.shape[0]):
        resized_imgs[i, ..., 0] = transform.resize(imgs[i, ..., 0], (32, 32))
    return resized_imgs

模型训练

定义损失函数（均方误差）和优化器（Adam）：

import tensorflow as tf

# 定义输入占位符和自编码器网络
ae_inputs = tf.placeholder(tf.float32, (None, 32, 32, 1))
ae_outputs = autoencoder(ae_inputs)

# 定义损失函数和优化器
loss = tf.reduce_mean(tf.square(ae_outputs - ae_inputs))
train_op = tf.train.AdamOptimizer(learning_rate=lr).minimize(loss)

# 初始化变量
init = tf.global_variables_initializer()

训练与测试

from tensorflow.examples.tutorials.mnist import input_data

# 超参数设置
batch_size = 500
epoch_num = 5
lr = 0.001

# 加载MNIST数据集
mnist = input_data.read_data_sets("MNIST_data", one_hot=True)

with tf.Session() as sess:
    sess.run(init)
    for ep in range(epoch_num):
        for batch_n in range(mnist.train.num_examples // batch_size):
            batch_img, _ = mnist.train.next_batch(batch_size)
            batch_img = resize_batch(batch_img)
            _, c = sess.run([train_op, loss], feed_dict={ae_inputs: batch_img})
            print(f'Epoch: {ep+1} - cost= {c:.5f}')

    # 测试网络
    test_img, _ = mnist.test.next_batch(50)
    test_img = resize_batch(test_img)
    recon_img = sess.run(ae_outputs, feed_dict={ae_inputs: test_img})[0]

结果可视化

训练完成后，我们可以比较原始图像和重构图像：

import matplotlib.pyplot as plt

plt.figure(1)
plt.title('Reconstructed Images')
for i in range(50):
    plt.subplot(5, 10, i+1)
    plt.imshow(recon_img[i, ..., 0], cmap='gray')

plt.figure(2)
plt.title('Input Images')
for i in range(50):
    plt.subplot(5, 10, i+1)
    plt.imshow(test_img[i, ..., 0], cmap='gray')

plt.show()