wanghui-garcia

参考: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为:

 

分类:

技术点:

相关文章: