0
0

DCGAN理论讲解及代码实现

DCGAN理论讲解

DCGAN也叫深度卷积生成对抗网络，DCGAN就是将CNN与GAN结合在一起，生成模型和判别模型都运用了深度卷积神经网络的生成对抗网络。

DCGAN将GAN与CNN相结合，奠定了之后几乎所有GAN的基本网络架构。DCGAN极大地提升了原始GAN训练的稳定性以及生成结果的质量

DCGAN主要是在网络架构上改进了原始的GAN，DCGAN的生成器与判别器都利用CNN架构替换了原始GAN的全连接网络，主要改进之处有如下几个方面，

DCGAN的改进：

（1）DCGAN的生成器和判别器都舍弃了CNN的池化层，判别器保留CNN的整体架构，生成器则是将卷积层替换成了反卷积层。

（2）在判别器和生成器中使用了BatchNormalization(BN)层，这里有助于处理初始化不良导致的训练问题，加速模型训练提升训练的稳定性。要注意，在生成器的输出层和判别器的输入层不使用BN层。

（3）在生成器中除输出层使用Tanh()激活函数，其余层全部使用Relu激活函数，在判别器中，除输出层外所有层都使用LeakyRelu激活函数，防止梯度稀疏

自己画的，凑合着看吧/(/ω＼)捂脸/

DCGAN的设计技巧

一，取消所有pooling层，G网络中使用转置卷积进行上采样，D网络中加入stride的卷积（为防止梯度稀疏）代替pooling

二，去掉FC层（全连接），使网络变成全卷积网络

三，G网络中使用Relu作为激活函数，最后一层用Tanh

四，D网络中使用LeakyRelu激活函数

五，在generator和discriminator上都使用batchnorm,解决初始化差的问题，帮助梯度传播到每一层，防止generator把所有的样本都收敛到同一点。直接将BN应用到所有层会导致样本震荡和模型不稳定，因此在生成器的输出层和判别器的输入层不使用BN层，可以防止这种现象。

六，使用Adam优化器

七，参数设置参考:LeakyRelu的斜率是0.2；Learing rate = 0.0002;batch size是128.

DCGAN纯代码实现

导入库

  1. import torch
  2. import torch.nn as nn
  3. import torch.nn.functional as F
  4. import torch.optim as optim #优化
  5. import numpy as np
  6. import matplotlib.pyplot as plt #绘图
  7. import torchvision #加载图片
  8. from torchvision import transforms #图片变换

导入数据和归一化

  1. #对数据做归一化（-1，1）
  2. transform=transforms.Compose([
  3.     #将shanpe为（H,W，C）的数组或img转为shape为（C,H,W）的tensor
  4.     transforms.ToTensor(), #转为张量并归一化到【0，1】；数据只是范围变了，并没有改变分布
  5.     transforms.Normalize(mean=0.5,std=0.5)#数据归一化处理，将数据整理到[-1,1]之间；可让数据呈正态分布
  6. ])
  7. #下载数据到指定的文件夹
  8. train_ds = torchvision.datasets.MNIST('data/',
  9.                                       train=True,
  10.                                      transform=transform,
  11.                                      download=True)
  12. #数据的输入部分
  13. train_dl=torch.utils.data.DataLoader(train_ds,batch_size=64,shuffle=True)

定义生成器

