02-DCGAN

　　2016年， Alec Radford 等发表的论文《深度卷积生成对抗网络》（简称DCGAN，论文网址：https://arxiv.org/abs/1511.06434）中，开创性地将卷积神经网络应用到生成对抗网络的模型算法设计当中，替代了全链接层，提高了图片场景里训练的稳定性。

　　DCGAN这篇论文展示了卷积层如何与GAN一起使用，并为此提供了一系列架构指南。这篇论文还讨论了 GAN 特征的可视化、潜在空间插值、利用判别器特征来训练分类器、评估结果等问题。在研究GAN过程中，推荐仔细阅读此论文 .

　　<<Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks>>DCGAN论文中对卷积神经网络的结构做了一些改变，以提高样本的质量和收敛的速度.

DCGAN的定义：

　　DCGAN就是将CNN和原始的GAN结合到了一起，生成模型和判别模型都运用了深度卷积神经网络的生成对抗网络。DCGAN将GAN与CNN相结合，奠定之后几乎所有GAN的基本网络架构。 DCGAN极大地提升了原始GAN训练的稳定性以及生成结果质量。

DCGAN的改进：

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

　DCGAN的生成器和判别器都舍弃了CNN的池化层，判别器保留CNN的整体架构，生成器则是将卷积层替换成了反卷积层（ConvTranspose2d）；
　在判别器和生成器中使用了Batch Normalization（BN）层，这有助于处理初始化不良导致的训练问题，加速模型训练，提升了训练的稳定性（要注意，在生成器的输出层和判别器的输入层不使用BN层）；
　在生成器中除输出层使用Tanh()激活函数，其余层全部使用ReLU激活函数；在判别器中，除输出层外所有层都使用LeakyReLU激活函数，防止梯度稀疏。这一点我们已在基础GAN中使用；
　在生成器中除输出层使用Tanh()激活函数，其余层全部使用ReLU激活函数；在判别器中，除输出层外所有层都使用LeakyReLU激活函数，防止梯度稀疏。这一点我们已在基础GAN中使。

DCGAN的设计：

DCGAN的设计技巧：

取消所有pooling层：G网络中使用转置卷积（transposed convolutional layer）进行上采样， D网络中用加入stride的卷积代替pooling。
去掉FC层，使网络变为全卷积网络；

G网络中使用ReLU作为激活函数，最后一层使用tanh
D网络中使用LeakyReLU作为激活函数

