深度学习框架PyTorch一书的学习-第七章-生成对抗网络(GAN)

参考：https://github.com/chenyuntc/pytorch-book/tree/v1.0/chapter7-GAN生成动漫头像

GAN解决了非监督学习中的著名问题：给定一批样本，训练一个系统能够生成类似的新样本

生成对抗网络的网络结构如下图所示：

• 生成器(generator)：输入一个随机噪声，生成一张图片
• 判别器(discriminator):判断输入的图片是真图片还是假图片

训练判别器D时，需要利用生成器G生成的假图片和来自现实世界的真图片；训练生成器时，只需要使用噪声生成假图片

判别器用来评估生成的假图片的质量，促使生成器相应地调整参数

生成器的目标是尽可能地生成以假乱真的图片，让判别器以为这是真的图片；判别器的目标是将生成器生成的图片和真实世界的图片区分开

可以看出这两者的目标相反，在训练过程中相互对抗，这也是它被称为生成对抗网络的原因

一开始，生成器和判别器的水平都很差，因为两者都是随机初始化的。训练的步骤分两步交替进行：

• 第一步是训练判别器D(只修改判别器的参数，固定生成器)，目标是把真图片和假图片区分开
• 第二步是训练生成器(只修改生成器的参数，固定判别器)，为的是生成的假图片能够被判别器判别为真图片

 这两步交替进行，为的是生成的假图片能够被判别为真图片

1.网络结构的设计

判别器的目标是判断输入的图片是真图片还是假图片，所以可以被看作是二分类网络

 生成器的目标是从噪声中生成一张彩色图片

这里我们采用的是广泛使用的DCGAN(Deep Convolutional Generative Adversarial Networks)结构，即采用全卷积网络，如图所示：

网络的输入是一个100维的噪声，输出是一个3*64*64的图片

这里的输入可以看成是一个100*1*1的图片，通过上卷积慢慢增大为4*4、8*8、16*16、32*32和64*64。当上卷集的stride=2时，输出会上采样到输入的两倍

这种上采样的做法可以理解为图片的信息保存于100个向量之中，然后神经网络会根据这100个向量描述的信息，前几步的上采样先勾勒出轮廓、色调等基础信息，后几步上采样慢慢完善细节。网络越深，细节越详细

在DCGAN中，判别器的结构和生成器对称：生成器中采用上采样的卷积，判别器中就采用下采样的卷积。

生成器是根据噪声输出一张64*64*3的图片，而判别器则是根据输出的64*64*3的图片输出图片属于正负样本的分数(即概率)

2.用GAN生成动漫头像

从https://pan.baidu.com/s/1eSifHcA 提取码：g5qa下载数据（275M，约5万多张图片）
把所有图片保存于data/face/目录下，形如：

data/
└── faces/
    ├── 0000fdee4208b8b7e12074c920bc6166-0.jpg
    ├── 0001a0fca4e9d2193afea712421693be-0.jpg
    ├── 0001d9ed32d932d298e1ff9cc5b7a2ab-0.jpg
    ├── 0001d9ed32d932d298e1ff9cc5b7a2ab-1.jpg
    ├── 00028d3882ec183e0f55ff29827527d3-0.jpg
    ├── 00028d3882ec183e0f55ff29827527d3-1.jpg
    ├── 000333906d04217408bb0d501f298448-0.jpg
    ├── 0005027ac1dcc32835a37be806f226cb-0.jpg

即data目录下只有一个文件夹，文件夹中有所有的图片

注意这里图片的分辨率是3*96*96,而不是3*64*64，所以需要相应地调整网络结构，使生成图像的尺寸为96

1）实验的代码结构

checkpoints/ #无代码，用来保存训练好的模型
imgs/ #无代码，用来保存生成的图片
data/ #无代码，用来保存训练所需的图片
main.py #训练和生成代码
model.py #模型定义代码
visualize.py #可视化工具visdom的封装代码
requirements.txt #程序中用到的第三方库
README.MD #说明文档

1》model.py

定义生成器和判别器

判别器：

