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

骑猪玩狗2024-07-26 16:11

基础任务

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

一、前期准备

1、导入第三方库

python 复制代码 
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)
  1. 定义超参数
python 复制代码 
# 设置超参数
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、导入数据

python 复制代码 
# 设置数据集，并用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、初始化权重

python 复制代码 
# 自定义权重初始化函数，作用于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、定义生成器

python 复制代码 
# 定义生成器
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)
python 复制代码 
# 创建生成器
netG = Generator().to(device)
# 使用'weights_init'函数对所有权重进行随机初始化，
# 平均值(mean)设置为0，标准差(stdev)设置为0.02.
netG.apply(weights_init)
# 打印生成器
print(netG)

3、定义判别器

python 复制代码 
# 定义判别器
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)
python 复制代码 
# 创建判别器
netD = Discriminator().to(device)
# 使用'weights_init'函数对所有权重进行随机初始化，
# 平均值(mean)设置为0，标准差(stdev)设置为0.2
netD.apply(weights_init)
# 打印判别器
print(netD)

四、训练模型

1、定义训练参数

python 复制代码 
# 初始化二进制交叉熵损失函数
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、训练模型

python 复制代码 
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
python 复制代码 
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、可视化

python 复制代码 
# 可视化
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()
python 复制代码 
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())
python 复制代码 
# 从数据加载器中获取一批真实图像
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的区别是，前者的生成器中使用了反卷积操作，它能放大特征图，从而改变尺寸。
  • 而判别器中则使用卷积步长取代空间池化。
  • 经过训练，生成的图像已经有部分接近真实图像了。
相关推荐
人工智能培训3 天前
规范实操筑牢防线，全域落地安全物理协作
人工智能·深度学习·神经网络·机器学习·生成对抗网络
学习论之费曼学习法4 天前
AI 入门 30 天挑战 - Day 19 费曼学习法版 - GAN 生成对抗网络
人工智能·学习·生成对抗网络
神仙别闹4 天前
基于GAN的恶意软件对抗样本生成
人工智能·神经网络·生成对抗网络
这张生成的图像能检测吗4 天前
（论文速读）结合噪声制导和全局特征的生成对抗网络生成了高质量的缺陷样本
人工智能·深度学习·神经网络·生成对抗网络·计算机视觉
大龄程序员狗哥7 天前
第22篇：生成对抗网络（GAN）入门——AI艺术创作的“造假”与“打假”（概念入门）
人工智能·神经网络·生成对抗网络
大龄程序员狗哥7 天前
第23篇：GAN实战：生成二次元头像——创造属于你的虚拟形象（项目实战）
人工智能·神经网络·生成对抗网络
CelestialYuxin9 天前
第13章课时48 GAN-2
人工智能·神经网络·生成对抗网络
熊猫钓鱼>_>14 天前
生成对抗网络（GAN）通俗解析：AI如何学会“无中生有”？
图像处理·人工智能·神经网络·生成对抗网络·ai·gan·博弈
苯酸氨酰糖化物16 天前
基于深度学习（U-Net架构下改良GAN与ViT算法）的高效肺部多模态疾病预测模型
人工智能·深度学习·算法·生成对抗网络·视觉检测
永霖光电_UVLED17 天前
奇瑞加速欧洲布局，扩产计划开启新征程
人工智能·生成对抗网络·汽车·制造·激光
热门推荐
01要裂开了！ChatGPT要手机号验证了？注册Codex要求验证电话号码怎么办？2026年登陆Codex要手机号验证的解决办法02GitHub 镜像站点03裂开！ChatGPT 居然开始要手机号验证，附详细解决方法04【AI】2026 年具身智能模型和世界模型总结05Codex 接入 DeepSeek API 完整配置文档062026年4月AI大事件深度解读：大模型竞争进入“深水区“07实测可用｜小米 MiMo 百万亿 Token 免费领，开发者速冲08零基础教你claude code 接入 deepseek V409在Windows 11上安装Docker的踩坑记录102026年AI前瞻：量子AI、具身智能与科学发现的新纪元