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

╰+哭是因爲堅強的太久メ 2022-01-07 12:45 395阅读 0赞

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

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

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

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

![1446032-20190428171304652-91548362.png][]

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

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

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

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

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

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

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

1.网络结构的设计

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

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

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

![1446032-20190428173227588-1123167107.png][]

网络的输入是一个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][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轮迭代后生成的结果为：

![1446032-20190501072238003-383847445.png][]

20次迭代后的结果为：

![1446032-20190501083800525-443677032.png][]

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

![1446032-20190501083852891-1476771812.png][]

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

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

得到的结果是：

![1446032-20190505195447534-94808582.png][]

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为：

![1446032-20190501084641472-2018569567.png][]

转载于:https://www.cnblogs.com/wanghui-garcia/p/10785579.html

[1446032-20190428171304652-91548362.png]: /images/20211220/7267bd59b55f4d7a827d9cd4a03f567e.png
[1446032-20190428173227588-1123167107.png]: /images/20211220/f808af2a94aa42d1a76fd97d0b6e9b54.png
[https_pan.baidu.com_s_1eSifHcA]: https://pan.baidu.com/s/1eSifHcA
[1446032-20190501072238003-383847445.png]: /images/20211220/a1049785c7f74aed92f036a04fd860a1.png
[1446032-20190501083800525-443677032.png]: /images/20211220/33965f0e96e549c791d336c064a76cac.png
[1446032-20190501083852891-1476771812.png]: /images/20211220/4f97860cc36b4352bfe3cf4469cc7498.png
[1446032-20190505195447534-94808582.png]: /images/20211220/1a01a5a5fd0048b499e2f6ff6df44485.png
[1446032-20190501084641472-2018569567.png]: /images/20211220/9d92d2745e8443be85d832a2bb059121.png