Autoencoders aren’t too useful in practice, but they can be used to denoise images quite successfully just by training the network on noisy images. We can generate noisy images by adding Gaussian noise to the training images, then clipping the values to be between 0 and 1.

自动编码器在实践中并不太有用，但是仅通过在嘈杂的图像上训练网络，它们就可以非常成功地对图像进行去噪。 我们可以通过将高斯噪声添加到训练图像中，然后将值裁剪为0到1之间的方式来生成嘈杂的图像。

“Denoising auto-encoder forces the hidden layer to extract more robust features and restrict it from merely learning the identity. Autoencoder reconstructs the input from a corrupted version of it.”

去噪自动编码器会强制隐藏层提取更强大的功能，并限制其仅学习身份。 自动编码器会从损坏的版本中重建输入。”

A denoising auto-encoder does two things:

去噪自动编码器有两件事：

• Encode the input (preserve the information about the data)编码输入(保留有关数据的信息)
• Undo the effect of a corruption process stochastically applied to the input of the auto-encoder.撤消随机应用于自动编码器输入的损坏过程的影响。

For the depiction of the denoising capabilities of Autoencoders, we’ll use noisy images as input and the original, clean images as targets.

为了描述自动编码器的降噪功能，我们将使用嘈杂的图像作为输入，并使用原始的干净图像作为目标。

Example: Top image is input, and the bottom image is the target.

示例：输入了顶部图像，而底部图像是目标。

问题陈述： (Problem Statement:)

Build the model for the denoising autoencoder. Add deeper and additional layers to the network. Using MNIST dataset, add noise to the data and try to define and train an autoencoder to denoise the images.

为降噪自动编码器构建模型。 向网络添加更深的层。 使用MNIST数据集，向数据添加噪声，并尝试定义和训练自动编码器以对图像进行降噪。

解： (Solution:)

Import Libraries and Load Dataset: Given below is the standard procedure to import the libraries and load the MNIST dataset.

导入库和加载数据集：以下是导入库和加载MNIST数据集的标准过程。

import torchimport numpy as npfrom torchvision import datasetsimport torchvision.transforms as transforms# convert data to torch.FloatTensortransform = transforms.ToTensor()# load the training and test datasetstrain_data = datasets.MNIST(root='data', train=True, download=True, transform=transform)test_data = datasets.MNIST(root='data', train=False, download=True, transform=transform)# Create training and test dataloadersnum_workers = 0# how many samples per batch to loadbatch_size = 20# prepare data loaderstrain_loader = torch.utils.data.DataLoader(train_data, batch_size=batch_size, num_workers=num_workers)test_loader = torch.utils.data.DataLoader(test_data, batch_size=batch_size, num_workers=num_workers)

Visualize the Data: You can use standard matplotlib library to view whether you’ve loaded your dataset correctly or not.

可视化数据：可以使用标准的matplotlib库查看是否正确加载了数据集。

import matplotlib.pyplot as plt%matplotlib inline

# obtain one batch of training imagesdataiter = iter(train_loader)images, labels = dataiter.next()images = images.numpy()# get one image from the batchimg = np.squeeze(images[0])fig = plt.figure(figsize = (5,5)) ax = fig.add_subplot(111)ax.imshow(img, cmap='gray')

The output should be something like this:

输出应该是这样的：

Network Architecture: The most crucial part is the network generation. It is because denoising is a hard problem for the network; hence we’ll need to use deeper convolutional layers here. It is recommended to start with a depth of 32 for the convolutional layers in the encoder, and the same depth going backwards through the decoder.

网络体系结构：最关键的部分是网络生成。 这是因为去噪是网络的难题。 因此我们需要在这里使用更深的卷积层。 对于编码器中的卷积层，建议从32的深度开始，并向后穿过解码器。

import torch.nn as nnimport torch.nn.functional as F# define the NN architectureclass ConvDenoiser(nn.Module):    def __init__(self):        super(ConvDenoiser, self).__init__()        ## encoder layers ##        # conv layer (depth from 1 --> 32), 3x3 kernels        self.conv1 = nn.Conv2d(1, 32, 3, padding=1)          # conv layer (depth from 32 --> 16), 3x3 kernels        self.conv2 = nn.Conv2d(32, 16, 3, padding=1)        # conv layer (depth from 16 --> 8), 3x3 kernels        self.conv3 = nn.Conv2d(16, 8, 3, padding=1)        # pooling layer to reduce x-y dims by two; kernel and stride of 2        self.pool = nn.MaxPool2d(2, 2)

        ## decoder layers ##        # transpose layer, a kernel of 2 and a stride of 2 will increase the spatial dims by 2        self.t_conv1 = nn.ConvTranspose2d(8, 8, 3, stride=2)  # kernel_size=3 to get to a 7x7 image output        # two more transpose layers with a kernel of 2        self.t_conv2 = nn.ConvTranspose2d(8, 16, 2, stride=2)        self.t_conv3 = nn.ConvTranspose2d(16, 32, 2, stride=2)        # one, final, normal conv layer to decrease the depth        self.conv_out = nn.Conv2d(32, 1, 3, padding=1)def forward(self, x):        ## encode ##        # add hidden layers with relu activation function        # and maxpooling after        x = F.relu(self.conv1(x))        x = self.pool(x)        # add second hidden layer        x = F.relu(self.conv2(x))        x = self.pool(x)        # add third hidden layer        x = F.relu(self.conv3(x))        x = self.pool(x)  # compressed representation

        ## decode ##        # add transpose conv layers, with relu activation function        x = F.relu(self.t_conv1(x))        x = F.relu(self.t_conv2(x))        x = F.relu(self.t_conv3(x))        # transpose again, output should have a sigmoid applied        x = F.sigmoid(self.conv_out(x))

        return x# initialize the NNmodel = ConvDenoiser()print(model)

