0
0

pytorch 自编码器实现图像的降噪

自编码器

自动编码器是一种无监督的深度学习算法，它学习输入数据的编码表示，然后重新构造与输出相同的输入。它由编码器和解码器两个网络组成。编码器将高维输入压缩成低维潜在(也称为潜在代码或编码空间) ，以从中提取最相关的信息，而解码器则解压缩编码数据并重新创建原始输入。

自编码器的输入和输出应该尽可能的相似。

通过输入含有噪声的图像，编码器在编码的过程中会存在信息丢失，将输入和输出最相似的特征保留下来，通过解码器得到最后的输出。在这个转换的过程中实现了图像的去噪。

自编码器主要的用途其实是用于降维，将高维的数据编码为一组向量，解码器通过解码得到输出。

数据集导入可视化

  1. import torchvision
  2. import matplotlib.pyplot as plt
  3. from torch.utils.data import DataLoader
  4. import numpy as np
  5. import random
  6. import PIL.Image as Image
  7. import torchvision.transforms as transforms
  9. class AddPepperNoise(object):
  10.     """增加椒盐噪声
  11.     Args:
  12.         snr （float）: Signal Noise Rate
  13.         p (float): 概率值，依概率执行该操作
  14.     """
  16.     def __init__(self, snr, p=0.9):
  17.         assert isinstance(snr, float) and (isinstance(p, float))
  18.         self.snr = snr
  19.         self.p = p
  21.     def __call__(self, img):
  22.         """
  23.         Args:
  24.             img (PIL Image): PIL Image
  25.         Returns:
  26.             PIL Image: PIL image.
  27.         """
  28.         if random.uniform(0, 1) < self.p:
  29.             img_ = np.array(img).copy()
  30.             h, w = img_.shape
  31.             signal_pct = self.snr
  32.             noise_pct = (1 - self.snr)
  33.             mask = np.random.choice((0, 1, 2), size=(h, w), p=[signal_pct, noise_pct/2., noise_pct/2.])
  35.             img_[mask == 1] = 255   # 盐噪声
  36.             img_[mask == 2] = 0     # 椒噪声
  37.             return Image.fromarray(img_.astype('uint8'))
  38.         else:
  39.             return img
  41. class Gaussian_noise(object):
  42.     """增加高斯噪声
  43.     此函数用将产生的高斯噪声加到图片上
  44.     传入:
  45.         img   :  原图
  46.         mean  :  均值
  47.         sigma :  标准差
  48.     返回:
  49.         gaussian_out : 噪声处理后的图片
  50.     """
  51.     def __init__(self, mean, sigma):
  53.         self.mean = mean
  54.         self.sigma = sigma
  56.     def __call__(self, img):
  57.         """
  58.         Args:
  59.             img (PIL Image): PIL Image
  60.         Returns:
  61.             PIL Image: PIL image.
  62.         """
  63.         # 将图片灰度标准化
  64.         img_ = np.array(img).copy()
  65.         img_ = img_ / 255.0
  66.         # 产生高斯 noise
  67.         noise = np.random.normal(self.mean, self.sigma, img_.shape)
  68.         # 将噪声和图片叠加
  69.         gaussian_out = img_ + noise
  70.         # 将超过 1 的置 1，低于 0 的置 0
  71.         gaussian_out = np.clip(gaussian_out, 0, 1)
  72.         # 将图片灰度范围的恢复为 0-255
  73.         gaussian_out = np.uint8(gaussian_out*255)
  74.         # 将噪声范围搞为 0-255
  75.         # noise = np.uint8(noise*255)
  76.         return Image.fromarray(gaussian_out)
  78. train_datasets = torchvision.datasets.MNIST('./', train=True, download=True)
  79. test_datasets = torchvision.datasets.MNIST('./', train=False, download=True)
  81. print('训练集的数量', len(train_datasets))
  82. print('测试集的数量', len(test_datasets))
  84. train_loader = DataLoader(train_datasets, batch_size=100, shuffle=True)
  85. test_loader = DataLoader(test_datasets, batch_size=1, shuffle=False)
  87. transform=transforms.Compose([
  88.     transforms.ToPILImage(),
  89.     Gaussian_noise(0,0.1),
  90.     AddPepperNoise(0.9)
  91.     # transforms.ToTensor()
  92. ])
  94. print('训练集可视化')
  95. fig = plt.figure()
  96. for i in range(12):
  97.     plt.subplot(3, 4, i + 1)
  98.     img = train_datasets.train_data[i]
  99.     label = train_datasets.train_labels[i]
  100.     # noise = np.random.normal(0.1, 0.1, img.shape)
  101.     # img=transform(img)
  102.     plt.imshow(img, cmap='gray')
  103.     plt.title(label)
  104.     plt.xticks([])
  105.     plt.yticks([])
  106. plt.show()

