devbox
很楠不爱3
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Pytorch实例----DCGAN图像生成_dcgan kernel 5*5 stride3

作者：很楠不爱3 | 2024-06-13 06:27:05

赞

踩

dcgan kernel 5*5 stride3

背景：

       深度学习对数据量的需求明显高于传统机器学习方法，当真实的数据量较少或难以满足实际网络收敛情况下，需用通过数据增强方法生成更多可用于训练的更多图片，数据增强方法通过对图像进行随机剪裁，翻转等变换，提升图像输入的丰富度，但数据增强本质上是在原图上做“线性变化”，无法产生原图中没有的图像。在这种条件下，GAN（Generative Adversarial Networks ）能够在有限数据条件下生成更加丰富的数据资源，提升网络训练的有效性。

DCGAN：使用卷积神经网络替代GAN 中的多层感知机（MLP）并对网络做微调处理，显著提升了图像生成的质量。

论文链接：Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks

DCGAN设计技巧

  1. 所有的pooling层使用步幅卷积(判别网络)和微步幅度卷积(生成网络)进行替换；
  2. 在生成网络和判别网络上使用批处理规范化；
  3. 对于更深的架构移除全连接隐藏层；
  4. 在生成网络的所有层上使用RelU激活函数，除了输出层使用Tanh激活函数；
  5. 在判别网络的所有层上使用LeakyReLU激活函数；

基于Pytorch的DCGAN数据增强方法：

生成器（Generator）： 

  1. class NetG(nn.Module):
  2.     def __init__(self, ngf, nz):
  3.         super(NetG, self).__init__()
  4.         # layer1输入的是一个100x1x1的随机噪声, 输出尺寸(ngf*8)x4x4
  5.         self.layer1 = nn.Sequential(
  6.             nn.ConvTranspose2d(nz, ngf * 8, kernel_size=4, stride=1, padding=0, bias=False),
  7.             nn.BatchNorm2d(ngf * 8),
  8.             nn.ReLU(inplace=True)
  9.         )
  10.         # layer2输出尺寸(ngf*4)x8x8
  11.         self.layer2 = nn.Sequential(
  12.             nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=False),
  13.             nn.BatchNorm2d(ngf * 4),
  14.             nn.ReLU(inplace=True)
  15.         )
  16.         # layer3输出尺寸(ngf*2)x16x16
  17.         self.layer3 = nn.Sequential(
  18.             nn.ConvTranspose2d(ngf * 4, ngf * 2, 4, 2, 1, bias=False),
  19.             nn.BatchNorm2d(ngf * 2),
  20.             nn.ReLU(inplace=True)
  21.         )
  22.         # layer4输出尺寸(ngf)x32x32
  23.         self.layer4 = nn.Sequential(
  24.             nn.ConvTranspose2d(ngf * 2, ngf, 4, 2, 1, bias=False),
  25.             nn.BatchNorm2d(ngf),
  26.             nn.ReLU(inplace=True)
  27.         )
  28.         # layer5输出尺寸 3x96x96
  29.         self.layer5 = nn.Sequential(
  30.             nn.ConvTranspose2d(ngf, 3, 5, 3, 1, bias=False),
  31.             nn.Tanh()
  32.         )
  33.  
  34.     # 定义NetG的前向传播
  35.     def forward(self, x):
  36.         out = self.layer1(x)
  37.         out = self.layer2(out)
  38.         out = self.layer3(out)
  39.         out = self.layer4(out)
  40.         out = self.layer5(out)
  41.         return out

 判别器（Discriminator）：（生成器的逆过程）

  1. # 定义鉴别器网络D
  2. class NetD(nn.Module):
  3.     def __init__(self, ndf):
  4.         super(NetD, self).__init__()
  5.         # layer1 输入 3 x 96 x 96, 输出 (ndf) x 32 x 32
  6.         self.layer1 = nn.Sequential(
  7.             nn.Conv2d(3, ndf, kernel_size=5, stride=3, padding=1, bias=False),
  8.             nn.BatchNorm2d(ndf),
  9.             nn.LeakyReLU(0.2, inplace=True)
  10.         )
  11.         # layer2 输出 (ndf*2) x 16 x 16
  12.         self.layer2 = nn.Sequential(
  13.             nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False),
  14.             nn.BatchNorm2d(ndf * 2),
  15.             nn.LeakyReLU(0.2, inplace=True)
  16.         )
  17.         # layer3 输出 (ndf*4) x 8 x 8
  18.         self.layer3 = nn.Sequential(
  19.             nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False),
  20.             nn.BatchNorm2d(ndf * 4),
  21.             nn.LeakyReLU(0.2, inplace=True)
  22.         )
  23.         # layer4 输出 (ndf*8) x 4 x 4
  24.         self.layer4 = nn.Sequential(
  25.             nn.Conv2d(ndf * 4, ndf * 8, 4, 2, 1, bias=False),
  26.             nn.BatchNorm2d(ndf * 8),
  27.             nn.LeakyReLU(0.2, inplace=True)
  28.         )
  29.         # layer5 输出一个数(概率)
  30.         self.layer5 = nn.Sequential(
  31.             nn.Conv2d(ndf * 8, 1, 4, 1, 0, bias=False),
  32.             nn.Sigmoid()
  33.         )
  34.  
  35.     # 定义NetD的前向传播
  36.     def forward(self,x):
  37.         out = self.layer1(x)
  38.         out = self.layer2(out)
  39.         out = self.layer3(out)
  40.         out = self.layer4(out)
  41.         out = self.layer5(out)
  42.         return out

