《昇思25天学习打卡营第24天》

接续上一天的学习任务，我们要继续进行下一步的操纵
构造网络

当处理完数据后，就可以来进行网络的搭建了。按照DCGAN论文中的描述，所有模子权重均应从mean为0，sigma为0.02的正态分布中随机初始化。
接下来相识一下其他内容
生成器

生成器G的功能是将隐向量z映射到数据空间。实践场景中，该功能是通过一系列Conv2dTranspose转置卷积层来完成的，每个层都与BatchNorm2d层和ReLu激活层配对，输出数据会颠末tanh函数，使其返回[-1,1]的数据范围内。
DCGAN论文生成图像如下所示：

通过输入部分中设置的nz、ngf和nc来影响代码中的生成器结构。nz是隐向量z的长度，ngf与通过生成器传播的特征图的巨细有关，nc是输出图像中的通道数。
代码实现

1. import mindspore as ms
2. from mindspore import nn, ops
3. from mindspore.common.initializer import Normal
5. weight_init = Normal(mean=0, sigma=0.02)
6. gamma_init = Normal(mean=1, sigma=0.02)
8. class Generator(nn.Cell):
9.     """DCGAN网络生成器"""
11.     def __init__(self):
12.         super(Generator, self).__init__()
13.         self.generator = nn.SequentialCell(
14.             nn.Conv2dTranspose(nz, ngf * 8, 4, 1, 'valid', weight_init=weight_init),
15.             nn.BatchNorm2d(ngf * 8, gamma_init=gamma_init),
16.             nn.ReLU(),
17.             nn.Conv2dTranspose(ngf * 8, ngf * 4, 4, 2, 'pad', 1, weight_init=weight_init),
18.             nn.BatchNorm2d(ngf * 4, gamma_init=gamma_init),
19.             nn.ReLU(),
20.             nn.Conv2dTranspose(ngf * 4, ngf * 2, 4, 2, 'pad', 1, weight_init=weight_init),
21.             nn.BatchNorm2d(ngf * 2, gamma_init=gamma_init),
22.             nn.ReLU(),
23.             nn.Conv2dTranspose(ngf * 2, ngf, 4, 2, 'pad', 1, weight_init=weight_init),
24.             nn.BatchNorm2d(ngf, gamma_init=gamma_init),
25.             nn.ReLU(),
26.             nn.Conv2dTranspose(ngf, nc, 4, 2, 'pad', 1, weight_init=weight_init),
27.             nn.Tanh()
28.             )
30.     def construct(self, x):
31.         return self.generator(x)
33. generator = Generator()

复制代码

鉴别器

鉴别器D是一个二分类网络模子，输出判断该图像为真实图的概率。
代码实现

1. class Discriminator(nn.Cell):
2.     """DCGAN网络判别器"""
4.     def __init__(self):
5.         super(Discriminator, self).__init__()
6.         self.discriminator = nn.SequentialCell(
7.             nn.Conv2d(nc, ndf, 4, 2, 'pad', 1, weight_init=weight_init),
8.             nn.LeakyReLU(0.2),
9.             nn.Conv2d(ndf, ndf * 2, 4, 2, 'pad', 1, weight_init=weight_init),
10.             nn.BatchNorm2d(ngf * 2, gamma_init=gamma_init),
11.             nn.LeakyReLU(0.2),
12.             nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 'pad', 1, weight_init=weight_init),
13.             nn.BatchNorm2d(ngf * 4, gamma_init=gamma_init),
14.             nn.LeakyReLU(0.2),
15.             nn.Conv2d(ndf * 4, ndf * 8, 4, 2, 'pad', 1, weight_init=weight_init),
16.             nn.BatchNorm2d(ngf * 8, gamma_init=gamma_init),
17.             nn.LeakyReLU(0.2),
18.             nn.Conv2d(ndf * 8, 1, 4, 1, 'valid', weight_init=weight_init),
19.             )
20.         self.adv_layer = nn.Sigmoid()
22.     def construct(self, x):
23.         out = self.discriminator(x)
24.         out = out.reshape(out.shape[0], -1)
25.         return self.adv_layer(out)
27. discriminator = Discriminator()

复制代码

接下来进入模子训练阶段
模子训练

其中分为几个要素：
丧失函数

当定义了D和G后，接下来将使用MindSpore中定义的二进制交织熵丧失函数BCELoss。
优化器

训练模子：训练鉴别器和训练生成器。

实现模子训练正向逻辑：

1. def generator_forward(real_imgs, valid):
2.     # 将噪声采样为发生器的输入
3.     z = ops.standard_normal((real_imgs.shape[0], nz, 1, 1))
5.     # 生成一批图像
6.     gen_imgs = generator(z)
8.     # 损失衡量发生器绕过判别器的能力
9.     g_loss = adversarial_loss(discriminator(gen_imgs), valid)
11.     return g_loss, gen_imgs
13. def discriminator_forward(real_imgs, gen_imgs, valid, fake):
14.     # 衡量鉴别器从生成的样本中对真实样本进行分类的能力
15.     real_loss = adversarial_loss(discriminator(real_imgs), valid)
16.     fake_loss = adversarial_loss(discriminator(gen_imgs), fake)
17.     d_loss = (real_loss + fake_loss) / 2
18.     return d_loss
20. grad_generator_fn = ms.value_and_grad(generator_forward, None,
21.                                       optimizer_G.parameters,
22.                                       has_aux=True)
23. grad_discriminator_fn = ms.value_and_grad(discriminator_forward, None,
24.                                           optimizer_D.parameters)
26. @ms.jit
27. def train_step(imgs):
28.     valid = ops.ones((imgs.shape[0], 1), mindspore.float32)
29.     fake = ops.zeros((imgs.shape[0], 1), mindspore.float32)
31.     (g_loss, gen_imgs), g_grads = grad_generator_fn(imgs, valid)
32.     optimizer_G(g_grads)
33.     d_loss, d_grads = grad_discriminator_fn(imgs, gen_imgs, valid, fake)
34.     optimizer_D(d_grads)
36.     return g_loss, d_loss, gen_imgs

复制代码

代码训练

结果展示就不多说了当作品

文末附上打卡时间

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。