噪声图像

原始图像

模型的搭建

  1. import torch
  2. from torch import nn
  4. class AE(nn.Module):
  5.     def __init__(self):
  6.         super(AE, self).__init__()
  8.         # [b, 784] => [b, 20]
  9.         self.encoder = nn.Sequential(
  10.             nn.Linear(784, 256),
  11.             nn.ReLU(),
  12.             nn.Linear(256, 64),
  13.             nn.ReLU(),
  14.             nn.Linear(64, 20),
  15.             nn.ReLU()
  16.         )
  18.         # [b, 20] => [b, 784]
  19.         self.decoder = nn.Sequential(
  20.             nn.Linear(20, 64),
  21.             nn.ReLU(),
  22.             nn.Linear(64, 256),
  23.             nn.ReLU(),
  24.             nn.Linear(256, 784),
  25.             nn.Sigmoid()
  26.         )
  28.     def forward(self, x):
  29.         """
  30.         :param x: [b, 1, 28, 28]
  31.         :return:
  32.         """
  33.         batchsz = x.size(0)
  34.         # flatten（打平）
  35.         x = x.view(batchsz, 784)
  36.         # encoder
  37.         x = self.encoder(x)
  38.         # decoder
  39.         x = self.decoder(x)
  40.         # reshape
  41.         x = x.view(batchsz, 1, 28, 28)
  43.         return x
  45. if __name__=='__main__':
  46.     model=AE()
  47.     input=torch.randn(1,28,28)
  48.     input=input.view(1,-1)
  49.     print('输入的维度',input.shape)
  50.     encoder_out=model.encoder(input)
  51.     print('编码器的输出',encoder_out.shape)
  52.     out=model.decoder(encoder_out)
  53.     print('解码器的输出',out.shape)

模型的训练

导入训练集训练的时候一定要将使用transforms将所有图像转换为tensor格式，这里的方法不同于tensorflow导入MNIST方法，如果不加transforms则图像的格式为列表类型，下面在训练的时候会报错。

