基于生成对抗网络（GAN）人脸图像生成

基于生成对抗网络（GAN）人脸图像生成

引用

CSDN

1.

https://blog.csdn.net/tjl521314_21/article/details/143337209

生成对抗网络（GAN）是一种强大的深度学习模型，能够生成逼真的图像。本文将详细介绍如何使用GAN生成人脸图像，从环境准备到模型训练，再到结果可视化，手把手教你掌握这一前沿技术。

GAN 原理概述

生成对抗网络通过两个神经网络的对抗性结构来实现目标：

• 生成器（G）：输入随机噪声，通过学习数据的分布模式生成类似真实图像的输出。
• 判别器（D）：用来判断输入的图像是真实的还是生成器生成的。

训练过程中，生成器尝试欺骗判别器，生成逼真的图像，而判别器则不断优化，以区分真实图像与生成图像。这种对抗过程最终使生成器的生成能力逐渐逼近真实图像。

环境准备

首先导入相关库并设置随机种子以确保结果的可复现性。

import random
import os
import torch
import torch.nn as nn
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 matplotlib.pyplot as plt
import numpy as np

超参数设置

在训练GAN之前，首先定义一些关键的超参数：

• batch_size：每个批次的样本数。
• image_size：图像的大小，用于调整输入数据的尺寸。
• nz：潜在向量大小，即生成器的输入维度。
• ngf和ndf：分别控制生成器和判别器中的特征图数量。
• num_epochs：训练的总轮数。
• lr：学习率。

batch_size = 128
image_size = 64
nz = 100
ngf = 64
ndf = 64
num_epochs = 50
lr = 0.0002
beta1 = 0.5

数据加载

通过torchvision.datasets.ImageFolder加载数据，并使用torch.utils.data.DataLoader进行批量处理。数据加载时，通过转换函数调整图像大小，并对其进行归一化处理。

dataroot = "data/GANdata"
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)

网络结构定义

1. 生成器

生成器将随机噪声（潜在向量）通过一系列转置卷积层转换为图像。每层使用ReLU激活函数，最后一层用Tanh激活函数，将输出限制在[-1, 1]。

class Generator(nn.Module):
    def __init__(self):
        super(Generator, self).__init__()
        self.main = nn.Sequential(
            nn.ConvTranspose2d(nz, ngf * 8, 4, 1, 0, bias=False),
            nn.BatchNorm2d(ngf * 8),
            nn.ReLU(True),
            nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf * 4),
            nn.ReLU(True),
            nn.ConvTranspose2d(ngf * 4, ngf * 2, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf * 2),
            nn.ReLU(True),
            nn.ConvTranspose2d(ngf * 2, ngf, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf),
            nn.ReLU(True),
            nn.ConvTranspose2d(ngf, 3, 4, 2, 1, bias=False),
            nn.Tanh()
        )
    def forward(self, input):
        return self.main(input)

2. 判别器

判别器为卷积网络，通过一系列卷积层提取图像特征。每层使用LeakyReLU激活函数，最终输出一个值（真实为1，生成为0）。

class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator, self).__init__()
        self.main = nn.Sequential(
            nn.Conv2d(3, ndf, 4, 2, 1, bias=False),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ndf * 2),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ndf * 4),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Conv2d(ndf * 4, ndf * 8, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ndf * 8),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Conv2d(ndf * 8, 1, 4, 1, 0, bias=False),
            nn.Sigmoid()
        )
    def forward(self, input):
        return self.main(input)

训练过程

训练分为两个部分：判别器和生成器的更新。

1. 判别器的训练

判别器首先接收真实图像样本，计算输出与真实标签的误差。然后判别器接收生成器生成的假图像，再计算输出与假标签的误差。最终判别器的损失是两者的总和。

output = netD(real_cpu).view(-1)
errD_real = criterion(output, label)
errD_real.backward()
fake = netG(noise)
output = netD(fake.detach()).view(-1)
errD_fake = criterion(output, label.fill_(fake_label))
errD_fake.backward()

2. 生成器的训练

生成器的目标是欺骗判别器，因此其损失函数基于判别器将生成图像误识为真实的概率值。

output = netD(fake).view(-1)
errG = criterion(output, label.fill_(real_label))
errG.backward()

训练监控与可视化

训练时，我们记录生成器和判别器的损失，并生成一些样本图像来查看生成器的效果。

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.savefig('Generator and Discriminator Loss During Training.png')

结果可视化

训练结束后，我们将真实图像与生成图像对比，以检验生成器的效果。

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.savefig('Fake Images.png')
plt.show()

总结

这周学习构建了一个深度卷积生成对抗网络（DCGAN），用于生成逼真的人脸图像，通过这周学习对对抗网路的构建有了更深的了解与运用。