第G2周：人脸图像生成（DCGAN）

• 🍨 本文为🔗365天深度学习训练营 中的学习记录博客
• 🍖 原作者：K同学啊

基础任务

1. 学习DCGAN的基本原理
2. 了解DCGAN与GAN的区别
3. 绘制DCGAN网络结构图
4. 学习DCGAN代码，并跑通代码

一、前期准备

1、导入第三方库

import torch, random, os
import torch.nn as nn
import torch.nn.parallel
import torch.optim as optim
import torch.utils.data
import torchvision.datasets as dset
import torchvision.transforms as transforms
import torchvision.utils as vutils
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
from IPython.display import HTML

manualSeed =999
print('Random Seed:',manualSeed)
random.seed(manualSeed)
torch.manual_seed(manualSeed)
torch.use_deterministic_algorithms(True)

2. 定义超参数

# 设置超参数
dataroot = "F:/365data/G2/"
batch_size = 128
image_size = 64
nz = 100
ngf = 64
ndf = 64
num_epochs = 50
lr = 0.0002
beta1 = 0.5

3、导入数据

# 设置数据集，并用matplotlib展示一些图片
dataset = dset.ImageFolder(root=dataroot,
                           transform=transforms.Compose([
                               transforms.Resize(image_size),
                               transforms.CenterCrop(image_size),#中心裁剪
                               transforms.ToTensor(),
                               transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))
                           ]))
dataloader = torch.utils.data.DataLoader(dataset,
                                         batch_size=batch_size,
                                         shuffle=True,
                                         num_workers=5)
device = torch.device('cuda:0' if (torch.cuda.is_available()) else 'cpu')
print('使用的设备是：',device)

real_batch = next(iter(dataloader))
plt.figure(figsize=(8,8))
plt.axis('off')
plt.title('Training Images')
plt.imshow(np.transpose(vutils.make_grid(real_batch[0].to(device)[:24],
                                         padding=2,
                                         normalize=True).cpu(),(1,2,0)))

三、定义模型

1、初始化权重

# 自定义权重初始化函数，作用于netG和netD
def weights_init(m):
    # 获取当前层的类名
    classname = m.__class__.__name__
    # 如果类名中包含'Conv',即当前层是卷积层
    if classname.find('Conv') != -1:
        # 使用正态分布初始化权重数据，均值为0，标准差为0.02
        nn.init.normal_(m.weight.data,0.0,0.02)
    # 如果类名中包含'BatchNorm',即当前层是批归一化层
    elif classname.find('BatchNorm') != -1:
        # 使用正态分布初始化权重数据，均值为1，标准差为0.02
        nn.init.normal_(m.weight.data,1.0,0.02)
        # 使用常数初始化偏置项数据，值为0
        nn.init.constant_(m.bias.data,0)

2、定义生成器

# 定义生成器
class Generator(nn.Module):
    def __init__(self):
        super(Generator,self).__init__()
        self.main = nn.Sequential(
            # 输入为Z,经过一个转置卷积层
            nn.ConvTranspose2d(nz,ngf*8,4,1,0,bias=False),
            nn.BatchNorm2d(ngf*8),
            nn.ReLU(True),
            # 输出尺寸：(ngf*8) x 4 x 4
            nn.ConvTranspose2d(ngf*8,ngf*4,4,2,1,bias=False),
            nn.BatchNorm2d(ngf*4),
            nn.ReLU(True),
            # 输出尺寸：(ngf*4) x 8 x 8
            nn.ConvTranspose2d(ngf*4,ngf*2,4,2,1,bias=False),
            nn.BatchNorm2d(ngf*2),
            nn.ReLU(True),
            # 输出尺寸：(ngf*2) x 16 x 16
            nn.ConvTranspose2d(ngf*2,ngf,4,2,1,bias=False),
            nn.BatchNorm2d(ngf),
            nn.ReLU(True),
            # 输出尺寸：(ngf) x 32 x 32
            nn.ConvTranspose2d(ngf,3,4,2,1,bias=False),
            nn.Tanh()
            # 输出尺寸：3 x 64 x 64
        )
    def forward(self,input):
        return self.main(input)

# 创建生成器
netG = Generator().to(device)
# 使用'weights_init'函数对所有权重进行随机初始化，
# 平均值(mean)设置为0，标准差(stdev)设置为0.02.
netG.apply(weights_init)
# 打印生成器
print(netG)

3、定义判别器