在训练过程中添加噪声。分别添加了高斯噪声和椒盐噪声

  1. import torchvision
  2. from torch.utils.data import DataLoader
  3. import numpy as np
  4. import random,os
  5. import PIL.Image as Image
  6. import torchvision.transforms as transforms
  7. from torch import nn,optim
  8. import torch
  9. from models import AE
  10. from tqdm import tqdm
  12. train_datasets = torchvision.datasets.MNIST('./', train=True, download=True,transform=transforms.ToTensor())
  13. test_datasets = torchvision.datasets.MNIST('./', train=False, download=True,transform=transforms.ToTensor())
  15. print('训练集的数量', len(train_datasets))
  16. print('测试集的数量', len(test_datasets))
  18. train_loader = DataLoader(train_datasets, batch_size=100, shuffle=True)
  19. test_loader = DataLoader(test_datasets, batch_size=1, shuffle=False)
  21. #模型，优化器，损失函数
  22. device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
  23. model=AE().to(device)
  24. criteon = nn.MSELoss()
  25. optimizer = optim.Adam(model.parameters(), lr=1e-3)
  27. ##导入预训练模型
  28. if os.path.exists('./model.pth') :
  29.     # 如果存在已保存的权重，则加载
  30.     checkpoint = torch.load('model.pth',map_location=lambda storage,loc:storage)
  31.     model.load_state_dict(checkpoint['model_state_dict'])
  32.     optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
  33.     initepoch = checkpoint['epoch']
  34.     loss = checkpoint['loss']
  35. else:
  36.     initepoch=0
  38. #开始训练
  39. for epoch in range(initepoch, 50):
  40.     with tqdm(total=(len(train_datasets)-len(train_datasets)), ncols=80) as t:
  41.         t.set_description('epoch: {}/{}'.format(epoch, 50))
  43.         running_loss = 0.0
  44.         for i, data in enumerate(train_loader, 0):
  45.             # get the inputs
  46.             true_input, _ = data
  47.             #生成均值为0，方差为0.1的高斯分布
  48.             gaussian_noise=torch.normal(mean=0,std=0.1,size=true_input.shape)
  49.             image_noise=true_input+gaussian_noise
  50.             noise_tensor = torch.rand(size=true_input.shape)
  51.             #添加椒盐噪声
  52.             image_noise[noise_tensor<0.1]=0 #椒噪声
  53.             image_noise[noise_tensor > (1-0.1)] = 1 #盐噪声
  54.             #限制像素的范围在0-1之间
  55.             image_noise=torch.clamp(image_noise,min=0,max=1)
  56.             optimizer.zero_grad()
  58.             outputs = model(image_noise)
  59.             loss = criteon(outputs, true_input)
  60.             loss.backward()
  62.             optimizer.step()
  64.             running_loss += loss.item()
  65.             t.set_postfix(trainloss='{:.6f}'.format(running_loss/len(train_loader)))
  66.             t.update(len(true_input))
  68.     torch.save({'epoch': epoch,
  69.                 'model_state_dict': model.state_dict(),
  70.                 'optimizer_state_dict': optimizer.state_dict(),
  71.                 'loss': running_loss/len(train_loader)
  72.                 }, 'model.pth')

模型的测试

在导入模型的时候经常发生上面的错误。模型在导入参数的时候不需要赋值操作。如果保存的方法是torch.load(model,'model.pth'),也就是直接保存模型的所有（包括模型的结构），在导入模型参数的时候可以使用model=torch.load('./model.pth')

  1. import numpy as np
  2. import torchvision
  3. import matplotlib.pyplot as plt
  4. from torch.utils.data import DataLoader
  5. import torch
  6. import torchvision.transforms as transforms
  7. from models import AE
  8. from data import AddPepperNoise,Gaussian_noise
  10. test_datasets = torchvision.datasets.MNIST('./', train=False, download=True)
  12. print('测试集的数量', len(test_datasets))
  14. test_loader = DataLoader(test_datasets, batch_size=1, shuffle=False)
  16. transform=transforms.Compose([
  17.     transforms.ToPILImage(),
  18.     Gaussian_noise(0,0.2),
  19.     AddPepperNoise(0.9),
  20.     transforms.ToTensor()
  21. ])
  22. model=AE()
  23. hh=torch.load('./model.pth',map_location=lambda storage,loc:storage)
  24. model.load_state_dict(hh['model_state_dict'])
  25. #错误写法
  26. # model=model.load_state_dict(hh['model_state_dict'])
  28. fig = plt.figure()
  29. for i in range(12):
  30.     plt.subplot(3, 4, i + 1)
  31.     img = test_datasets.train_data[i]
  32.     label = test_datasets.test_labels[i]
  33.     img_noise=transform(img)
  34.     out=model(img_noise)
  35.     out=out.squeeze()
  36.     out=transforms.ToPILImage()(out)
  37.     #原始图像，噪声图像，去噪图像
  38.     plt.imshow(np.hstack((np.array(img),np.array(transforms.ToPILImage()(img_noise)),np.array(out))), cmap='gray')
  39.     plt.title(label)
  40.     plt.xticks([])
  41.     plt.yticks([])
  42. plt.show()

生成随机数看看解码器能解码出什么

生成标准正太分布

  1. import matplotlib.pyplot as plt
  2. import torch
  3. import torchvision.transforms as transforms
  4. from models import AE
  6. model=AE()
  7. model.load_state_dict(torch.load('./model.pth',map_location=lambda storage,loc:storage)['model_state_dict'])
  9. fig = plt.figure()
  10. for i in range(12):
  11.     plt.subplot(3, 4, i + 1)
  12.     input=torch.randn(1,20)
  13.     out=model.decoder(input)
  14.     out=out.view(28,28)
  15.     out=transforms.ToPILImage()(out)
  16.     plt.imshow(out, cmap='gray')
  17.     plt.xticks([])
  18.     plt.yticks([])
  19. plt.show()

