堆叠降噪自编码器——SDAE

2021-09-11 18:35:12 阅读：968 来源： 互联网

堆叠自编码器

对于很多数据来说，仅使用两层神经网络的自编码器结构还不足以获取一种好的数据表示，为了获取更好的数据表示，我们可以使用更深层的神经网络。深层神经网络作为自编码器提取的数据表示一般会更加抽象，能够更好地捕捉到数据的语义信息。在实践中经常使用逐层堆叠的方式来训练一个深层的自编码器，称为堆叠自编码器（SAE）。堆叠自编码器一般可以采用逐层训练来学习网络参数。

堆叠自编码器示意图

降噪自编码器

我们使用自编码器的目的是得到有效的数据表示，而有效的数据表示除了具有最小重构误差或稀疏性等性质之外，还可以要求其具备其他性质，比如对数据部分损坏的鲁棒性。高维数据（如图像）一般具有一定的冗余信息，比如我们可以根据一张部分损坏的图像联想到完整的内容。因此我们希望自编码器也能够从部分损坏的数据中得到有效的数据表示，并能够恢复出完整的原始信息。
降噪自编码器就是一种通过引入噪声来增加编码鲁棒性的自编码器。对于一个向量\(x\)，我们首先根据一个比例\(\mu\)（一般小于0.5）随机将\(x\)的一些维度的值设置为0，得到一个被损坏的向量\(\tilde x\)，然后将被损坏的向量\(\tilde x\)输入给自编码器得到编码\(z\)，并重构出无损的原始输入\(x\)。

自编码器示意图

降噪码器示意图

堆叠降噪自编码器

堆叠降噪自编码器（SDAE）与降噪自编码器（DAE）的关系就像堆叠自编码器（SAE）与自编码器（AE）之间的关系。SDAE的输入是加入噪声的原始数据\(x\)，将DAE原先的单隐藏层堆叠多次便是SDAE。

代码实现

本文利用pytorch实现了SDAE，数据集是MNIST数据，我们通过对原始图片加入一定比例的椒盐噪声，然后训练能够重构出无损图片的SDAE。下图是无损图和加入噪声的图。

文件结构

config.py：保存模型超参数

import argparse


class HyperParam:
    def __init__(self):
        self.parse = argparse.ArgumentParser()
        self.parse.add_argument("--epoch",  type=int, default=40)
        self.parse.add_argument("--batch_size", type=int, default=64)
        self.parse.add_argument("--image_size", type=int, default=28 * 28)
        self.parse.add_argument("--lr", type=float, default=0.0002)

sdae.py：堆叠降噪自编码器模型实现

import os
import torch
from config import HyperParam
import torch.nn as nn
import torch.optim as optim
import torchvision
import torch.utils.data as Data
import torchvision.transforms as transforms
import numpy as np
import matplotlib.pyplot as plt

os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"

hyparam = HyperParam()
opt = hyparam.parse.parse_args()


datapath = "C:/Users/DZL102/Desktop/VAE/data"
train_dataset = torchvision.datasets.MNIST(root=datapath,
                                           train=True,
                                           transform=transforms.ToTensor())
train_loader = Data.DataLoader(dataset=train_dataset,
                               batch_size=opt.batch_size,
                               shuffle=True)

test_dataset = torchvision.datasets.MNIST(root=datapath,
                                          transform=transforms.ToTensor())
test_loader = Data.DataLoader(dataset=test_dataset,
                              batch_size=opt.batch_size,
                              shuffle=True)


def make_noise(X, noise_prop):
    X_clone = X.clone()
    # X：batchsize, channel, height, width
    batchsize, channel, height, width = X.shape
    num = int(height * width * noise_prop)
    for b in range(batchsize):
        for c in range(channel):
            for i in range(num):
                h = np.random.randint(0, height)
                w = np.random.randint(0, width)
                if np.random.randint(0, 2) == 0:
                    X_clone[b, c, h, w] = 0  # 黑点
                else:
                    X_clone[b, c, h, w] = 0.98  # 白点

    return X_clone


def draw(X):
    h, w = 2, 2
    fig, axs = plt.subplots(nrows=h, ncols=w)
    for i in range(h):
        for j in range(w):
            axs[i, j].imshow(X[(i + 1) * (j + 1) - 1, 0, :] * 255, cmap="gray")
            axs[i, j].set_xticks([])
            axs[i, j].set_yticks([])
    plt.show()


class SDAE(nn.Module):
    def __init__(self, in_size):
        super().__init__()
        self.encoder = nn.Sequential(
            nn.Linear(in_size, 400),
            nn.ReLU(),
            nn.Linear(400, 100),
            nn.ReLU())
        self.decoder = nn.Sequential(
            nn.Linear(100, 400),
            nn.ReLU(),
            nn.Linear(400, in_size))
        self.sdae = nn.Sequential(self.encoder, self.decoder)

    def forward(self, X):
        return self.sdae(X)


model = SDAE(opt.image_size)
loss = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=opt.lr)


def train(epochs):
    print("training..........")
    for epoch in range(epochs):
        for i, (X, _) in enumerate(train_loader):
            y = X.view(-1, opt.image_size)
            X = make_noise(X, 0.1)
            X = X.view(-1, opt.image_size)

            output = model(X)
            train_loss = loss(output, y)
            optimizer.zero_grad()
            train_loss.backward()
            optimizer.step()

        test_loss = 0
        with torch.no_grad():
            for i, (X, _) in enumerate(test_loader):
                X = X.view(-1, opt.image_size)
                output = model(X)
                test_loss += loss(output, X).item()
            print("epoch [{}/{}], test_loss: {:.4f}".format(epoch + 1,
                                                            epochs, test_loss))


train(opt.epoch)

# 持久化模型
torch.save(model, 'model/model.pth')

标签：编码器,SDAE,nn,self,堆叠,import,size
来源： https://www.cnblogs.com/foghorn/p/15255708.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

堆叠降噪自编码器——SDAE

堆叠自编码器

降噪自编码器

堆叠降噪自编码器

代码实现