# 定义判别器
class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator,self).__init__()

        # 定义判别器的主要结构，使用Sequential容器将多个层按顺序组合在一起
        self.main = nn.Sequential(
            # 输入尺寸：3 x 64 x 64
            nn.Conv2d(3,ndf,4,2,1,bias=False),
            nn.LeakyReLU(0.2,inplace=True),
            # 输出尺寸：(ndf) x 32 x 32
            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
            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
            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
            nn.Conv2d(ndf*8,1,4,1,0,bias=False),
            nn.Sigmoid()
        )
    def forward(self,input):
        return self.main(input)

# 创建判别器
netD = Discriminator().to(device)
# 使用'weights_init'函数对所有权重进行随机初始化，
# 平均值(mean)设置为0，标准差(stdev)设置为0.2
netD.apply(weights_init)
# 打印判别器
print(netD)

四、训练模型

1、定义训练参数

# 初始化二进制交叉熵损失函数
criterion = nn.BCELoss()

# 创建用于可视化生成器进程的潜在向量批次
fixed_noise = torch.randn(64,nz,1,1,device=device)

real_label = 1.
fake_label = 0.

# 设置Adam优化器
optimizerD = optim.Adam(netD.parameters(),lr=lr,betas=(beta1,0.999))
optimizerG = optim.Adam(netG.parameters(),lr=lr,betas=(beta1,0.999))

2、训练模型

img_list = [] # 用于保存生成器生成的图片
G_losses = [] # 用于保存生成器的损失
D_losses = [] # 用于保存判别器的损失
iters = 0 # 迭代次数

print('Starting Training Loop...')
for epoch in range(num_epochs):
    # 对于dataloader中的每个batch
    for i, data in enumerate(dataloader,0):

        ############################
        # (1) 更新判别器网络：最大化 log(D(x)) + log(1-D(G(z)))
        ###########################
        ## 训练真实数据
        netD.zero_grad()
        # 准备真实数据
        real_cpu = data[0].to(device)
        b_size = real_cpu.size(0)
        label = torch.full((b_size,), real_label, dtype=torch.float,device=device) # 创建真实标签
        # 通过判别器前向传播真实数据
        output = netD(real_cpu).view(-1)
        # 计算真实数据的损失
        errD_real = criterion(output,label)
        errD_real.backward()
        D_x = output.mean().item()

        ## 训练生成数据
        # 准备生成数据
        noise = torch.randn(b_size,nz,1,1,device=device)
        # 通过生成器生成数据
        fake = netG(noise)
        label.fill_(fake_label)
        # 通过判别器前向传播生成数据
        output = netD(fake.detach()).view(-1)
        # 计算生成数据的损失
        errD_fake = criterion(output,label)
        errD_fake.backward()
        D_G_z1 = output.mean().item()
        # 将真实数据和生成数据的损失相加
        errD = errD_real + errD_fake
        # 更新判别器参数
        optimizerD.step()

        ############################
        # (2) 更新生成器网络：最大化 log(D(G(z)))
        ###########################
        netG.zero_grad()
        label.fill_(real_label) # 为真实标签填充1
        # 通过判别器前向传播生成数据
        output = netD(fake).view(-1)
        # 计算生成数据的损失
        errG = criterion(output,label)
        # 更新生成器参数
        errG.backward()
        D_G_z2 = output.mean().item()
        optimizerG.step()

        # 输出训练统计信息
        if i % 400 == 0:
            print('[%d/%d][%d/%d]\tLoss_D: %.4f\tLoss_G: %.4f\tD(x): %.4f\tD(G(z)): %.4f / %.4f'
                  % (epoch, num_epochs, i, len(dataloader),
                     errD.item(), errG.item(), D_x, D_G_z1, D_G_z2))
        
        # 保存损失以便后续绘图
        G_losses.append(errG.item())
        D_losses.append(errD.item())

        # 通过固定噪声生成的图片来跟踪生成器的训练进度
        if (iters % 500 == 0) or ((epoch == num_epochs-1) and (i == len(dataloader)-1)):
            with torch.no_grad():
                fake = netG(fixed_noise).detach().cpu()
            img_list.append(vutils.make_grid(fake,padding=2,normalize=True))
        
        iters += 1

