《深度学习之Pytorch实战计算机视觉》阅读笔记 第11章：自动编码器

1. 自动编码器

  • 一种可以进行无监督学习的神经网络模型
  • 自动编码器：1）用于核心特征提取的编码部分；2）实现数据重构的解码部分
  • 简化模型：
    20190905141205.png
    最左侧用于数据输入的输入层，在输入数据通过神经网络的层层传递之后得到了中间的输入特征的核心特征。然后将输入数据的核心特征再传递到一个逆向的神经网络中，核心特征会被解压并重构，最后得到一个和输入数据相近的输出数据。
  • 作用：实现输入数据的清洗，对数据的某些关键特征进行增强和放大

2. 去除图片马赛克

  • 马赛克图片生成 

    1. # 添加马赛克
    2. noisy_x_train=x_train+0.5*torch.randn(x_train.shape)
    3. noisy_x_train=torch.clamp(noisy_x_train,0.,1.)

  • 模型定义
    1）线性变换
    2）卷积变换 

    1. class AutoEncoder_Linear(torch.nn.Module):
    2.   def __init__(self):
    3.       super(AutoEncoder_Linear, self).__init__()
    4.       self.encoder = torch.nn.Sequential(torch.nn.Linear(28 * 28, 128),
    5.                                          torch.nn.ReLU(),
    6.                                          torch.nn.Linear(128, 64),
    7.                                          torch.nn.ReLU(),
    8.                                          torch.nn.Linear(64, 32),
    9.                                          torch.nn.ReLU())
    10.       self.decoder = torch.nn.Sequential(torch.nn.Linear(32, 64),
    11.                                          torch.nn.ReLU(),
    12.                                          torch.nn.Linear(64, 128),
    13.                                          torch.nn.ReLU(),
    14.                                          torch.nn.Linear(128, 28 * 28))
    16.   def forward(self, input):
    17.       output = self.encoder(input)
    18.       output = self.decoder(output)
    19.       return output
    1. # 卷积变换
    2. class AutoEncoder_Conv(torch.nn.Module):
    3.   def __init__(self):
    4.       super(AutoEncoder_Conv, self).__init__()
    5.       self.encoder = torch.nn.Sequential(
    6.           torch.nn.Conv2d(1, 64, kernel_size=3, stride=1, padding=1),
    7.           torch.nn.ReLU(), torch.nn.MaxPool2d(kernel_size=2, stride=2),
    8.           torch.nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),
    9.           torch.nn.ReLU(), torch.nn.MaxPool2d(kernel_size=2, stride=2))
    10.       self.decoder = torch.nn.Sequential(
    11.           torch.nn.Upsample(scale_factor=2, mode="nearest"),
    12.           torch.nn.Conv2d(128, 64, kernel_size=3, stride=1, padding=1),
    13.           torch.nn.ReLU(), torch.nn.Upsample(scale_factor=2, mode="nearest"),
    14.           torch.nn.Conv2d(64, 1, kernel_size=3, stride=1, padding=1))
    16.       def forward(self, input):
    17.           output = self.encoder(input)
    18.           output = self.decoder(output)
    19.           return output

  • 加载数据 

    1. transform = transforms.Compose(
    2.   [transforms.ToTensor(),
    3.    transforms.Normalize(mean=[0.5], std=[0.5])])
    4. dataset_train = datasets.MNIST(root="../data",
    5.                              transform=transform,
    6.                              train=True,
    7.                              download=True)
    8. dataset_test = datasets.MNIST(root="../data", transform=transform, train=False)
    9. train_load = torch.utils.data.DataLoader(dataset=dataset_train,
    10.                                        batch_size=4,
    11.                                        shuffle=True)
    12. test_load = torch.utils.data.DataLoader(dataset=dataset_test,
    13.                                       batch_size=4,
    14.                                       shuffle=True)

  • 训练 

    1. epoch_n = 10
    2. for epoch in range(epoch_n):
    3.   running_loss = 0.0
    4.   print("Epoch {}/{}".format(epoch, epoch_n))
    5.   print("-" * 20)
    7.   for data in train_load:
    8.       x_train, _ = data
    10.       # Linear
    11.       x_train, noisy_x_train = Variable(x_train.view(-1, 28 * 28)), Variable(
    12.           noisy_x_train.view(-1, 28 * 28))
    13.       # Conv
    14.       # x_train, noisy_x_train = Variable(x_train.cuda()), Variable(
    15.       #     noisy_x_train.cuda())
    17.       x_train, noisy_x_train = Variable(x_train.view(-1, 28 * 28)), Variable(
    18.           noisy_x_train.view(-1, 28 * 28))
    19.       image_pre = model(noisy_x_train)
    20.       loss = loss_fun(image_pre, x_train)
    22.       optimizer.zero_grad()
    23.       loss.backward()
    24.       optimizer.step()
    26.       running_loss += loss.item()
    28.   print("Loss is {:.4f}".format(running_loss / len(dataset_train)))

  • Test ```python

    Test

    data_loader_test = torch.utils.data.DataLoader(dataset=dataset_test,

    1.                                          batch_size=4,
    2.                                          shuffle=True)

    xtest, = next(iter(data_loader_test)) print(x_test) img1 = torchvision.utils.make_grid((x_test)) img1 = img1.numpy().transpose(1, 2, 0) std = [0.5, 0.5, 0.5] mean = [0.5, 0.5, 0.5] img1 = img1 * std + mean

noisy_x_test = img1 + 0.5 np.random.randn(img1.shape) noisy_x_test = np.clip(noisy_x_test, 0., 1.)

plt.figure() plt.imshow(noisy_x_test)

img2 = x_test 0.5 torch.randn(*x_test.shape) img2 = torch.clamp(img2, 0., 1.)

img2 = Variable(img2.view(-1, 28 * 28))

test_pred = model(img2)

img_test = test_pred.data.view(-1, 1, 28, 28) img2 = torchvision.utils.make_grid(img_test) img2 = img2.numpy().transpose(1, 2, 0) img2 = img2 * std + mean img2 = np.clip(img2, 0., 1.) plt.figure() plt.imshow(img2) plt.show() ```