使用 DCGAN 生成动漫小姐姐头像
1049 字 · 1964 阅读 · 2019 年 02 月 22 日
生成对抗网络是 2014 年由伊恩·古德费洛等人提出的一种非监督式学习方法 arXiv:1406.2661v1，该方法的特点是通过让两个神经网络相互博弈的方式进行学习。DCGAN 是 GAN 的一种十分实用的延伸网络，它由 Alec Radford 等人于 2015 年提出 arXiv:1511.06434。
DCGAN 的全称为：Deep Convolutional Generative Adversarial Networks，翻译成中文也就是：深度卷积生成对抗网络。DCGAN 将卷积网络引入到生成式模型当中来做无监督的训练。这种结构很好地利用了卷积网络强大的特征提取能力，从而有效提高了生成网络的学习效果。
数据集
首先，你需要找到一些动漫人物头像数据。不用特别多，几千张就可以了。这里推荐一个网站 Danbooru，可以直接使用爬虫爬取。
网络搭建
我们可以使用 TensorFlow 或者 PyTorch 来构建网络。这里推荐使用 PyTorch，因为其提供的 Dataloader 数据加载器非常适合用来对图像进行预处理和小批量加载。
下面提供一段示例代码，你需要将头像图片放置在 avatar 目录下方。
import torch
from torchvision import datasets, transforms
# 定义图片处理方法
transforms = transforms.Compose([
transforms.Resize(64),
transforms.CenterCrop(64),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
dataset = datasets.ImageFolder('avatar/',
transform=transforms)
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=16,
shuffle=True,
num_workers=2
)
网络主体需要参考 DCGAN 论文来实现，下面是 DCGAN 网络结构图。
结合网络结构图，就可以实现生成器和判别器网络了。
from torch import nn
class Generator(nn.Module):
def __init__(self):
super(Generator, self).__init__()
self.main = nn.Sequential(
nn.ConvTranspose2d( 100, 64 * 8, 4, 1, 0, bias=False),
nn.BatchNorm2d(64 * 8),
nn.ReLU(True),
nn.ConvTranspose2d(64 * 8, 64 * 4, 4, 2, 1, bias=False),
nn.BatchNorm2d(64 * 4),
nn.ReLU(True),
nn.ConvTranspose2d( 64 * 4, 64 * 2, 4, 2, 1, bias=False),
nn.BatchNorm2d(64 * 2),
nn.ReLU(True),
nn.ConvTranspose2d( 64 * 2, 64, 4, 2, 1, bias=False),
nn.BatchNorm2d(64),
nn.ReLU(True),
nn.ConvTranspose2d( 64, 3, 4, 2, 1, bias=False),
nn.Tanh()
)
def forward(self, input):
return self.main(input)
class Discriminator(nn.Module):
def __init__(self):
super(Discriminator, self).__init__()
self.main = nn.Sequential(
nn.Conv2d(3, 64, 4, 2, 1, bias=False),
nn.BatchNorm2d(64),
nn.LeakyReLU(0.2, inplace=True),
nn.Conv2d(64, 64 * 2, 4, 2, 1, bias=False),
nn.BatchNorm2d(64 * 2),
nn.LeakyReLU(0.2, inplace=True),
nn.Conv2d(64 * 2, 64 * 4, 4, 2, 1, bias=False),
nn.BatchNorm2d(64 * 4),
nn.LeakyReLU(0.2, inplace=True),
nn.Conv2d(64 * 4, 64 * 8, 4, 2, 1, bias=False),
nn.BatchNorm2d(64 * 8),
nn.LeakyReLU(0.2, inplace=True),
nn.Conv2d(64 * 8, 1, 4, 1, 0, bias=False),
nn.Sigmoid()
)
def forward(self, input):
return self.main(input)
定义损失函数和优化器是必不可少的步骤：
netD = Discriminator()
netG = Generator()
criterion = nn.BCELoss()
lr = 0.0002
optimizerD = torch.optim.Adam(netD.parameters(), lr=lr, betas=(0.5, 0.999))
optimizerG = torch.optim.Adam(netG.parameters(), lr=lr, betas=(0.5, 0.999))
最后就可以完成网络训练，并使用噪声数据进行测试了。
from torchvision.utils import make_grid
from matplotlib import pyplot as plt
from IPython import display
%matplotlib inline
epochs = 100
for epoch in range(epochs):
for n, (images, _) in enumerate(dataloader):
real_labels = torch.ones(images.size(0))
fake_labels = torch.zeros(images.size(0))
netD.zero_grad()
output = netD(images)
lossD_real = criterion(output.squeeze(), real_labels)
noise = torch.randn(images.size(0), 100, 1, 1)
fake_images = netG(noise)
output2 = netD(fake_images.detach())
lossD_fake = criterion(output2.squeeze(), fake_labels)
lossD = lossD_real + lossD_fake
lossD.backward()
optimizerD.step()
netG.zero_grad()
output3 = netD(fake_images)
lossG = criterion(output3.squeeze(), real_labels)
lossG.backward()
optimizerG.step()
fixed_noise = torch.randn(64, 100, 1, 1)
fixed_images = netG(fixed_noise)
fixed_images = make_grid(fixed_images.data,
nrow=8, normalize=True).cpu()
plt.figure(figsize=(6, 6))
plt.title("Epoch[{}/{}], Batch[{}/{}]".format(epoch+1,
epochs,
n+1,
len(dataloader)))
plt.imshow(fixed_images.permute(1, 2, 0).numpy())
display.display(plt.gcf())
display.clear_output(wait=True)
以下，是迭代 100 个 Epoch 之后的测试结果，可以看到效果还是不错的。
GAN 是近些年来快速发展的网络结构，但由于其模型过于自由，很容易出现训练不收敛，模型崩溃等问题。不过在数据增强，图片生成等方面，GAN 还是有很多的发展空间。未来值得期待。