Starting Training Loop...
[0/50][0/36]	Loss_D: 1.7508	Loss_G: 5.3002	D(x): 0.5574	D(G(z)): 0.5731 / 0.0074
[1/50][0/36]	Loss_D: 0.0362	Loss_G: 14.2664	D(x): 0.9773	D(G(z)): 0.0000 / 0.0000
[2/50][0/36]	Loss_D: 0.2026	Loss_G: 16.0342	D(x): 0.9112	D(G(z)): 0.0001 / 0.0000
[3/50][0/36]	Loss_D: 2.0525	Loss_G: 15.8344	D(x): 0.9709	D(G(z)): 0.7586 / 0.0000
[4/50][0/36]	Loss_D: 0.6356	Loss_G: 8.1305	D(x): 0.9236	D(G(z)): 0.3685 / 0.0009
[5/50][0/36]	Loss_D: 0.6821	Loss_G: 5.9364	D(x): 0.6237	D(G(z)): 0.0144 / 0.0069
[6/50][0/36]	Loss_D: 1.2046	Loss_G: 7.3426	D(x): 0.7934	D(G(z)): 0.5032 / 0.0014
[7/50][0/36]	Loss_D: 0.3649	Loss_G: 2.4782	D(x): 0.8240	D(G(z)): 0.0923 / 0.1542
[8/50][0/36]	Loss_D: 0.4195	Loss_G: 3.9613	D(x): 0.7799	D(G(z)): 0.0813 / 0.0324
[9/50][0/36]	Loss_D: 0.4080	Loss_G: 3.5926	D(x): 0.7544	D(G(z)): 0.0522 / 0.0381
[10/50][0/36]	Loss_D: 0.5388	Loss_G: 3.2718	D(x): 0.7955	D(G(z)): 0.1924 / 0.0625
[11/50][0/36]	Loss_D: 0.5069	Loss_G: 4.6123	D(x): 0.8644	D(G(z)): 0.2365 / 0.0201
[12/50][0/36]	Loss_D: 0.3624	Loss_G: 6.0753	D(x): 0.9865	D(G(z)): 0.2575 / 0.0056
[13/50][0/36]	Loss_D: 0.5918	Loss_G: 7.9663	D(x): 0.9450	D(G(z)): 0.3553 / 0.0015
[14/50][0/36]	Loss_D: 0.7028	Loss_G: 2.9400	D(x): 0.6269	D(G(z)): 0.0732 / 0.0965
[15/50][0/36]	Loss_D: 0.5989	Loss_G: 7.1686	D(x): 0.9460	D(G(z)): 0.3633 / 0.0016
[16/50][0/36]	Loss_D: 0.4842	Loss_G: 3.3526	D(x): 0.8576	D(G(z)): 0.1826 / 0.0679
[17/50][0/36]	Loss_D: 0.5359	Loss_G: 3.9497	D(x): 0.7646	D(G(z)): 0.1681 / 0.0320
[18/50][0/36]	Loss_D: 0.5714	Loss_G: 3.7671	D(x): 0.6718	D(G(z)): 0.0380 / 0.0435
[19/50][0/36]	Loss_D: 0.9133	Loss_G: 9.8651	D(x): 0.9621	D(G(z)): 0.5022 / 0.0003
[20/50][0/36]	Loss_D: 0.3539	Loss_G: 4.9887	D(x): 0.8234	D(G(z)): 0.0916 / 0.0127
[21/50][0/36]	Loss_D: 0.4090	Loss_G: 5.5089	D(x): 0.8455	D(G(z)): 0.1559 / 0.0068
[22/50][0/36]	Loss_D: 0.2700	Loss_G: 3.9109	D(x): 0.8547	D(G(z)): 0.0828 / 0.0305
[23/50][0/36]	Loss_D: 0.3666	Loss_G: 4.6487	D(x): 0.7987	D(G(z)): 0.0728 / 0.0169
[24/50][0/36]	Loss_D: 0.2080	Loss_G: 4.8461	D(x): 0.9183	D(G(z)): 0.0987 / 0.0132
[25/50][0/36]	Loss_D: 0.2491	Loss_G: 4.2578	D(x): 0.8474	D(G(z)): 0.0466 / 0.0284
[26/50][0/36]	Loss_D: 1.4370	Loss_G: 0.9225	D(x): 0.4111	D(G(z)): 0.0110 / 0.4851
[27/50][0/36]	Loss_D: 0.1547	Loss_G: 5.1120	D(x): 0.8961	D(G(z)): 0.0276 / 0.0129
[28/50][0/36]	Loss_D: 0.8567	Loss_G: 6.5480	D(x): 0.9418	D(G(z)): 0.4856 / 0.0033
[29/50][0/36]	Loss_D: 0.6378	Loss_G: 4.9804	D(x): 0.8771	D(G(z)): 0.3173 / 0.0184
[30/50][0/36]	Loss_D: 0.3486	Loss_G: 7.5059	D(x): 0.9430	D(G(z)): 0.1735 / 0.0045
[31/50][0/36]	Loss_D: 0.2469	Loss_G: 5.3903	D(x): 0.9004	D(G(z)): 0.1147 / 0.0071
[32/50][0/36]	Loss_D: 2.1140	Loss_G: 4.0502	D(x): 0.2535	D(G(z)): 0.0006 / 0.0527
[33/50][0/36]	Loss_D: 0.3779	Loss_G: 3.3574	D(x): 0.7900	D(G(z)): 0.0785 / 0.0629
[34/50][0/36]	Loss_D: 0.7457	Loss_G: 6.2508	D(x): 0.9369	D(G(z)): 0.4182 / 0.0050
[35/50][0/36]	Loss_D: 0.4192	Loss_G: 4.5746	D(x): 0.7539	D(G(z)): 0.0488 / 0.0286
[36/50][0/36]	Loss_D: 0.4010	Loss_G: 3.1014	D(x): 0.7694	D(G(z)): 0.0720 / 0.0785
[37/50][0/36]	Loss_D: 0.4838	Loss_G: 3.9613	D(x): 0.8002	D(G(z)): 0.1559 / 0.0388
[38/50][0/36]	Loss_D: 0.6112	Loss_G: 3.6062	D(x): 0.6384	D(G(z)): 0.0287 / 0.0572
[39/50][0/36]	Loss_D: 0.5417	Loss_G: 3.0678	D(x): 0.7755	D(G(z)): 0.1755 / 0.0730
[40/50][0/36]	Loss_D: 0.5360	Loss_G: 3.0343	D(x): 0.7394	D(G(z)): 0.1202 / 0.0796
[41/50][0/36]	Loss_D: 0.3049	Loss_G: 5.8082	D(x): 0.7885	D(G(z)): 0.0089 / 0.0091
[42/50][0/36]	Loss_D: 0.3132	Loss_G: 3.4717	D(x): 0.8981	D(G(z)): 0.1557 / 0.0584
[43/50][0/36]	Loss_D: 0.2647	Loss_G: 5.5635	D(x): 0.9601	D(G(z)): 0.1828 / 0.0060
[44/50][0/36]	Loss_D: 0.5790	Loss_G: 4.6106	D(x): 0.9657	D(G(z)): 0.3423 / 0.0241
[45/50][0/36]	Loss_D: 0.3232	Loss_G: 3.9199	D(x): 0.8089	D(G(z)): 0.0699 / 0.0371
[46/50][0/36]	Loss_D: 0.4083	Loss_G: 4.3659	D(x): 0.8922	D(G(z)): 0.2183 / 0.0195
[47/50][0/36]	Loss_D: 0.5366	Loss_G: 5.3078	D(x): 0.9345	D(G(z)): 0.3024 / 0.0120
[48/50][0/36]	Loss_D: 0.3728	Loss_G: 3.7532	D(x): 0.8676	D(G(z)): 0.1756 / 0.0430
[49/50][0/36]	Loss_D: 0.8418	Loss_G: 1.9751	D(x): 0.5530	D(G(z)): 0.0795 / 0.2058