class NetD(nn.Module):
    """
    判别器定义
    """

    def __init__(self, opt):
        super(NetD, self).__init__()
        ndf = opt.ndf #判别器channel值
        self.main = nn.Sequential(
            # 输入 3 x 96 x 96
            # kernel_size = 5,stride = 3, padding =1
            # 按式子计算 floor((96 + 2*1 - 1*(5-1) - 1)/3 + 1) = 32
            # 是same卷积，96/32 = stride = 3
            nn.Conv2d(3, ndf, 5, 3, 1, bias=False),
            nn.LeakyReLU(0.2, inplace=True),
            # 输出 (ndf) x 32 x 32

            #kernel_size = 4,stride = 2, padding =1
            #按式子计算 floor((32 + 2*1 - 1*(4-1) - 1)/2 + 1) = 16
            #是same卷积，32/16 = stride = 2
            nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ndf * 2),
            nn.LeakyReLU(0.2, inplace=True),
            # 输出 (ndf*2) x 16 x 16

            #kernel_size = 4,stride = 2, padding =1
            #按式子计算 floor((16 + 2*1 - 1*(4-1) - 1)/2 + 1) = 8
            #是same卷积，16/8 = stride = 2           
            nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ndf * 4),
            nn.LeakyReLU(0.2, inplace=True),
            # 输出 (ndf*4) x 8 x 8

            #kernel_size = 4,stride = 2, padding =1
            #按式子计算 floor((8 + 2*1 - 1*(4-1) - 1)/2 + 1) = 4
            #是same卷积，8/4 = stride = 2
            nn.Conv2d(ndf * 4, ndf * 8, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ndf * 8),
            nn.LeakyReLU(0.2, inplace=True),
            # 输出 (ndf*8) x 4 x 4

            #kernel_size = 4,stride = 1, padding =0
            #按式子计算 floor((4 + 2*0 - 1*(4-1) - 1)/1 + 1) = 1
            nn.Conv2d(ndf * 8, 1, 4, 1, 0, bias=False),
            #输出为1*1*1
            nn.Sigmoid()  # 返回[0,1]的值，输出一个数(作为概率值)
        )

    def forward(self, input):
        return self.main(input).view(-1) #输出从1*1*1变为1，得到生成器生成假图片的分数，分数高则像真图片

生成器：

class NetG(nn.Module):
    """
    生成器定义
    """

    def __init__(self, opt):
        super(NetG, self).__init__()
        ngf = opt.ngf  # 生成器feature map数channnel，默认为64

        self.main = nn.Sequential(
            # 输入是一个nz维度(默认为100)的噪声，我们可以认为它是一个1*1*nz的feature map
            # kernel_size = 4,stride = 1, padding =0
            # 根据计算式子 (1-1)*1 - 2*0 + 4 + 0 = 4
            nn.ConvTranspose2d(opt.nz, ngf * 8, 4, 1, 0, bias=False),
            nn.BatchNorm2d(ngf * 8),
            nn.ReLU(True),
            # 上一步的输出形状：(ngf*8) x 4 x 4

            #kernel_size = 4,stride = 2, padding =1
            #根据计算式子 (4-1)*2 - 2*1 + 4 + 0 = 8
            nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf * 4),
            nn.ReLU(True),
            # 上一步的输出形状： (ngf*4) x 8 x 8

            #kernel_size = 4,stride = 2, padding =1
            #根据计算式子 (8-1)*2 - 2*1 + 4 + 0 = 16
            nn.ConvTranspose2d(ngf * 4, ngf * 2, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf * 2),
            nn.ReLU(True),
            # 上一步的输出形状： (ngf*2) x 16 x 16

            #kernel_size = 4,stride = 2, padding =1
            #根据计算式子 (16-1)*2 - 2*1 + 4 + 0 = 32
            nn.ConvTranspose2d(ngf * 2, ngf, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf),
            nn.ReLU(True),
            # 上一步的输出形状：(ngf) x 32 x 32

            # kernel_size = 5,stride = 3, padding =1
            #根据计算式子 (32-1)*3 - 2*1 + 5 + 0 = 96
            nn.ConvTranspose2d(ngf, 3, 5, 3, 1, bias=False),
            nn.Tanh()  # 输出范围 -1~1 故而采用Tanh
            # 输出形状：3 x 96 x 96
        )

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

