深度卷积生成对抗网络

深度卷积生成对抗网络

Deep Convolutional Generative Adversarial Networks

GANs如何工作的基本思想。可以从一些简单的，易于抽样的分布，如均匀分布或正态分布中提取样本，并将其转换成与某些数据集的分布相匹配的样本。虽然例子匹配一个二维高斯分布得到了交叉点，不是特别令人兴奋。

将演示如何使用GANs生成照片级真实感图像。将以深卷积GAN（DCGAN）为基础建立模型。将借用卷积体系结构，已经被证明在区分计算机视觉问题上是如此成功，并展示如何通过GANs来利用来生成真实感图像。

from mxnet import gluon, init, np, npx

from mxnet.gluon import nn

from d2l import mxnet as d2l

npx.set_np()

1. The Pokemon Dataset

将使用的数据集是从pokemondb获得的Pokemon精灵集合。首先下载、提取并加载此数据集。

#@save

d2l.DATA_HUB['pokemon'] = (d2l.DATA_URL + 'pokemon.zip',

'c065c0e2593b8b161a2d7873e42418bf6a21106c')

data_dir = d2l.download_extract('pokemon')

pokemon = gluon.data.vision.datasets.ImageFolderDataset(data_dir)

Downloading ../data/pokemon.zip from

http://d2l-data.s3-accelerate.amazonaws.com/pokemon.zip...

将每个图像调整为64×64。ToTensor变换将像素值投影到[0,1]，而生成器将使用tanh函数来获得[-1,1]。因此，用0.5平均值和0.5与值范围匹配的标准偏差。

batch_size = 256

transformer = gluon.data.vision.transforms.Compose([

gluon.data.vision.transforms.Resize(64),

gluon.data.vision.transforms.ToTensor(),

gluon.data.vision.transforms.Normalize(0.5, 0.5)

])

data_iter = gluon.data.DataLoader(

pokemon.transform_first(transformer), batch_size=batch_size,

shuffle=True, num_workers=d2l.get_dataloader_workers())

让想象一下前20幅图像。

d2l.set_figsize((4, 4))

for X, y in data_iter:

imgs = X[0:20,:,:,:].transpose(0, 2, 3, 1)/2+0.5

d2l.show_images(imgs, num_rows=4, num_cols=5)

break

2. The Generator

生成器Generator需要映射噪声变量z∈Rd，一个length-d图像的宽度和宽度64×64。使用转置卷积层来扩大输入大小的全卷积网络。生成器的基本块包含一个转置卷积层，然后是批处理规范化和ReLU激活。

class G_block(nn.Block):

def __init__(self, channels, kernel_size=4,

strides=2, padding=1, **kwargs):

super(G_block, self).__init__(**kwargs)

self.conv2d_trans = nn.Conv2DTranspose(

channels, kernel_size, strides, padding, use_bias=False)

self.batch_norm = nn.BatchNorm()

self.activation = nn.Activation('relu')

def forward(self, X):

return self.activation(self.batch_norm(self.conv2d_trans(X)))

x = np.zeros((2, 3, 16, 16))

g_blk = G_block(20)

g_blk.initialize()

g_blk(x).shape

(2, 20, 32, 32)

如果将转置卷积层更改为4×4内核，1×1跨步和零填充。输入大小为1×1输出宽度和高度分别增加3。

x = np.zeros((2, 3, 1, 1))

g_blk = G_block(20, strides=1, padding=0)

g_blk.initialize()

g_blk(x).shape

(2, 20, 4, 4)

生成器由四个基本块组成，将输入的宽度和高度从1增加到32。同时，首先将潜在变量投影到64×8通道，然后每次将通道减半。最后，利用转置卷积层产生输出。进一步将宽度和高度加倍以匹配所需的64×64形状，并将通道大小减小到3。tanh激活函数用于将输出值投影到（-1,1）范围。

n_G = 64

net_G = nn.Sequential()

net_G.add(G_block(n_G*8, strides=1, padding=0), # output: (64*8, 4, 4)

G_block(n_G*4), # output: (64*4, 8, 8)

G_block(n_G*2), # output: (64*2, 16, 16)

G_block(n_G), # output: (64, 32, 32)

nn.Conv2DTranspose(

3, kernel_size=4, strides=2, padding=1, use_bias=False,

activation='tanh')) # output: (3, 64, 64)

生成一个100维的潜在变量来验证生成器的输出形状。

x = np.zeros((1, 100, 1, 1))

net_G.initialize()

net_G(x).shape

(1, 3, 64, 64)

3. Discriminator

该鉴别器Discriminator是一个普通的卷积网络，但使用泄漏ReLU作为其激活函数。鉴于α∈[0,1]。R ReLU if α=0, and an identity function if α=1. For α∈(0,1), leaky ReLU。可以看出，如果α=0，以及如果α=1. 为α∈（0,1），leaky ReLU是一个非线性函数，对负输入给出非零输出。目的是解决“dying ReLU”问题，即神经元可能总是输出一个负值，因此由于ReLU的梯度为0，因此无法取得任何进展。
alphas = [0, 0.2, 0.4, .6, .8, 1]
x = np.arange(-2, 1, 0.1)
Y = [nn.LeakyReLU(alpha)(x).asnumpy() for alpha in alphas]
d2l.plot(x.asnumpy(), Y, 'x', 'y', alphas)