3、可视化

# 可视化
plt.figure(figsize=(10,5))
plt.title('Generator and Discriminator Loss During Training')
plt.plot(G_losses,label='G')
plt.plot(D_losses,label='D')
plt.xlabel('iterations')
plt.ylabel('Loss')
plt.legend()
plt.show()

fig = plt.figure(figsize=(8,8))

plt.axis('off')

ims = [[plt.imshow(np.transpose(i,(1,2,0)),animated=True)] for i in img_list]

ani = animation.ArtistAnimation(fig,ims,interval=1000,repeat_delay=1000,blit=True)

HTML(ani.to_jshtml())

# 从数据加载器中获取一批真实图像
real_batch = next(iter(dataloader))

# 将真实图像可视化
plt.figure(figsize=(15,15))
plt.subplot(1,2,1)
plt.axis('off')
plt.title('Real Images')
plt.imshow(np.transpose(vutils.make_grid(real_batch[0].to(device)[:64],padding=5,normalize=True).cpu(),(1,2,0)))

# 绘制上一个时期生成的假图像
plt.subplot(1,2,2)
plt.axis('off')
plt.title('Fake Images')
plt.imshow(np.transpose(img_list[-1],(1,2,0)))
plt.show()

五、总结

• DCGAN与GAN的区别是，前者的生成器中使用了反卷积操作，它能放大特征图，从而改变尺寸。
• 而判别器中则使用卷积步长取代空间池化。
• 经过训练，生成的图像已经有部分接近真实图像了。