前言.

关于 $\rm GAN$ 的基础知识以及 $\rm DCGAN$ 的特点，可以阅读《生成对抗网络》，这里将深度卷积生成对抗网络的特点摘录如下：
取消所有 $\rm pooling$ 层， $\rm Generator$ 网络中使用转置卷积进行上采样， $\rm Discriminator$ 网络中用加入 $\rm stride$ 的卷积代替 $\rm pooling.$
在 $\rm Discriminator$ 和 $\rm Generator$ 中均使用 $\rm Batch~Normalization.$
去掉全连接层，即线性层，使网络变为全卷积网络。
$\rm Generator$ 网络中使用 $\rm ReLU$ 作为激活函数，最后一层使用 $\rm Tanh.$
$\rm Discriminator$ 网络中使用 $\rm LeakyReLU$ 作为激活函数。

判别网络.

$\rm DCGAN$ 中判别网络 $\rm Discriminator$ 与普通的卷积网络区别只在于使用带步长的卷积层来替换池化层，并且激活函数使用了 $\rm LeakyReLU$ ，该激活函数针对 $\rm ReLU$ 在输入为负时反向传播梯度为 $0$ 进行修改，会对判别网络的效率有所改善。
$\rm PyTorch$ 实现的 $\rm DCGAN.Discriminator$ 代码如下所示：

# In[Discriminator]
class _DNet(nn.Module):
    def __init__(self):
        super().__init__()
        
        # Input image size = [64,3,64,64]
        self.network = nn.Sequential(
            nn.Conv2d(3,64,4,2,1,bias = False),
            nn.LeakyReLU(0.2,True),
            # Image size = [64,64,32,32]
            
            nn.Conv2d(64,64*2,4,2,1,bias = False),
            nn.BatchNorm2d(64*2),
            nn.LeakyReLU(0.2,True),
            # Image size = [64,128,16,16]
            
            nn.Conv2d(64*2,64*4,4,2,1,bias = False),
            nn.BatchNorm2d(64*4),
            nn.LeakyReLU(0.2,True),
            # Image size = [64,256,8,8]
            
            nn.Conv2d(64*4,64*8,4,2,1,bias = False),
            nn.BatchNorm2d(64*8),
            nn.LeakyReLU(0.2,True),
            # Image size = [64,512,4,4]
            
            nn.Conv2d(64*8,1,4,1,0,bias = False),
            nn.Sigmoid())
            # Image size = [64,1,1,1]
            
    def forward(self,inputs):
        output = self.network(inputs)
        output = output.view(-1,1).squeeze(1)
        return output

判别网络 $\rm Discriminator$ 对于批数据中的每个样本，其输出值都是一个标量，用于表示该样本是真实图片 $\rm true$ 抑或是生成图片 $\rm fake.$ 在本例中以 $1$ 表示真实图片， $0$ 表示生成图片。
我们的输入图片大小为 $3\times64\times64$ ，注意判别网络中的卷积核参数，其卷积核大小为 $4$ ，步长为 $2$ ，填充为 $1$ ，这是一种常见的卷积核，其输出图像的大小计算式如下： $\frac{H_{in}+2-4}{2}+1=\frac{H_{in}}{2}\tag{1}$
并且由于网络中添加了 $\rm Batch~Normalization$ 层，因此舍弃了卷积层偏置项 $\rm bias$ ，具体的原因可以参考《卷积层操作后是否需要附加偏置项 bias.》

生成网络.

需要明确，生成网络 $\rm Generator$ 接受一个随机向量来合成一张图片，在本例中使用的随机向量维度是 $100\times1\times1.$
$\rm PyTorch$ 实现的生成网络 $\rm DCGAN.Generator$ 代码如下所示：