Training: The training of the network takes significantly less time with GPU; hence I would recommend using one. Though here we are only concerned with the training images, which we can get from the train_loader.

培训：使用GPU进行网络培训所需的时间大大减少； 因此，我建议使用一个。 虽然在这里我们只关心训练图像，但可以从train_loader获得。

# specify loss functioncriterion = nn.MSELoss()# specify loss functionoptimizer = torch.optim.Adam(model.parameters(), lr=0.001)# number of epochs to train the modeln_epochs = 20# for adding noise to imagesnoise_factor=0.5for epoch in range(1, n_epochs+1):    # monitor training loss    train_loss = 0.0

    ###################    # train the model #    ###################    for data in train_loader:        # _ stands in for labels, here        # no need to flatten images        images, _ = data

        ## add random noise to the input images        noisy_imgs = images + noise_factor * torch.randn(*images.shape)        # Clip the images to be between 0 and 1        noisy_imgs = np.clip(noisy_imgs, 0., 1.)

        # clear the gradients of all optimized variables        optimizer.zero_grad()        ## forward pass: compute predicted outputs by passing *noisy* images to the model        outputs = model(noisy_imgs)        # calculate the loss        # the "target" is still the original, not-noisy images        loss = criterion(outputs, images)        # backward pass: compute gradient of the loss with respect to model parameters        loss.backward()        # perform a single optimization step (parameter update)        optimizer.step()        # update running training loss        train_loss += loss.item()*images.size(0)

    # print avg training statistics     train_loss = train_loss/len(train_loader)    print('Epoch: {} \tTraining Loss: {:.6f}'.format(        epoch,         train_loss        ))

In this case, we are actually adding some noise to these images and we’ll feed these noisy_imgs to our model. The model will produce reconstructed images based on the noisy input. But, we want it to produce normal un-noisy images, and so, when we calculate the loss, we will still compare the reconstructed outputs to the original images!

在这种情况下，我们实际上 会在这些图像上 添加一些噪点 ，并将这些 noisy_imgs 入模型。 该模型将根据嘈杂的输入产生重建的图像。 但是，我们希望它产生正常的无噪图像，因此，当我们计算损耗时，我们仍然会将重构的输出与原始图像进行比较！

Because we’re comparing pixel values in input and output images, it will be best to use a loss that is meant for a regression task. Regression is all about comparing quantities rather than probabilistic values. So, in this case, I’ll use MSELoss.

因为我们正在比较输入和输出图像中的像素值，所以最好使用用于回归任务的损耗。 回归全是比较数量而不是概率值。 因此，在这种情况下，我将使用MSELoss 。

Results: Here let’s add noise to the test images and pass them through the autoencoder.

结果：在这里，我们将噪声添加到测试图像中，然后将其通过自动编码器。

# obtain one batch of test imagesdataiter = iter(test_loader)images, labels = dataiter.next()# add noise to the test imagesnoisy_imgs = images + noise_factor * torch.randn(*images.shape)noisy_imgs = np.clip(noisy_imgs, 0., 1.)# get sample outputsoutput = model(noisy_imgs)# prep images for displaynoisy_imgs = noisy_imgs.numpy()# output is resized into a batch of iagesoutput = output.view(batch_size, 1, 28, 28)# use detach when it's an output that requires_gradoutput = output.detach().numpy()# plot the first ten input images and then reconstructed imagesfig, axes = plt.subplots(nrows=2, ncols=10, sharex=True, sharey=True, figsize=(25,4))# input images on top row, reconstructions on bottomfor noisy_imgs, row in zip([noisy_imgs, output], axes):    for img, ax in zip(noisy_imgs, row):        ax.imshow(np.squeeze(img), cmap='gray')        ax.get_xaxis().set_visible(False)        ax.get_yaxis().set_visible(False)

It does a surprisingly great job of removing the noise, even though it’s sometimes difficult to tell what the original number is.

尽管有时很难说出原始数字是多少，但是它在消除噪声方面却做得非常出色。

Code: You can find this code on my Github: Denoising Autoencoder

代码：您可以在我的Github上找到此代码： Denoising Autoencoder

Conclusion: In this article, we learnt how to code denoising autoencoder in python properly. We also learnt that denoising is a hard problem for the network, hence using deeper convolutional layers provide exceptionally accurate results.

结论：在本文中，我们学习了如何在python中正确编码去噪自动编码器。 我们还了解到，去噪对于网络来说是一个难题，因此使用更深的卷积层可提供异常准确的结果。

Reference: I learnt this topic from “Udacity’s Secure and Private AI Scholarship Challenge Nanodegree Program.”

参考资料：我从“ Udacity的安全和私人AI奖学金挑战纳米学位计划”中学到了这个主题。