DCGAN的代码（Pytorch实现）

  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
  9 
 10 import time
 11 
 12 transform = transforms.Compose([
 13     transforms.ToTensor(),
 14     transforms.Normalize(mean=0.5, std=0.5)
 15 ])
 16 
 17 train_ds = torchvision.datasets.MNIST('data/',
 18                                       train=True,
 19                                       transform=transform,
 20                                       download=True)
 21 
 22 train_dl = torch.utils.data.DataLoader(train_ds, batch_size=64, shuffle=True)
 23 
 24 #定义生成器
 25 class Generator(nn.Module):
 26     def __init__(self):
 27         super(Generator, self).__init__()
 28         self.linear1 = nn.Linear(100, 7*7*256)
 29         self.bn1 = nn.BatchNorm1d(7*7*256)
 30         self.deconv1 = nn.ConvTranspose2d(256, 128, kernel_size=(3, 3), padding=1)
 31         self.bn2 = nn.BatchNorm2d(128)
 32         self.deconv2 = nn.ConvTranspose2d(128, 64, kernel_size=(4, 4), stride=2, padding=1)
 33         self.bn3 = nn.BatchNorm2d(64)
 34         self.deconv3 = nn.ConvTranspose2d(64, 1, kernel_size=(4, 4), stride=2, padding=1)
 35             
 36     def forward(self, x):
 37         
 38         x = F.relu(self.linear1(x))  # 64, 100 --> 64, 7*7*256
 39         x = self.bn1(x)              # 64, 7*7*256  --> 64, 7*7*256 
 40         x = x.view(-1, 256, 7, 7)    # 64, 7*7*256  --> 64, 256, 7*7
 41         x = F.relu(self.deconv1(x))  # 64, 256, 7*7  --> 64, 128, 7*7
 42         x = self.bn2(x)              # 64, 128, 7*7  --> 64, 128, 7*7
 43         x = F.relu(self.deconv2(x))  # 64, 128, 7*7  --> 64, 64, 14*14
 44         x = self.bn3(x)              #  64, 64, 14*14  --> 64, 64, 14*14
 45         x = torch.tanh(self.deconv3(x)) # 64, 64, 14*14  --> 64, 1, 28*28
 46         return x
 47 
 48 print(Generator)
 49 
 50 # 定义判别器
 51 class Discriminator(nn.Module):
 52     def __init__(self):
 53         super(Discriminator, self).__init__()
 54         
 55         self.conv1 = nn.Conv2d(1, 64, 3, 2)
 56         self.conv2 = nn.Conv2d(64, 128, 3, 2)
 57         self.bn = nn.BatchNorm2d(128)
 58         self.fc = nn.Linear(128*6*6, 1)
 59 
 60     def forward(self, x):
 61         # 判别器的损失加入了dropout，是为了防止判别器学习过强，导致生成器学习过弱，无法形成对抗学习
 62         x = F.dropout2d(F.leaky_relu(self.conv1(x)), p=0.3)
 63         x = F.dropout2d(F.leaky_relu(self.conv2(x)), p=0.3)
 64         x = self.bn(x)
 65         x = x.view(-1, 128*6*6)
 66         x = torch.sigmoid(self.fc(x))
 67         return x
 68     
 69 device = "cuda" if torch.cuda.is_available() else "cpu"
 70 #device = "cpu"
 71 gen = Generator().to(device)
 72 dis = Discriminator().to(device)
 73 
 74 loss_fn = torch.nn.BCELoss()  # 损失函数
 75 d_optimizer = torch.optim.Adam(dis.parameters(), lr=1e-5)
 76 g_optimizer = torch.optim.Adam(gen.parameters(), lr=1e-4)
 77 
 78 def generate_and_save_images(model, epoch, test_input):
 79     predictions = np.squeeze(model(test_input).cpu().numpy())
 80     fig = plt.figure(figsize=(4, 4))
 81     for i in range(predictions.shape[0]):
 82         plt.subplot(4, 4, i+1)
 83         plt.imshow((predictions[i] + 1)/2, cmap='gray')
 84         plt.axis('off')
 85     plt.savefig('./DCGAN_Image/image_at_epoch_{:04d}.png'.format(epoch))
 86     plt.show()
 87     plt.close()
 88 
 89 # 绘制loss函数
 90 def D_G_loss_plot(D_loss, G_loss, epotchs):
 91     
 92     fig = plt.figure(figsize=(4, 4))
 93     
 94     plt.plot(epotchs, D_loss, label='D_loss')
 95     plt.plot(epotchs, G_loss, label='G_loss')
 96     plt.legend()
 97     
 98     plt.title("D_G_Loss")
 99     plt.savefig('./DCGAN_Image/loss_at_epoch_{:04d}.png'.format(epotchs[len(epotchs)-1]))    
100     plt.close()
101     
102 test_input = torch.randn(16, 100, device=device)
103 
104 D_loss = []
105 G_loss = []
106 epochs = []
107 
108 #开始训练
109 for epoch in range(1000):
110     
111     epoch_start = time.time()
112     
113     D_epoch_loss=0
114     G_epoch_loss=0
115     count = len(train_dl.dataset)
116     for step, (img, _) in enumerate(train_dl):
117         img = img.to(device)
118         size=img.shape[0]
119         random_seed = torch.randn(size, 100, device=device) # 64*100
120         
121         d_optimizer.zero_grad()
122         real_output = dis(img)
123         d_real_loss = loss_fn(real_output, torch.ones_like(real_output, device=device))
124         d_real_loss.backward()
125         
126         generated_img = gen(random_seed)
127         fake_output = dis(generated_img.detach())
128         d_fake_loss = loss_fn(fake_output, torch.zeros_like(fake_output, device=device))
129         d_fake_loss.backward()
130         
131         disc_loss = d_real_loss + d_fake_loss
132         d_optimizer.step()
133         
134         g_optimizer.zero_grad()
135         fake_output = dis(generated_img)
136         gen_loss = loss_fn(fake_output, torch.ones_like(fake_output, device=device))
137         gen_loss.backward()
138         g_optimizer.step()
139         
140         with torch.no_grad():
141             D_epoch_loss += disc_loss.item()
142             G_epoch_loss += gen_loss.item()
143             
144     epoch_finish = time.time()
145     # print("Time cost for every epoch: {:2f}s.".format(epoch_finish-epoch_start))
146             
147     with torch.no_grad():        
148         D_epoch_loss /= count
149         G_epoch_loss /= count
150         D_loss.append(D_epoch_loss)
151         G_loss.append(G_epoch_loss)
152         epochs.append(epoch)
153         
154         print('Epoch: %d, D_loss: %.6f, G_loss: %.6f, Time: %.3fs' %(epoch, D_epoch_loss, G_epoch_loss, epoch_finish-epoch_start))
155         
156         generate_and_save_images(gen, epoch, test_input)
157         
158 D_G_loss_plot(D_loss, G_loss, epochs)