# In[Generator]
class _GNet(nn.Module):
    def __init__(self):
        super().__init__()
        
        # Input image size = [64,100,1,1]
        self.network = nn.Sequential(
            nn.ConvTranspose2d(100,64*8,4,1,0,bias = False),
            nn.BatchNorm2d(64*8),
            nn.ReLU(True),
            # Image size = [64,64*8,4,4]
            
            nn.ConvTranspose2d(64*8,64*4,4,2,1,bias = False),
            nn.BatchNorm2d(64*4),
            nn.ReLU(True),
            # Image size = [64,64*4,8,8]
            
            nn.ConvTranspose2d(64*4,64*2,4,2,1,bias = False),
            nn.BatchNorm2d(64*2),
            nn.ReLU(True),
            # Image size = [64,64*2,16,16]
            
            nn.ConvTranspose2d(64*2,64,4,2,1,bias = False),
            nn.BatchNorm2d(64),
            nn.ReLU(True),
            # Image size = [64,64,32,32]
            
            nn.ConvTranspose2d(64,3,4,2,1,bias = False),
            nn.Tanh())
            # Image size = [64,3,64,64]
        
    def forward(self,inputs):
        output = self.network(inputs)
        return output

注意生成网络中使用了转置卷积 $\rm nn.ConvTranspose2d()$ 来进行上采样，最终网络的输出是大小为 $3\times64\times64$ 的张量，代表一张合成图片。

训练过程.

$\rm DCGAN$ 在完成了网络参数初始化后，首先从判别网络开始训练，分别用真实图片集和合成图片集对其进行训练，将误差加合起来进行反向传播。由于具体的分类问题实质是二分类问题，因此损失函数采用二分类交叉熵函数 $\rm nn.BCELoss$ .
我们将真实图片记为 $x$ ，输入判别网络后对应的结果为 $D (x)$ ；输入生成网络的随机向量记为 $z$ ，生成网络的输出结果为 $G (z)$ ，因此判别网络的判别结果为 $D [G (z)] .$
$\rm BCELoss$ 的损失值计算式如下： $l(\hat y,y)=-[y\cdot\log\hat y+(1-y)\cdot\log(1-\hat y)]\tag{2}$ 因此对判别网络而言，真实图片集的损失为： $l_1=-\log\big[D(x)\big]\tag{3.1}$ 合成图片集的损失为： $l_2=-\log\big[1-D[G(z)]\big]\tag{3.2}$ 将 $l_1,l_2$ 加合后就是判别网络最终需要优化的损失函数： $l_d=-\log\big[D(x)\big]-\log\big[1-D[G(z)]\big]\tag{4}$
而后训练生成网络，训练方式基于判别网络的反馈。即对于随机向量 $x$ ，将生成图片 $G (z)$ 传递给判别网络，得到判别结果 $D [G (z)]$ ，籍此来进行梯度反向传播训练生成网络。这里需要注意，对生成网络而言，合成图片的目的是欺骗判别网络，因此合成图片在生成网络中的标签值应为 $\rm true.$ 同样采样二分类交叉熵函数计算损失值，得到生成网络的损失为： $l_g=-\log\big[D[G(z)]\big]\tag{5}$
注意在该过程中，判定合成图片的真假会有判别网络参与，但这里我们必须固定判别网络的参数，只对生成网络进行训练。所以实际上训练生成网络的过程实际在训练生成-判别串接网络，只不过判别网络的参数不进行更新。
关于训练过程，还可以参看《大白话讲解 $\rm GAN$ 的训练机制》互相验证。

下面分步骤给出 $\rm DCGAN$ 训练阶段的代码，分别对应上面所说的训练过程。
首先是使用真实图片集对判别网络进行训练：

DNet.zero_grad()
r_sample = data[0]
batch_size = r_sample.size()[0]
        
if is_cuda:
	r_sample = r_sample.cuda()
            
inputs.resize_as_(r_sample).copy_(r_sample)
'''1 for real'''
labels.resize_(batch_size).fill_(1)
outputs = DNet(inputs)
r_DNetloss = loss(outputs,labels)
r_DNetloss.backward()
Dx = outputs.data.mean()

而后是使用合成图片集对判别网络进行训练，注意这里在训练判别网络时并不希望同时训练生成网络，因此需要切断梯度流。

noise = torch.FloatTensor(batch_size,100,1,1).normal_(0,1)
if is_cuda:
	noise = noise.cuda()
f_sample = GNet(noise)
'''0 for fake'''
labels = labels.fill_(0)
outputs = DNet(f_sample.detach())
f_DNetloss = loss(outputs,labels)
f_DNetloss.backward()
DGz1 = outputs.data.mean()
        