可以看出判别器和生成器的网络结构几乎是对称的，从卷积核大小kernel_size到padding、stride等设置，几乎是一模一样。例如生成器的最后一个卷积层的尺度是(5,3,1),判别器的第一个卷积层的尺度也是(5,3,1)

再这里可见生成器的激活函数使用的是ReLU(),而判别器使用的是LeakyReLU，二者并没有本质的区别，这里的选择不同更多是经验总结导致的

每一个样本经过判别器后，输出一个0～1的数，表示这个样本是真图片的概率

2》main.py

配置参数信息：

class Config(object):
    data_path = 'data/'  # 数据集存放路径
    num_workers = 4  # 多进程加载数据所用的进程数
    image_size = 96  # 图片尺寸
    batch_size = 256
    max_epoch = 200
    lr1 = 2e-4  # 生成器的学习率
    lr2 = 2e-4  # 判别器的学习率
    beta1 = 0.5  # Adam优化器的beta1参数
    gpu = True  # 是否使用GPU
    nz = 100  # 噪声维度
    ngf = 64  # 生成器feature map数
    ndf = 64  # 判别器feature map数

    save_path = 'imgs/'  # 生成图片保存路径

    vis = True  # 是否使用visdom可视化
    env = 'GAN'  # visdom的env
    plot_every = 20  # 每间隔20 batch，visdom画图一次

    debug_file = '/tmp/debuggan'  # 存在该文件则进入debug模式
    d_every = 1  # 每1个batch训练一次判别器
    g_every = 5  # 每5个batch训练一次生成器
    save_every = 10  # 没10个epoch保存一次模型
    netd_path = None  # 'checkpoints/netd_.pth' #预训练模型
    netg_path = None  # 'checkpoints/netg_211.pth'

    # 只测试不训练
    gen_img = 'result.png'
    # 从512张生成的图片中保存最好的64张
    gen_num = 64
    gen_search_num = 512
    gen_mean = 0  # 噪声的均值
    gen_std = 1  # 噪声的方差


opt = Config()

这些是模型的默认参数，还可以利用Fire等工具通过命令行传入，覆盖默认值。可以用opt.attr的方式来指定使用的参数

这里的参数设置大多是照搬DCGAN论文的默认值，作者经过大量的实验，发现这些参数能够更快地训练出一个不错的模型

数据处理：

使用torchvision.ImageFolder函数读取data/faces中的图片，不必自己写Dataset

数据读取和加载的代码为：

    # 数据
    transforms = tv.transforms.Compose([
        tv.transforms.Resize(opt.image_size), #重新设置图片大小，opt.image_size默认值为96
        tv.transforms.CenterCrop(opt.image_size), #从中心截取大小为opt.image_size的图片
        tv.transforms.ToTensor(), #转为Tensor格式，并将值取在[0,1]中
        tv.transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) #标准化，得到在[-1,1]的值
    ])

    dataset = tv.datasets.ImageFolder(opt.data_path, transform=transforms) #从data中读取图片，图片类别会设置为文件夹名faces
    dataloader = t.utils.data.DataLoader(dataset, #然后对得到的图片进行批处理，默认一批为256张图，使用4个进程读取数据
                                         batch_size=opt.batch_size,
                                         shuffle=True,
                                         num_workers=opt.num_workers,
                                         drop_last=True
                                         )

