4.2.5. DCGAN生成器的构建

DCGAN的生成器主要通过转置卷积的上采样功能将输入的噪声数据逐步转换为图像数据。DCGAN的生成器由ConvTranspose2、BatchNorm2d、ReLU和Tanh组成。生成器借助ConvTranspose2d的上采样功能，实现对输入的噪声信号，即隐变量z的逐级放大。隐变量z的尺寸为(nz,1,1)，经过生成器内部模块逐步处理后，最终生成的图像格式为(nc, image_size, image_size)。用我们设定的参数来举例，即从(100, 1, 1)的尺寸到(3, 64, 64)的尺寸。

生成器模型的实际代码如下所示。隐变量z的维度为100，此参数可按需设置，无其他特殊意义。与transforms.Compose类似，nn.Sequential也是一个序列容器，可按照一定顺序将各种神经网络模块装入其中。nn.Sequential把多个模块封装为一个模块，比逐层定义网络层更加方便。在forward方法接收到输入后，nn.Sequential便按照装入模块的顺序，依次计算并输出结果。

chapter_4_2_5_01.py

from torch import nn
from chapter_4_2_3_01 import ngf, nz, nc


class Generator(nn.Module):
    def __init__(self):
        super(Generator, self).__init__()
        self.main = nn.Sequential(
            # 100 x 1 x 1
            nn.ConvTranspose2d(in_channels=nz, out_channels=ngf * 8,
                               kernel_size=4, stride=1, padding=0, bias=False),
            nn.BatchNorm2d(ngf * 8),
            nn.ReLU(True),
            # (ngf*8) x 4 x 4，输入—输出计算过程：O=(I-1)*S+K-2P=(1-1)*1+4-2*0=4
            nn.ConvTranspose2d(in_channels=ngf * 8, out_channels=ngf * 4,
                               kernel_size=4, stride=2, padding=1, bias=False),
            nn.BatchNorm2d(ngf * 4),
            nn.ReLU(True),
            # (ngf*4) x 8 x 8，输入—输出计算过程：O=(I-1)*S+K-2P=(4-1)*2+4-2*1=8
            nn.ConvTranspose2d(in_channels=ngf * 4, out_channels=ngf * 2,
                               kernel_size=4, stride=2, padding=1, bias=False),
            nn.BatchNorm2d(ngf * 2),
            nn.ReLU(True),
            # (ngf*2) x 16 x 16，输入—输出计算过程：O=(I-1)*S+K-2P=(8-1)*2+4-2*1=16
            nn.ConvTranspose2d(in_channels=ngf * 2, out_channels=ngf,
                               kernel_size=4, stride=2, padding=1, bias=False),
            nn.BatchNorm2d(ngf),
            nn.ReLU(True),
            # (ngf) x 32 x 32，输入—输出计算过程：O=(I-1)*S+K-2P=(16-1)*2+4-2*1=32
            nn.ConvTranspose2d(in_channels=ngf, out_channels=nc,
                               kernel_size=4, stride=2, padding=1, bias=False),
            nn.Tanh()
            # (nc) x 64 x 64，输入—输出计算过程：O=(I-1)*S+K-2P=(32-1)*2+4-2*1=64
        )

    def forward(self, inputs):
        return self.main(inputs)