DNetLoss = r_DNetloss + f_DNetloss
opt_d.step()

我们注意到在 $\rm r\_DNetloss$ 和 $\rm f\_DNetloss$ 都反向传播后才调用了 $\rm opt\_d.step().$ 并且 $\rm f\_sample$ 在传入判别网络时进行了 $\rm detach()$ 操作。
最后是基于判别网络的反馈来训练生成网络：

GNet.zero_grad()
'''Fake sample is \real\ to generator net '''
labels = labels.fill_(1)
outputs = DNet(f_sample)
GNetLoss = loss(outputs,labels)
GNetLoss.backward()
DGz2 = outputs.data.mean()
        
opt_g.step()

DCGAN完整代码.

使用 $\rm CIFAR10$ 数据集进行训练，生成器最终生成的图片会和其中的图片十分类似。下面分别是真实图片和合成图片的展示：
合成图片中箭头所指已经十分像一只真正的🐱.
下面是本例中 $\rm DCGAN$ 的完整代码，推荐使用 $\rm Spyder$ 或 $\rm Notebook$ 进行体验，每个 $\rm In[~]$ 是一个 $\rm cell.$

# In[Import]
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.transforms as transforms
import torchvision.utils as vutils
import matplotlib.pyplot as plt
from torch.utils.data import DataLoader
from torchvision import datasets
from PIL import Image

# In[GPU]
if torch.cuda.is_available():
    print('GPU works.')
    is_cuda = True

# In[Transform]
img_size = 64
mean = [0.5,0.5,0.5]
std = [0.5,0.5,0.5]

trans = transforms.Compose([transforms.Resize(img_size),
                            transforms.ToTensor(),
                            transforms.Normalize(mean, std)])

# In[DataLoader]
ds = datasets.CIFAR10(root = 'data',download = True,
                      transform = trans)

loader = torch.utils.data.DataLoader(ds,batch_size = 64,
                                     shuffle = True)

# In[Discriminator]
class _DNet(nn.Module):
    def __init__(self):
        super().__init__()
        
        # Input image size = [64,3,64,64]
        self.network = nn.Sequential(
            nn.Conv2d(3,64,4,2,1,bias = False),
            nn.LeakyReLU(0.2,True),
            # Image size = [64,64,32,32]
            
            nn.Conv2d(64,64*2,4,2,1,bias = False),
            nn.BatchNorm2d(64*2),
            nn.LeakyReLU(0.2,True),
            # Image size = [64,128,16,16]
            
            nn.Conv2d(64*2,64*4,4,2,1,bias = False),
            nn.BatchNorm2d(64*4),
            nn.LeakyReLU(0.2,True),
            # Image size = [64,256,8,8]
            
            nn.Conv2d(64*4,64*8,4,2,1,bias = False),
            nn.BatchNorm2d(64*8),
            nn.LeakyReLU(0.2,True),
            # Image size = [64,512,4,4]
            
            nn.Conv2d(64*8,1,4,1,0,bias = False),
            nn.Sigmoid())
            # Image size = [64,1,1,1]
            
    def forward(self,inputs):
        output = self.network(inputs)
        output = output.view(-1,1).squeeze(1)
        return output

# In[Generator]
class _GNet(nn.Module):
    def __init__(self):
        super().__init__()
        
        # Input image size = [64,100,1,1]
        self.network = nn.Sequential(
            nn.ConvTranspose2d(100,64*8,4,1,0,bias = False),
            nn.BatchNorm2d(64*8),
            nn.ReLU(True),
            # Image size = [64,64*8,4,4]
            
            nn.ConvTranspose2d(64*8,64*4,4,2,1,bias = False),
            nn.BatchNorm2d(64*4),
            nn.ReLU(True),
            # Image size = [64,64*4,8,8]
            
            nn.ConvTranspose2d(64*4,64*2,4,2,1,bias = False),
            nn.BatchNorm2d(64*2),
            nn.ReLU(True),
            # Image size = [64,64*2,16,16]
            
            nn.ConvTranspose2d(64*2,64,4,2,1,bias = False),
            nn.BatchNorm2d(64),
            nn.ReLU(True),
            # Image size = [64,64,32,32]
            
            nn.ConvTranspose2d(64,3,4,2,1,bias = False),
            nn.Tanh())
            # Image size = [64,3,64,64]
        
    def forward(self,inputs):
        output = self.network(inputs)
        return output
    
