感谢伯禹学习平台，本次学习将记录记录如何使用Pytorch高效实现网络，熟练掌握Pytorch的基础知识。记录不包含理论知识的细节展开。

DCGAN

DCGAN，实在GAN的基础上，使用卷积网络替换了原有的G和D中的全连接层，在图像生成上具有较好的表现。

GAN的结构示意图

初始准备

使用的输入图像的大小为（64，64，3）彩色的RGB图像。在DCGAN中比较重要的一点是，G生成的图像大小需要和真实图片大小保持一致性，确定G的输入大小后，可以设计G的基本结构。

Generator

G的作用是将一个噪声使用反卷积的操作，将其拉伸到真实数据大小，反卷积的参数是可以学习，所以与D的学习参数迭代，有了对抗。

import torch
import torchvision
import torch.nn as nn
# G_block，G与之前的网络设计思想一致，将复用的模块封装为块
class G_block(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size=4,strides=2, padding=1):
        super(G_block,self).__init__()
        self.conv2d_trans=nn.ConvTranspose2d(in_channels, out_channels, kernel_size=kernel_size,
                                             stride=strides, padding=padding, bias=False)
        # 前几层都是 trans_conv+bn+relu
        self.batch_norm=nn.BatchNorm2d(out_channels,0.8)
        self.activation=nn.ReLU()
    def forward(self,x):
        return self.activation(self.batch_norm(self.conv2d_trans(x)))

如上block中的反卷积输入大小可以参考如下计算公式，在输入的情况下输出大小为（32，32），也就增大一倍

在G的网络结构中，它每层的输出通道数时递减的，这点与D刚好有点对称的意思。

class net_G(nn.Module):
    def __init__(self,in_channels):
        super(net_G,self).__init__()

        n_G=64
        self.model=nn.Sequential(
            G_block(in_channels,n_G*8,strides=1,padding=0), 
            G_block(n_G*8,n_G*4),
            G_block(n_G*4,n_G*2),
            G_block(n_G*2,n_G),
            # 最后的输出卷积层使用的激活函数为Tanh，具有较好的泛化能力
            nn.ConvTranspose2d(
                n_G,3,kernel_size=4,stride=2,padding=1,bias=False
            ),
            nn.Tanh()
        )
    def forward(self,x):
        x=self.model(x)
        return x

在给定输入为（1，1）的噪声情况下，不难验证输出为（64，64）

Discriminator

D的作用是区分真假，生成对抗网络是一个无监督学习，其标签区分只有0，1，分别对应生成数据和真实数据。D的结构，类似于G的反过来的意思。

# 定义D的复用块，使用正常的卷积网络
class D_block(nn.Module):
    def __init__(self,in_channels,out_channels,kernel_size=4,strides=2,
                 padding=1,alpha=0.2):
        super(D_block,self).__init__()
        self.conv2d=nn.Conv2d(in_channels,out_channels,kernel_size,strides,padding,bias=False)
        # 这里用的时conv+bn+leakyrelu，论文中给出这样有利于收敛。
        self.batch_norm=nn.BatchNorm2d(out_channels,0.8)
        self.activation=nn.LeakyReLU(alpha)
    def forward(self,X):
        return self.activation(self.batch_norm(self.conv2d(X)))

对应的D

class net_D(nn.Module):
    def __init__(self,in_channels):
        super(net_D,self).__init__()
        n_D=64
        self.model=nn.Sequential(
            D_block(in_channels,n_D),
            D_block(n_D,n_D*2),
            D_block(n_D*2,n_D*4),
            D_block(n_D*4,n_D*8)
        )
        self.conv=nn.Conv2d(n_D*8,1,kernel_size=4,bias=False)
        # 最后使用的sigmoid激活，常的分类激活函数
        self.activation=nn.Sigmoid()
    def forward(self,x):
        x=self.model(x)
        x=self.conv(x)
        x=self.activation(x)
        return x

这里由于D输入尺寸为为（64，64）所以其最后的输出为（1，1）

如何训练这样的网络

在DCGAN中，网络通常是迭代训练的，固定G训练D，固定D训练G。。。
训练过程中的损失计算参考如下代码

def update_D(X,Z,net_D,net_G,loss,trainer_D):
    batch_size=X.shape[0]
    Tensor=torch.cuda.FloatTensor
    ones=Variable(Tensor(np.ones(batch_size,)),requires_grad=False).view(batch_size,1)
    zeros = Variable(Tensor(np.zeros(batch_size,)),requires_grad=False).view(batch_size,1)
    #训练D的时候，给原始图1标签，生成图0标签
    real_Y=net_D(X).view(batch_size,-1)
    fake_X=net_G(Z)
    fake_Y=net_D(fake_X).view(batch_size,-1)
    loss_D=(loss(real_Y,ones)+loss(fake_Y,zeros))/2
    loss_D.backward()
    trainer_D.step()
    return float(loss_D.sum())

def update_G(Z,net_D,net_G,loss,trainer_G):
    batch_size=Z.shape[0]
    Tensor=torch.cuda.FloatTensor
    ones=Variable(Tensor(np.ones((batch_size,))),requires_grad=False).view(batch_size,1)
    # 在训练G的时候我们需要给定生成图1标签
    fake_X=net_G(Z)
    fake_Y=net_D(fake_X).view(batch_size,-1)
    loss_G=loss(fake_Y,ones)
    loss_G.backward()
    trainer_G.step()
    return float(loss_G.sum())

读取数据训练参考如下

    for epo in range(epochs):
        for data in dataiter:
            z = ..
            d.zero_grad()
            update_D(...)
            g.zero_grad()
            update_G

总结

DCGAN 可以说是入门GAN的开始，后面有很多基于GAN思路的改进，本质上来说，GAN的思路使得神经网络具有了可控的创造性，但距离人的差距还是很大。