生成0-1之间的均匀分布

  1. import matplotlib.pyplot as plt
  2. import torch
  3. import torchvision.transforms as transforms
  4. from models import AE
  6. model=AE()
  7. model.load_state_dict(torch.load('./model.pth',map_location=lambda storage,loc:storage)['model_state_dict'])
  9. fig = plt.figure()
  10. for i in range(12):
  11.     plt.subplot(3, 4, i + 1)
  12.     input=torch.rand(1,20)
  13.     out=model.decoder(input)
  14.     out=out.view(28,28)
  15.     out=transforms.ToPILImage()(out)
  16.     plt.imshow(out, cmap='gray')
  17.     plt.xticks([])
  18.     plt.yticks([])
  19. plt.show()

可以看到随机生成的数据用解码器解码得到的数据都很乱。接下来，看看编码器编码后的数据服从什么分布。

看看编码器编码的输出服从什么分布

  1. import numpy as np
  2. import torchvision
  3. import matplotlib.pyplot as plt
  4. from torch.utils.data import DataLoader
  5. import torch
  6. import torchvision.transforms as transforms
  7. from models import AE
  8. from data import AddPepperNoise,Gaussian_noise
  10. test_datasets = torchvision.datasets.MNIST('./', train=False, download=True)
  12. print('测试集的数量', len(test_datasets))
  14. test_loader = DataLoader(test_datasets, batch_size=1, shuffle=False)
  16. transform=transforms.Compose([
  17.     transforms.ToPILImage(),
  18.     Gaussian_noise(0,0.2),
  19.     AddPepperNoise(0.9),
  20.     transforms.ToTensor()
  21. ])
  22. model=AE()
  23. hh=torch.load('./model.pth',map_location=lambda storage,loc:storage)
  24. model.load_state_dict(hh['model_state_dict'])
  25. #错误写法
  26. # model=model.load_state_dict(hh['model_state_dict'])
  28. fig = plt.figure()
  29. for i in range(1):
  30.     plt.subplot(1, 1, i + 1)
  31.     img = test_datasets.test_data[i]
  32.     label = test_datasets.test_labels[i]
  33.     img_noise=transform(img)
  34.     img_noise=img_noise.view(1,-1)
  35.     out=model.encoder(img_noise)
  36.     print('encoder的输出',out)
  37.     #正太分布检验
  38.     import scipy.stats as stats
  39.     print(stats.shapiro(out.detach().numpy()))
  40.     plt.imshow(img, cmap='gray')
  41.     plt.title(label)
  42.     plt.xticks([])
  43.     plt.yticks([])
  44. plt.show()
  46. print('均值',torch.mean(out))
  47. print('方差',torch.var(out))

可以看到一张图片7是服从均值为2.5，方差为8.55的正太分布的。

然后生成一些类似的分布看看效果。

  1. import matplotlib.pyplot as plt
  2. import torch
  3. import torchvision.transforms as transforms
  4. from models import AE
  6. model=AE()
  7. model.load_state_dict(torch.load('./model.pth',map_location=lambda storage,loc:storage)['model_state_dict'])
  9. fig = plt.figure()
  10. for i in range(12):
  11.     plt.subplot(3, 4, i + 1)
  12.     input=torch.normal(mean=2.5928,std=8.5510,size=(1,20))
  13.     out=model.decoder(input)
  14.     out=out.view(28,28)
  15.     out=transforms.ToPILImage()(out)
  16.     plt.imshow(out, cmap='gray')
  17.     plt.xticks([])
  18.     plt.yticks([])
  19. plt.show()

其实效果挺差的，可能是因为一张图片的分布并不能代表所有吧。

标签： pytorch 深度学习 人工智能
本文转载自: https://blog.csdn.net/qq_40107571/article/details/128357520
版权归原作者 南妮儿 所有， 如有侵权，请联系我们删除。
登录后发布评论

“pytorch 自编码器实现图像的降噪”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？