定义变量：模型，优化器，噪声

    # 网络，netg为生成器，netd为判别器
    netg, netd = NetG(opt), NetD(opt)
    # 把所有的张量加载到CPU中
    map_location = lambda storage, loc: storage
    # 把所有的张量加载到GPU 1中
    #torch.load('tensors.pt', map_location=lambda storage, loc: storage.cuda(1))
    #也可以写成：
    #device = torch.device('cpu')
    #netd.load_state_dict(t.load(opt.netd_path, map_location=device))
    #或：
    #netd.load_state_dict(t.load(opt.netd_path))
    #netd.to(device)
    if opt.netd_path: #是否指定训练好的预训练模型，加载模型参数
        netd.load_state_dict(t.load(opt.netd_path, map_location=map_location))
    if opt.netg_path:
        netg.load_state_dict(t.load(opt.netg_path, map_location=map_location))
    netd.to(device)
    netg.to(device)


    # 定义优化器和损失，学习率都默认为2e-4，beta1默认为0.5
    optimizer_g = t.optim.Adam(netg.parameters(), opt.lr1, betas=(opt.beta1, 0.999))
    optimizer_d = t.optim.Adam(netd.parameters(), opt.lr2, betas=(opt.beta1, 0.999))
    criterion = t.nn.BCELoss().to(device)

    # 真图片label为1，假图片label为0
    # noises为生成网络的输入
    true_labels = t.ones(opt.batch_size).to(device)
    fake_labels = t.zeros(opt.batch_size).to(device)
    fix_noises = t.randn(opt.batch_size, opt.nz, 1, 1).to(device)#opt.nz为噪声维度，默认为100
    noises = t.randn(opt.batch_size, opt.nz, 1, 1).to(device)

    #AverageValueMeter测量并返回添加到其中的任何数字集合的平均值和标准差,
    #对度量一组示例的平均损失是有用的。
    errord_meter = AverageValueMeter()
    errorg_meter = AverageValueMeter()

再加载预训练模型时，最好指定map_location。因为如果程序之前在GPU上运行，那么模型就会被存为torch.cuda.Tensor，这样加载时会默认将数据加载至显存。如果运行该程序的计算机中没有GPU，加载就会报错，故通过指定map_location将Tensor默认加载入内存(CPU)，待有需要再移至显存

训练网络：

1）训练判别器

• 先固定生成器
• 对于真图片，判别器的输出概率值尽可能接近1
• 对于生成器生成的假图片，判别器尽可能输出0

2）训练生成器

• 固定判别器
• 生成器生成图片，尽可能使生成的图片让判别器输出为1

3）返回第一步，循环交替进行

    epochs = range(opt.max_epoch)
    for epoch in iter(epochs):
        for ii, (img, _) in tqdm.tqdm(enumerate(dataloader)):
            real_img = img.to(device)

            if ii % opt.d_every == 0:
                # 训练判别器
                # 每d_every=1(默认)个batch训练一次判别器
                optimizer_d.zero_grad()
                ## 尽可能的把真图片判别为正确
                output = netd(real_img)
                error_d_real = criterion(output, true_labels)
                error_d_real.backward()

                ## 尽可能把假图片判别为错误
                #更新noises中的data值
                noises.data.copy_(t.randn(opt.batch_size, opt.nz, 1, 1))
                fake_img = netg(noises).detach()  # 根据噪声生成假图
                output = netd(fake_img)
                error_d_fake = criterion(output, fake_labels)
                error_d_fake.backward()
                optimizer_d.step()

                error_d = error_d_fake + error_d_real

                errord_meter.add(error_d.item())

            if ii % opt.g_every == 0:
                # 训练生成器
                # 每g_every=5个batch训练一次生成器
                optimizer_g.zero_grad()
                #更新noises中的data值
                noises.data.copy_(t.randn(opt.batch_size, opt.nz, 1, 1))
                fake_img = netg(noises)
                output = netd(fake_img)
                error_g = criterion(output, true_labels)
                error_g.backward()
                optimizer_g.step()
                errorg_meter.add(error_g.item())

注意：

训练生成器时，无须调整判别器的参数；训练判别器时，无须调整生成器的参数

在训练判别器时，需要对生成器生成的图片用detach()操作进行计算图截断，避免反向传播将梯度传到生成器中。因为在训练判别器时，我们不需要训练生成器，也就不需要生成器的梯度

在训练判别器时，需要反向传播两次，一次是希望把真图片判定为1，一次是希望把假图片判定为0.也可以将这两者的数据放到一个batch中，进行一次前向传播和反向传播即可。但是人们发现，分两次的方法更好

