Pytorch实现mnist数据集图像自编码降噪（新人纯小白）

        新人第一次发文，如果有不对的地方，还请各位大佬多多包涵！希望如果有和我相同的兄弟，不会再经历我的痛苦。       

        这篇文章出现的原因是：作为小白，在刚开始学习的时候，框架用的是Tensorflow，但由于一些原因，老师让将框架改为Pytorch，练习mnist数据集图像自编码降噪。而作者编程水平又是十分稀碎，让我自己从无到有编一个自编码器，可以说是不可能，无奈只能上CSDN求助大佬，希望能白嫖写好的代码。

       然而在找到的大多是以Tensorflow为框架，而以Pytorch为框架的有大多直接练习具体的图片，或者就是具体代码在Github上。而我的网络无法打开Github，需要VPN。

       好了，不多说，上代码

import torch
import torch.nn as nn  # 引入NN体系结构，相当于Containers（容器）：class torch.nn.Module所有网络的基类。你的模型也应该继承这个类。
import torch.optim as optim  # 优化库
from torchvision import datasets, transforms  # 目前流行的数据集，模型结构和常用的图片转换工具,对PIL.Image进行变换
from matplotlib import pyplot as plt
import numpy as np

# 导入mnist数据集,
train_data = datasets.MNIST(root='data', train=True, transform=transforms.ToTensor())
test_data = datasets.MNIST(root='data', train=False, transform=transforms.ToTensor())

# 创建培训和测试数据加载器,num_workers (int, optional) – 用多少个子进程加载数据。0表示数据将在主进程中加载(默认: 0)
num_workers = 0
# 每批要装载多少个样本
batch_size = 20

# 准备数据加载器,(数据加载器:组合数据集和采样器，并在数据集上提供单进程或多进程迭代器。)
train_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)


class Autoencoder(nn.Module):  # 初始化网络
    def __init__(self):
        super(Autoencoder, self).__init__()  # 继承父类的初始化方式，即class Autoencoder(nn.Module)的初始化方法。便于网络的日后的维护。

        # 编码器部分
        self.encoder = nn.Sequential(  # 一个序列容器，用于搭建神经网络的模块被按照被传入构造器的顺序添加到nn.Sequential()容器中。
            nn.Conv2d(1, 16, kernel_size=3, stride=1, padding=1),  # 输入1通道，输出16通道，3x3卷积，步长为1，padding为1
            # 图片规格为16*28*28
            nn.ReLU(),
            nn.MaxPool2d(2, 2),  # 16*14*14
            nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=1),  # 输入16通道，输出32通道，3x3卷积，步长为1，padding为1
            # 32*14*14
            nn.ReLU(),
            nn.MaxPool2d(2, 2),  # 32*7*7
        )

        # 解码器部分
        self.decoder = nn.Sequential(
            nn.ConvTranspose2d(32, 16, kernel_size=2, stride=2, padding=0),  # 16*14*14
            # 输入32通道，输出16通道，2x2卷积转置，步长为2，padding为0
            nn.ReLU(),
            nn.ConvTranspose2d(16, 1, kernel_size=2, stride=2, padding=0),  # 1*28*28
            nn.Sigmoid(),
        )

    # 定义模型的前向传播过程,及模型的输入为x，然后先后经过编码器和解码器，然后输出解码器的输出结果
    def forward(self, x):
        x = self.encoder(x)
        x = self.decoder(x)
        return x


# initialize the NN 初始化NN
model = Autoencoder()
# 第一模型为我们定义好的Autoencoder
print(model)

# 定义损失函数和优化器，损失函数为MSE，优化器取Adam
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
# 定义迭代次数
n_epochs = 20

noise_factor = 0.5

for epochs in range(1, n_epochs + 1):
    # 预训练模型本身无关，不要在意
    train_loss = 0

    for data in train_loader:
        images, _ = data  # 这里的images是torch.Size([20, 1, 28, 28])
        # 加入噪声
        images_noise = images + noise_factor * torch.randn(size=images.shape, out=None)
        # 卡一下范围，不要超出0~1的范围
        images_noise = np.clip(images_noise, 0., 1.)

        # 清楚原有的优化梯度
        optimizer.zero_grad()
        # 开始训练
        output = model(images_noise)
        # print(images_noise.shape)
        # print(output.shape)
        # 计算输出的MSE误差，比对双方为模型输和为加噪声前的输入
        loss = criterion(output, images)
        # 反向传播计算得到每个参数的梯度值
        loss.backward()
        # 通过梯度下降执行一步参数更新
        optimizer.step()
        # 到这里，模型训练就结束了，但是为了训练过程更加清晰，我们希望可以看到每个epoch过程中，训练损失的变化
        # 所以
        train_loss += loss.item() * images.size(0)
    # 之后，我们计算一个train_loss的平均，将其打印
    train_loss = train_loss / len(train_loader)
    print('Epoch:{} \tTraining Loss:{:.6f}'.format(
        epochs,
        train_loss
    ))

# obtain one batch of test images 获取一批测试图像
dataiter = iter(test_loader)
images, labels = next(dataiter)

# add noise to the test images 向测试图像添加噪声
noisy_images = images + noise_factor * torch.randn(size=images.shape, out=None)
noisy_images = np.clip(noisy_images, 0., 1.)

# get sample outputs 获取样本输出
output = model(noisy_images)
# prep images for display 准备要显示的图像
noisy_imgs = noisy_images.numpy()

# output is resized into a batch of images 输出的大小调整为一批图像
output = output.view(batch_size, 1, 28, 28)  # 这里的view相当于reshape
# use detach when it's an output that requires_grad 当输出需要_grad时使用分离
output = output.detach().numpy()

# plot the first ten input images and then reconstructed images 绘制前十个输入图像，然后重建图像
fig, axes = plt.subplots(nrows=2, ncols=10, sharex=True, sharey=True, figsize=(25, 4))

# input images on top row, reconstructions on bottom 输入图像在上排，重建在下排
for 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)

# 显示生成的子图
plt.show()

如果train_loss的训练值卡在某个数不动了，建议将学习率，也就是 lr = 0.001 改为0.0001，如果还不行，就改优化器。还不行，就直接找教程吧，我在CSDN上找到过，但由于是第一发文，还不知道怎么转载 。

       最后，感谢大家的支持。