鉴别器的基本模块是卷积层，然后是批处理规范化层和泄漏ReLU激活。卷积层的超参数类似于生成块中的转置卷积层。

class D_block(nn.Block):
def __init__(self, channels, kernel_size=4, strides=2,
padding=1, alpha=0.2, **kwargs):
super(D_block, self).__init__(**kwargs)
self.conv2d = nn.Conv2D(
channels, kernel_size, strides, padding, use_bias=False)
self.batch_norm = nn.BatchNorm()
self.activation = nn.LeakyReLU(alpha)
def forward(self, X):
return self.activation(self.batch_norm(self.conv2d(X)))

x = np.zeros((2, 3, 16, 16))
d_blk = D_block(20)
d_blk.initialize()
d_blk(x).shape
(2, 20, 8, 8)
鉴别器是发生器的镜像。
n_D = 64
net_D = nn.Sequential()
net_D.add(D_block(n_D), # output: (64, 32, 32)
D_block(n_D*2), # output: (64*2, 16, 16)
D_block(n_D*4), # output: (64*4, 8, 8)
D_block(n_D*8), # output: (64*8, 4, 4)
nn.Conv2D(1, kernel_size=4, use_bias=False)) # output: (1, 1, 1)
使用带输出通道的卷积层1作为最后一层获得单个预测值。
x = np.zeros((1, 3, 64, 64))
net_D.initialize()
net_D(x).shape
(1, 1, 1, 1)
4. Training
对生成器和鉴别器使用学习速率，改变β1在亚当中0.9到0.5。降低了动量的平滑度，即过去梯度的指数加权移动平均值，以处理快速变化的梯度，因为生成器和鉴别器相互竞争。另外，用随机产生的随机噪声来加速计算。
def train(net_D, net_G, data_iter, num_epochs, lr, latent_dim,
ctx=d2l.try_gpu()):
loss = gluon.loss.SigmoidBCELoss()
net_D.initialize(init=init.Normal(0.02), force_reinit=True, ctx=ctx)
net_G.initialize(init=init.Normal(0.02), force_reinit=True, ctx=ctx)
trainer_hp = {'learning_rate': lr, 'beta1': 0.5}
trainer_D = gluon.Trainer(net_D.collect_params(), 'adam', trainer_hp)
trainer_G = gluon.Trainer(net_G.collect_params(), 'adam', trainer_hp)
animator = d2l.Animator(xlabel='epoch', ylabel='loss',
xlim=[1, num_epochs], nrows=2, figsize=(5, 5),
legend=['discriminator', 'generator'])
animator.fig.subplots_adjust(hspace=0.3)
for epoch in range(1, num_epochs + 1):
# Train one epoch
timer = d2l.Timer()
metric = d2l.Accumulator(3) # loss_D, loss_G, num_examples
for X, _ in data_iter:
batch_size = X.shape[0]
Z = np.random.normal(0, 1, size=(batch_size, latent_dim, 1, 1))
X, Z = X.as_in_ctx(ctx), Z.as_in_ctx(ctx),
metric.add(d2l.update_D(X, Z, net_D, net_G, loss, trainer_D),
d2l.update_G(Z, net_D, net_G, loss, trainer_G),
batch_size)
# Show generated examples
Z = np.random.normal(0, 1, size=(21, latent_dim, 1, 1), ctx=ctx)
# Normalize the synthetic data to N(0, 1)
fake_x = net_G(Z).transpose(0, 2, 3, 1) / 2 + 0.5
imgs = np.concatenate(
[np.concatenate([fake_x[i * 7 + j] for j in range(7)], axis=1)
for i in range(len(fake_x)//7)], axis=0)
animator.axes[1].cla()
animator.axes[1].imshow(imgs.asnumpy())
# Show the losses
loss_D, loss_G = metric[0] / metric[2], metric[1] / metric[2]
animator.add(epoch, (loss_D, loss_G))
print('loss_D %.3f, loss_G %.3f, %d examples/sec on %s' % (
loss_D, loss_G, metric[2]/timer.stop(), ctx))
现在训练模型
latent_dim, lr, num_epochs = 100, 0.005, 40
train(net_D, net_G, data_iter, num_epochs, lr, latent_dim)
loss_D 0.011, loss_G 7.465, 2663 examples/sec on gpu(0)

 5. Summary

· DCGAN architecture has four convolutional layers for the Discriminator and four “fractionally-strided” convolutional layers for the Generator.
· The Discriminator is a 4-layer strided convolutions with batch normalization (except its input layer) and leaky ReLU activations.
· Leaky ReLU is a nonlinear function that give a non-zero output for a negative input. It aims to fix the “dying ReLU” problem and helps the gradients flow easier through the architecture.