# In[Weight]
def weight(model):
    cls_name = model.__class__.__name__
    
    if cls_name.find('Conv') != -1:
        model.weight.data.normal_(0.0,0.02)
    elif cls_name.find('BatchNorm') != -1:
        model.weight.data.normal_(0.0,0.02)
        model.bias.data.fill_(0)

# In[Model]
DNet = _DNet()
GNet = _GNet()

DNet.apply(weight)
GNet.apply(weight)

print(DNet)
print(GNet)

# In[Params]
loss = nn.BCELoss()
lr = 2e-4
betas = (0.5,0.999)
opt_d = optim.Adam(DNet.parameters(),lr,betas)
opt_g = optim.Adam(GNet.parameters(),lr,betas)

inputs = torch.FloatTensor(64,3,img_size,img_size)
labels = torch.FloatTensor(64)

noise = torch.FloatTensor(64,100,1,1)
fix_noise = torch.FloatTensor(64,100,1,1).normal_(0,1)

outpath = './output'

# In[To GPU]
if is_cuda:
    DNet = DNet.cuda()
    GNet = GNet.cuda()
    loss = loss.cuda()
    inputs,labels = inputs.cuda(),labels.cuda()
    noise,fix_noise = noise.cuda(),fix_noise.cuda()

# In[Fit]
epochs = 10
DNetLosses = []
GNetLosses = []

for epoch in range(epochs):
    for batch,data in enumerate(loader,start = 0):
        '''Train DNet'''
        # Real samples.
        DNet.zero_grad()
        r_sample = data[0]
        batch_size = r_sample.size()[0]
        
        if is_cuda:
            r_sample = r_sample.cuda()
            
        inputs.resize_as_(r_sample).copy_(r_sample)
        '''1 for real'''
        labels.resize_(batch_size).fill_(1)
        outputs = DNet(inputs)
        r_DNetloss = loss(outputs,labels)
        r_DNetloss.backward()
        Dx = outputs.data.mean()
        
        # Fake samples.
        noise = torch.FloatTensor(batch_size,100,1,1).normal_(0,1)
        if is_cuda:
            noise = noise.cuda()
        f_sample = GNet(noise)
        '''0 for fake'''
        labels = labels.fill_(0)
        outputs = DNet(f_sample.detach())
        f_DNetloss = loss(outputs,labels)
        f_DNetloss.backward()
        DGz1 = outputs.data.mean()
        
        DNetLoss = r_DNetloss + f_DNetloss
        opt_d.step()

        '''Train GNet'''
        GNet.zero_grad()
        '''Fake sample is \real\ to generator net '''
        labels = labels.fill_(1)
        outputs = DNet(f_sample)
        GNetLoss = loss(outputs,labels)
        GNetLoss.backward()
        DGz2 = outputs.data.mean()
        
        opt_g.step()

        if batch % 100 == 0:
            print('[%d/%d][%d/%d]'%(epoch,epochs,batch,len(loader)))
            print('DNet-Loss:%.4f'%(DNetLoss.data))
            print('GNet-Loss:%.4f'%(GNetLoss.data))
            print('D(x):%.4f'%(Dx))
            print('D[G(z)]:%.4f/%.4f'%(DGz1,DGz2))
            print('*'*30)
            
            vutils.save_image(r_sample,
                              '%s\\real_sample.png'%outpath,
                              normalize= True)
            f_sample = GNet(fix_noise)
            vutils.save_image(f_sample,
                              '%s\\fake_sample_%03d.png'%(outpath,epoch),
                              normalize= True)
    DNetLosses.append(DNetLoss.detach().cpu().numpy())
    GNetLosses.append(GNetLoss.detach().cpu().numpy())

# In[Plot loss]
plt.plot(range(1,len(DNetLosses)+1),
         DNetLosses,'b',
         label = 'GNet Loss')
plt.plot(range(1,len(GNetLosses)+1),
         GNetLosses,'r',
         label = 'DNet Loss')
plt.legend()