深度卷积生成对抗网络_头歌深度卷积生成对抗网络

深度卷积生成对抗网络

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)])
1
2
3
4
5

data_iter = gluon.data.DataLoader(

pokemon.transform_first(transformer), batch_size=batch_size,
1

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
1
2
3
4
5

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)))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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_G8, strides=1, padding=0), # output: (648, 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,
1
2
3
4
5

32, 32)

      nn.Conv2DTranspose(

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

          activation='tanh'))  # output: (3, 64, 64)
1
2
3
4
5

生成一个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)))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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)) 
1
2
3
4
5
6
7

# 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))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

现在训练模型

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.