损失函数（Loss function）：

  1. criterion = nn.BCELoss()
  2. optimizerG = torch.optim.Adam(netG.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999))
  3. optimizerD = torch.optim.Adam(netD.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999))
  4. #每次训练中
  5. for epoch in range(1, opt.epoch + 1):
  6.     for i, (imgs,_) in enumerate(dataloader):
  7.         # 固定生成器G，训练鉴别器D
  8.         optimizerD.zero_grad()
  9.         ## 让D尽可能的把真图片判别为1
  10.         imgs=imgs.to(device)
  11.         output = netD(imgs)
  12.         label.data.fill_(real_label)
  13.         label=label.to(device)
  14.         #判别图像和标签的loss
  15.         errD_real = criterion(output, label)
  16.         errD_real.backward()
  17.         ## 让D尽可能把假图片判别为0
  18.         label.data.fill_(fake_label)
  19.         noise = torch.randn(opt.batchSize, opt.nz, 1, 1)
  20.         noise=noise.to(device)
  21.         fake = netG(noise)  # 生成假图
  22.         output = netD(fake.detach()) #避免梯度传到G，因为G不用更新
  23.         errD_fake = criterion(output, label)
  24.         errD_fake.backward()
  25.         errD = errD_fake + errD_real
  26.         optimizerD.step()
  27.  
  28.         # 固定鉴别器D，训练生成器G
  29.         optimizerG.zero_grad()
  30.         # 让D尽可能把G生成的假图判别为1
  31.         label.data.fill_(real_label)
  32.         label = label.to(device)
  33.         output = netD(fake)
  34.         errG = criterion(output, label)
  35.         errG.backward()
  36.         optimizerG.step()

 

