tensorflow2从入门到精通——自编码器系列原理以及实现

自编码器

• 无监督学习，常用于数据去噪，数据降维、图像重构

无监督学习

• 监督学习

• 样本数据对应着标签，称之为有监督学习

• 难点

• 绝大部分标签为人工标注
• 有些数据对于标注者的先验知识要求过高，且难以标注，如医学数据，具有一定的专业性
• 人工标注数据成果过高
• 人工标注容易引起主观先验偏差

• 典型无监督学习

• PCA，聚类，自编码器

自编码器介绍

本质上是一个数据编码与解码的过程，数据通过压缩之后解压恢复为元数据，编码时模型会将输入数据映射到低维向量，而解码时模型再将向量映射回输入数据的空间。与平常使用 的文件压缩和解压操作了类似。

普通自编码器

组成形式：输入层，单层隐藏层、输出层

深度自编码器

在隐藏层部分采用更深的多层网络结构进行表示，增加其中的特征提取层数

欠完备自编码器

隐藏层的维度比输入维度小，强制自编码器捕捉训练输入数据中最有用的特征。

正则自编码器

在损失函数上加上正则项等强制自编码器学习一些其他特性，如稀疏特征。

去噪自编码器

将输入数据进行一些人为破坏，如加噪等，强制自编码器学习相关特征并输出无噪数据。

• 自编码器

import tensorflow as tf
form tensorflow.keras import layers
class Autoencoder(tf.keras.Model):
    def __init__(self):
        super(Autoencoder,self).__init__()
        self.Encoder = tf.keras.models.Sequential([   #编码器网络
            layers.Dense(512, kernel_initializer = 'normal', activation = 'relu'),
            layers.Dense(256, kernel_initializer = 'normal', activation = 'relu'),
            layers.Dense(60, kernel_initializer = 'normal', activation = 'relu')
        ])
        self.Decoder = tf.keras.models.Sequential([   #解码器网络
            layers.Dense(256, kernel_initializer = 'normal', activation = 'relu'),
            layers.Dense(512, kernel_initializer = 'normal', activation = 'relu'),
            layers.Dense(784, kernel_initializer = 'normal', activation = 'sigmoid')
        ])
    def call(self,input_features,training = None):   #前向传播
        code = self.Encoder(input_features)   #数据编码
        reconstructed = self.Decoder(code)   #数据解码
        return reconstructed

conv 自编码器

class Conv_Autoencoder(tf.keras.Model):
    def __init__(self):
        super(Conv_Autoencoder,self).__init__()
        self.Encoder = tf.keras.models.Sequential([   #编码器网络
            layers.Conv2D(16,(3,3),kernel_initializer = 'normal',padding = 'same',activation = 'relu'),
            layers.MaxPool2D((2,2)),
            layers.Conv2D(8,(3,3),kernel_initializer = 'normal',padding = 'same',activation = 'relu'),
            layers.MaxPool2D((2,2))
        ])
        self.Decoder = tf.keras.models.Sequential([   #解码器网络
            layers.UpSampling2D((2,2)),
            layers.Conv2D(8,(3,3),kernel_initializer = 'normal',padding = 'same', activation = 'relu'),
            layers.UpSampling2D((2,2)),
            layers.Conv2D(16,(3,3),kernel_initializer = 'normal',padding = 'same', activation = 'relu'),
            layers.Conv2D(1,(3,3),kernel_initializer = 'normal',padding = 'same', activation = 'sigmoid')
        ])
    def call(self,input_features,training = None):   #前向传播         
        code = self.Encoder(input_features)                      
        reconstructed = self.Decoder(code)                       
        return reconstructed

变分自编码器

class VAE(tf.keras.Model):
    def __init__(self,latent_dim):
        super(VAE,self).__init__()
        self.latent_dim = latent_dim
        self.epsilon_std = 1.0
        self.Encoder = tf.keras.models.Sequential([   #编码器网络
            layers.Dense(256,activation='relu'),
            layers.Dense(2)
        ])
        self.Decoder = tf.keras.models.Sequential([   #解码器网络
            layers.Dense(256, activation='relu'),
            layers.Dense(784,activation = 'sigmoid')
        ])
        
    def encode(self,x):
        z_mean = self.Encoder(x)   #均值
        z_log_var = self.Encoder(x)   #方差
        return z_mean, z_log_var
    
    def sampling(self, z_mean, z_log_var):
        z_mean, z_log_var = z_mean, z_log_var
        epsilon = K.random_normal(shape=(K.shape(z_mean)[0], self.latent_dim), mean=0.,stddev=self.epsilon_std)
        return z_mean + K.exp(z_log_var / 2) * epsilon
    
    def decode(self,z):
        x_decoded_mean = self.Decoder(z)
        return x_decoded_mean

class Autoencoder(tf.keras.Model):
    def __init__(self):
        super(Autoencoder, self).__init__()
        self.encoder = tf.keras.Sequential([
          tf.keras.layers.Dense(64, activation="relu"),
          tf.keras.layers.Dense(32, activation="relu"),
          tf.keras.layers.Dense(16, activation="relu")])

        self.decoder = tf.keras.Sequential([
          tf.keras.layers.Dense(32, activation="relu"),
          tf.keras.layers.Dense(64, activation="relu"),
          tf.keras.layers.Dense(140, activation="sigmoid")])

    def call(self, x):
        encoded = self.encoder(x)
        decoded = self.decoder(encoded)
        return decoded