对于假图片，在训练判别器时，我们希望判别器输出为0；而在训练生成器时，我们希望判别器输出为1，这样实现判别器和生成器互相对抗提升

可视化：

接下来就是一些可视化代码的实现。每次可视化时使用的噪音都是固定的fix_noises，因为这样便于我们比较对于相同的输入，可见生成器生成的图片是如何一步步提升的

因为对输出的图片进行了归一化处理,值在(-1,1)，所以在输出时需要将其还原会原来的scale,值在(0,1),方法就是图片的值*mean + std

            # 每间隔20 batch，visdom画图一次
            if opt.vis and ii % opt.plot_every == opt.plot_every - 1:
                ## 可视化
                ## 存在该文件则进入debug模式
                if os.path.exists(opt.debug_file):
                    ipdb.set_trace()
                fix_fake_imgs = netg(fix_noises)
                vis.images(fix_fake_imgs.detach().cpu().numpy()[:64] * 0.5 + 0.5, win='fixfake')
                vis.images(real_img.data.cpu().numpy()[:64] * 0.5 + 0.5, win='real')
                vis.plot('errord', errord_meter.value()[0])
                vis.plot('errorg', errorg_meter.value()[0])

保存模型：

        # 每10个epoch保存一次模型
        if (epoch+1) % opt.save_every == 0:
            # 保存模型、图片
            tv.utils.save_image(fix_fake_imgs.data[:64], '%s/%s.png' % (opt.save_path, epoch), normalize=True,
                                range=(-1, 1))
            t.save(netd.state_dict(), 'checkpoints/netd_%s.pth' % epoch)
            t.save(netg.state_dict(), 'checkpoints/netg_%s.pth' % epoch)
            errord_meter.reset()#重置，清空里面的值
            errorg_meter.reset()

验证：

使用训练好的模型进行验证

@t.no_grad()
def generate(**kwargs):#进行验证
    """
    随机生成动漫头像，并根据netd的分数选择较好的
    """
    for k_, v_ in kwargs.items():
        setattr(opt, k_, v_)
    
    device=t.device('cuda') if opt.gpu else t.device('cpu')

    netg, netd = NetG(opt).eval(), NetD(opt).eval()
    noises = t.randn(opt.gen_search_num, opt.nz, 1, 1).normal_(opt.gen_mean, opt.gen_std)
    noises = noises.to(device)

    map_location = lambda storage, loc: storage
    netd.load_state_dict(t.load(opt.netd_path, map_location=map_location))
    netg.load_state_dict(t.load(opt.netg_path, map_location=map_location))
    netd.to(device)
    netg.to(device)


    # 生成图片，并计算图片在判别器的分数
    fake_img = netg(noises)
    scores = netd(fake_img).detach()

    # 挑选最好的某几张，默认opt.gen_num=64张，并得到其索引
    indexs = scores.topk(opt.gen_num)[1]
    result = []
    for ii in indexs:
        result.append(fake_img.data[ii])
    # 保存图片
    tv.utils.save_image(t.stack(result), opt.gen_img, normalize=True, range=(-1, 1))

2）开始训练

使用gpu，并且visdom实现可视化

python main.py train --gpu=True --vis=True

进行了200次迭代，生成的图片存储在imgs文件夹中，第一次10轮迭代后生成的结果为：

20次迭代后的结果为：

一直到200次迭代的结果为,多训练几轮可能效果会更好：

 在该基础上又训练了200轮：

python main.py train --netd-path=checkpoints/netd_199.pth --netg-path=checkpoints/netg_199.pth

得到的结果是：

3）验证

使用最后一次迭代的到的训练网络进行验证，生成器网络为--netd-path=checkpoints/netd_199.pth，判别器网络为--netg-path=checkpoints/netg_199.pth，会输出结果最好的64张图，并存储在本地，命名为result.png：

(deeplearning) userdeMBP:DCGAN user$ python main.py generate --gpu=False --vis=False --netd-path=checkpoints/netd_199.pth --netg-path=checkpoints/netg_199.pth

得到的result.png为：