模型: model.py

  1. import torch.nn as nn
  2. # 定义生成器网络G
  3. class NetG(nn.Module):
  4.     def __init__(self, ngf, nz):
  5.         super(NetG, self).__init__()
  6.         # layer1输入的是一个100x1x1的随机噪声, 输出尺寸(ngf*8)x4x4
  7.         self.layer1 = nn.Sequential(
  8.             nn.ConvTranspose2d(nz, ngf * 8, kernel_size=4, stride=1, padding=0, bias=False),
  9.             nn.BatchNorm2d(ngf * 8),
  10.             nn.ReLU(inplace=True)
  11.         )
  12.         # layer2输出尺寸(ngf*4)x8x8
  13.         self.layer2 = nn.Sequential(
  14.             nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=False),
  15.             nn.BatchNorm2d(ngf * 4),
  16.             nn.ReLU(inplace=True)
  17.         )
  18.         # layer3输出尺寸(ngf*2)x16x16
  19.         self.layer3 = nn.Sequential(
  20.             nn.ConvTranspose2d(ngf * 4, ngf * 2, 4, 2, 1, bias=False),
  21.             nn.BatchNorm2d(ngf * 2),
  22.             nn.ReLU(inplace=True)
  23.         )
  24.         # layer4输出尺寸(ngf)x32x32
  25.         self.layer4 = nn.Sequential(
  26.             nn.ConvTranspose2d(ngf * 2, ngf, 4, 2, 1, bias=False),
  27.             nn.BatchNorm2d(ngf),
  28.             nn.ReLU(inplace=True)
  29.         )
  30.         # layer5输出尺寸 3x96x96
  31.         self.layer5 = nn.Sequential(
  32.             nn.ConvTranspose2d(ngf, 3, 5, 3, 1, bias=False),
  33.             nn.Tanh()
  34.         )
  35.  
  36.     # 定义NetG的前向传播
  37.     def forward(self, x):
  38.         out = self.layer1(x)
  39.         out = self.layer2(out)
  40.         out = self.layer3(out)
  41.         out = self.layer4(out)
  42.         out = self.layer5(out)
  43.         return out
  44.  
  45.  
  46. # 定义鉴别器网络D
  47. class NetD(nn.Module):
  48.     def __init__(self, ndf):
  49.         super(NetD, self).__init__()
  50.         # layer1 输入 3 x 96 x 96, 输出 (ndf) x 32 x 32
  51.         self.layer1 = nn.Sequential(
  52.             nn.Conv2d(3, ndf, kernel_size=5, stride=3, padding=1, bias=False),
  53.             nn.BatchNorm2d(ndf),
  54.             nn.LeakyReLU(0.2, inplace=True)
  55.         )
  56.         # layer2 输出 (ndf*2) x 16 x 16
  57.         self.layer2 = nn.Sequential(
  58.             nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False),
  59.             nn.BatchNorm2d(ndf * 2),
  60.             nn.LeakyReLU(0.2, inplace=True)
  61.         )
  62.         # layer3 输出 (ndf*4) x 8 x 8
  63.         self.layer3 = nn.Sequential(
  64.             nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False),
  65.             nn.BatchNorm2d(ndf * 4),
  66.             nn.LeakyReLU(0.2, inplace=True)
  67.         )
  68.         # layer4 输出 (ndf*8) x 4 x 4
  69.         self.layer4 = nn.Sequential(
  70.             nn.Conv2d(ndf * 4, ndf * 8, 4, 2, 1, bias=False),
  71.             nn.BatchNorm2d(ndf * 8),
  72.             nn.LeakyReLU(0.2, inplace=True)
  73.         )
  74.         # layer5 输出一个数(概率)
  75.         self.layer5 = nn.Sequential(
  76.             nn.Conv2d(ndf * 8, 1, 4, 1, 0, bias=False),
  77.             nn.Sigmoid()
  78.         )
  79.  
  80.     # 定义NetD的前向传播
  81.     def forward(self,x):
  82.         out = self.layer1(x)
  83.         out = self.layer2(out)
  84.         out = self.layer3(out)
  85.         out = self.layer4(out)
  86.         out = self.layer5(out)
  87.         return out
  88.