使用长度为100的noise作为输入，也可以使用torch.randn(batchsize,100,1,1）

  1. class Generator(nn.Module):
  2.     def __init__(self):
  3.         super(Generator,self).__init__()
  4.         self.linear1 = nn.Linear(100,256*7*7)
  5.         self.bn1=nn.BatchNorm1d(256*7*7)
  6.         self.deconv1 = nn.ConvTranspose2d(256,128,
  7.                                          kernel_size=(3,3),
  8.                                          stride=1,
  9.                                          padding=1)  #生成（128，7，7）的二维图像
  10.         self.bn2=nn.BatchNorm2d(128)
  11.         self.deconv2 = nn.ConvTranspose2d(128,64,
  12.                                          kernel_size=(4,4),
  13.                                          stride=2,
  14.                                          padding=1)  #生成（64，14，14）的二维图像
  15.         self.bn3=nn.BatchNorm2d(64)
  16.         self.deconv3 = nn.ConvTranspose2d(64,1,
  17.                                          kernel_size=(4,4),
  18.                                          stride=2,
  19.                                          padding=1)  #生成（1,28,28）的二维图像
  20.         
  21.     def forward(self,x):
  22.         x=F.relu(self.linear1(x))
  23.         x=self.bn1(x)
  24.         x=x.view(-1,256,7,7)
  25.         x=F.relu(self.deconv1(x))
  26.         x=self.bn2(x)
  27.         x=F.relu(self.deconv2(x))
  28.         x=self.bn3(x)
  29.         x=torch.tanh(self.deconv3(x))
  30.         return x

定义鉴别器

  1. class Discriminator(nn.Module):
  2.     def __init__(self):
  3.         super(Discriminator,self).__init__()
  4.         self.conv1 = nn.Conv2d(1,64,kernel_size=3,stride=2)
  5.         self.conv2 = nn.Conv2d(64,128,kernel_size=3,stride=2)
  6.         self.bn = nn.BatchNorm2d(128)
  7.         self.fc = nn.Linear(128*6*6,1)
  8.     def forward(self,x):
  9.         x= F.dropout2d(F.leaky_relu(self.conv1(x)))
  10.         x= F.dropout2d(F.leaky_relu(self.conv2(x)) )  #(batch,128,6,6)
  11.         x = self.bn(x)
  12.         x = x.view(-1,128*6*6) #展平
  13.         x = torch.sigmoid(self.fc(x))
  14.         return x

初始化和 模型训练

  1. #设备的配置
  2. device='cuda' if torch.cuda.is_available() else 'cpu'
  3. #初化生成器和判别器把他们放到相应的设备上
  4. gen = Generator().to(device)
  5. dis = Discriminator().to(device)
  1. #交叉熵损失函数
  2. loss_fn = torch.nn.BCELoss()
  3. #训练器的优化器
  4. d_optimizer = torch.optim.Adam(dis.parameters(),lr=1e-5)
  5. #训练生成器的优化器
  6. g_optimizer = torch.optim.Adam(dis.parameters(),lr=1e-4)
  1. def generate_and_save_images(model,epoch,test_input):
  2.     prediction = np.squeeze(model(test_input).detach().cpu().numpy())
  3.     fig = plt.figure(figsize=(4,4))
  4.     for i in range(prediction.shape[0]):
  5.         plt.subplot(4,4,i+1)
  6.         plt.imshow((prediction[i]+1)/2,cmap='gray')
  7.         plt.axis('off')
  8.     plt.savefig('image_at_epoch_{:04d}.png'.format(epoch))
  9.     plt.show()
  1. test_input = torch.randn(16,100 ,device=device) #16个长度为100的随机数
  1. D_loss = []
  2. G_loss = []
  3. #训练循环
  4. for epoch in range(30):
  5.     #初始化损失值
  6.     D_epoch_loss = 0
  7.     G_epoch_loss = 0
  8.     count = len(train_dl.dataset) #返回批次数
  9.     #对数据集进行迭代
  10.     for step,(img,_) in enumerate(train_dl):
  11.         img =img.to(device) #把数据放到设备上
  12.         size = img.shape[0] #img的第一位是size,获取批次的大小
  13.         random_seed = torch.randn(size,100,device=device)
  14.         
  15.         #判别器训练(真实图片的损失和生成图片的损失),损失的构建和优化
  16.         d_optimizer.zero_grad()#梯度归零
  17.         #判别器对于真实图片产生的损失
  18.         real_output = dis(img) #判别器输入真实的图片，real_output对真实图片的预测结果
  19.         d_real_loss = loss_fn(real_output,
  20.                               torch.ones_like(real_output,device=device)
  21.                               )
  22.         d_real_loss.backward()#计算梯度
  23.         
  24.         #在生成器上去计算生成器的损失，优化目标是判别器上的参数
  25.         generated_img = gen(random_seed) #得到生成的图片
  26.         #因为优化目标是判别器，所以对生成器上的优化目标进行截断
  27.         fake_output = dis(generated_img.detach()) #判别器输入生成的图片，fake_output对生成图片的预测;detach会截断梯度，梯度就不会再传递到gen模型中了
  28.         #判别器在生成图像上产生的损失
  29.         d_fake_loss = loss_fn(fake_output,
  30.                               torch.zeros_like(fake_output,device=device)
  31.                               )
  32.         d_fake_loss.backward()
  33.         #判别器损失
  34.         disc_loss = d_real_loss + d_fake_loss
  35.         #判别器优化
  36.         d_optimizer.step()
  37.         
  38.         
  39.         #生成器上损失的构建和优化
  40.         g_optimizer.zero_grad() #先将生成器上的梯度置零
  41.         fake_output = dis(generated_img)
  42.         gen_loss = loss_fn(fake_output,
  43.                               torch.ones_like(fake_output,device=device)
  44.                           )  #生成器损失
  45.         gen_loss.backward()
  46.         g_optimizer.step()
  47.         #累计每一个批次的loss
  48.         with torch.no_grad():
  49.             D_epoch_loss +=disc_loss
  50.             G_epoch_loss +=gen_loss
  51.     #求平均损失
  52.     with torch.no_grad():
  53.             D_epoch_loss /=count
  54.             G_epoch_loss /=count
  55.             D_loss.append(D_epoch_loss)
  56.             G_loss.append(G_epoch_loss)
  57.             generate_and_save_images(gen,epoch,test_input)
  58.             print('Epoch:',epoch)

运行结果

因篇幅有限，这里展示第一张和最后一张，这里我训练了30个epoch,有条件的可以多训练几次，训练越多效果越明显哦

希望我的文章能对你有所帮助。欢迎👍点赞 ，📝评论，🌟关注，⭐️收藏

  1.                                                                 ![](https://img-blog.csdnimg.cn/img_convert/b9ce23bc74d0dadd58f4078e134ce011.png)
标签： python 深度学习 pytorch
本文转载自: https://blog.csdn.net/weixin_51781852/article/details/125862628
版权归原作者 无咎.lsy 所有， 如有侵权，请联系我们删除。
登录后发布评论

“DCGAN理论讲解及代码实现”的评论:

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

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

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

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

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

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

Kafka学习笔记

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