训练：train.py

  1. import os
  2. import argparse
  3. import torch
  4. import torchvision
  5. import torchvision.utils as vutils
  6. from torchvision import transforms
  7. from torchvision.transforms import ToPILImage
  8. import torch.nn as nn
  9. from random import randint
  10. from model import NetD, NetG
  11. from PIL import Image
  12. from utils import tensor_to_PIL
  13.  
  14. parser = argparse.ArgumentParser()
  15. parser.add_argument('--batchSize', type=int, default=32)
  16. parser.add_argument('--imageSize', type=int, default=96)
  17. parser.add_argument('--nz', type=int, default=100, help='size of the latent z vector')
  18. parser.add_argument('--ngf', type=int, default=64)
  19. parser.add_argument('--ndf', type=int, default=64)
  20. parser.add_argument('--epoch', type=int, default=40000, help='number of epochs to train for')
  21. parser.add_argument('--lr', type=float, default=0.0002, help='learning rate, default=0.0002')
  22. parser.add_argument('--beta1', type=float, default=0.5, help='beta1 for adam. default=0.5')
  23. parser.add_argument('--data_path', default='data/', help='folder to train data')
  24. parser.add_argument('--outf', default='imgs/', help='folder to output images and model checkpoints')
  25. opt = parser.parse_args()
  26. # 定义是否使用GPU
  27. device = torch.device("cuda:3" if torch.cuda.is_available() else "cpu")
  28.  
  29. #图像读入与预处理
  30. transforms = torchvision.transforms.Compose([
  31.     torchvision.transforms.Scale(opt.imageSize),
  32.     torchvision.transforms.ToTensor(),
  33.     torchvision.transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), ])
  34.  
  35. dataset = torchvision.datasets.ImageFolder(opt.data_path, transform=transforms)
  36.  
  37. dataloader = torch.utils.data.DataLoader(
  38.     dataset=dataset,
  39.     batch_size=opt.batchSize,
  40.     shuffle=True,
  41.     drop_last=True,
  42. )
  43.  
  44. netG = NetG(opt.ngf, opt.nz).to(device)
  45. netD = NetD(opt.ndf).to(device)
  46.  
  47. criterion = nn.BCELoss()
  48. optimizerG = torch.optim.Adam(netG.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999))
  49. optimizerD = torch.optim.Adam(netD.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999))
  50.  
  51. label = torch.FloatTensor(opt.batchSize)
  52. real_label = 1
  53. fake_label = 0
  54. save_path = './imgs/epoch{:s}'
  55. j = 0
  56. for epoch in range(1, opt.epoch + 1):
  57.     for i, (imgs,_) in enumerate(dataloader):
  58.         # 固定生成器G，训练鉴别器D
  59.         optimizerD.zero_grad()
  60.         ## 让D尽可能的把真图片判别为1
  61.         imgs=imgs.to(device)
  62.         output = netD(imgs)
  63.         label.data.fill_(real_label)
  64.         label=label.to(device)
  65.         errD_real = criterion(output, label)
  66.         errD_real.backward()
  67.         ## 让D尽可能把假图片判别为0
  68.         label.data.fill_(fake_label)
  69.         noise = torch.randn(opt.batchSize, opt.nz, 1, 1)
  70.         noise=noise.to(device)
  71.         fake = netG(noise)  # 生成假图
  72.         output = netD(fake.detach()) #避免梯度传到G，因为G不用更新
  73.         errD_fake = criterion(output, label)
  74.         errD_fake.backward()
  75.         errD = errD_fake + errD_real
  76.         optimizerD.step()
  77.  
  78.         # 固定鉴别器D，训练生成器G
  79.         optimizerG.zero_grad()
  80.         # 让D尽可能把G生成的假图判别为1
  81.         label.data.fill_(real_label)
  82.         label = label.to(device)
  83.         output = netD(fake)
  84.         errG = criterion(output, label)
  85.         errG.backward()
  86.         optimizerG.step()
  87.  
  88.         print('[%d/%d][%d/%d] Loss_D: %.3f Loss_G %.3f'
  89.               % (epoch, opt.epoch, i, len(dataloader), errD.item(), errG.item()))
  90.     if epoch % 1000 == 0:
  91.         os.mkdir(save_path.format(str(j)))
  92.         for i in range(len(fake.data)):
  93.             #im = tensor_to_PIL(fake.data[i])
  94.             #im = im.convert('RGB')
  95.             #im.save(os.path.join(save_path.format(str(j)),str(i)+'.png'))
  96.             vutils.save_image(fake.data[i],
  97.                             '%s/%d.png' % (save_path.format(str(j)), i),
  98.                             normalize=True)
  99.         torch.save(netG.state_dict(), '%s/netG_%03d.pth' % (opt.outf, epoch))
  100.         torch.save(netD.state_dict(), '%s/netD_%03d.pth' % (opt.outf, epoch))
  101.         j = j+1

参考博客：Pytorch版DCGAN图像生成技术

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/711238
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号