提交 bb080b6b 编写于 作者: W wizardforcel

2020-12-07 21:47:16

上级 54a0a8eb
......@@ -411,7 +411,7 @@ AlphaGo 及其继任者使用蒙特卡洛树搜索算法,基于先前通过机
# 电影制作
几乎可以肯定的是在接下来的几十年内可以制作出 100% 计算机生成的电影。 构想一个系统,其中输入是一个书面剧本,而输出是一个完整的故事片,这是不容置疑的。 此外,天然发电机已经取得了一些进步。 因此,最终甚至不需要脚本。 让我们进一步探讨。
几乎可以肯定的是在接下来的几十年内可以制作出 100% 计算机生成的电影。 构想一个系统,其中输入是一个书面剧本,而输出是一个完整的故事片,这是不容置疑的。 此外,天然生成器已经取得了一些进步。 因此,最终甚至不需要脚本。 让我们进一步探讨。
**仿冒品**
......
......@@ -27,7 +27,7 @@ RNN 背后的数学有时可能会令人不知所措。 在深入研究 RNN 之
现在让我们进入神经网络的一些基础知识。 顾名思义,*神经*网络从大脑神经元的结构中获得灵感。 神经网络中的神经元大致模拟了人类神经元的结构和功能。 对于一般的大脑,尤其是神经元,我们有很多不了解的地方。 但在基本级别上,神经元接受输入,并且如果达到阈值,它将触发输出。 用数学术语来说,*人工*神经元是数学函数的容器,其唯一的任务是通过将给定的输入应用于函数来传递输出。
既然我们已经了解了使神经网络*滴答作响*的原因以及使它们发火的原因,那么让我们了解一些用于触发神经网络的常用功能。 这些功能通常称为,称为*激活功能*,因为它们在达到阈值时就会激活。 您可以将任何类型的功能用作激活功能,但以下是一些用作激活功能的常用功能:
既然我们已经了解了使神经网络*滴答作响*的原因以及使它们发火的原因,那么让我们了解一些用于触发神经网络的常用功能。 这些功能通常称为,称为*激活函数*,因为它们在达到阈值时就会激活。 您可以将任何类型的功能用作激活函数,但以下是一些用作激活函数的常用功能:
* 步进函数
* Sigmoid 函数
......@@ -104,7 +104,7 @@ f(x) = max(0.3 * x, x)
泄漏的 ReLU 具有理论上的优势,即在所有值下都受到`x`的影响,因此可以更好地利用所有输入提供的信息。
鉴于 ReLU 的特性和优势,它经常是深度学习从业人员和研究人员选择的激活功能
鉴于 ReLU 的特性和优势,它经常是深度学习从业人员和研究人员选择的激活函数
现在,我们已经介绍了 RNN 的一些基本功能,并讨论了它们的一些关键功能,下面让我们深入研究其实际的体系结构。
......
......@@ -31,11 +31,11 @@ GAN 是由两个网络(生成器网络和判别器网络)组成的深度神
# 什么是发电机网络?
# 什么是生成器网络?
生成器网络使用现有数据来生成新数据。 例如,它可以使用现有图像生成新图像。 生成器的主要目标是从随机生成的数字向量(称为**潜在空间**)生成数据(例如图像,视频,音频或文本)。 在创建发电机网络时,我们需要指定网络的目标。 这可能是图像生成,文本生成,音频生成,视频生成等。
生成器网络使用现有数据来生成新数据。 例如,它可以使用现有图像生成新图像。 生成器的主要目标是从随机生成的数字向量(称为**潜在空间**)生成数据(例如图像,视频,音频或文本)。 在创建生成器网络时,我们需要指定网络的目标。 这可能是图像生成,文本生成,音频生成,视频生成等。
......@@ -100,7 +100,7 @@ GAN 的体系结构具有两个基本元素:生成器网络和判别器网络
# 发电机的架构
# 生成器的架构
......@@ -115,7 +115,7 @@ GAN 的体系结构具有两个基本元素:生成器网络和判别器网络
上表显示了隐藏层的配置,以及网络中的输入和输出层。
下图显示了发电机网络中每一层的张量流以及张量的输入和输出形状:
下图显示了生成器网络中每一层的张量流以及张量的输入和输出形状:
![](img/9c07dac5-3b55-444a-b7a5-6119c5d9370b.png)
......@@ -151,7 +151,7 @@ The architecture of the discriminator network
1. 最初,它接收形状为`28x28`的输入。
2. 输入层采用输入张量,该张量是形状为( `batch_sizex28x28` )的张量,然后将其直接传递到第一隐藏层。
3. 接下来,平坦化层将张量平坦化为 784 维向量,该向量将传递到第一隐藏(密集)层。 第一和第二隐藏层将其修改为 500 维向量。
4. 最后一层是输出层,又是一个密集层,其中一个单元( 神经元)和乙状结肠为激活功能。 它输出一个值为 0 或 1 的值。值为 0 表示提供的图像是假的,而值为 1 表示提供的图像是真实的。
4. 最后一层是输出层,又是一个密集层,其中一个单元( 神经元)和乙状结肠为激活函数。 它输出一个值为 0 或 1 的值。值为 0 表示提供的图像是假的,而值为 1 表示提供的图像是真实的。
......@@ -391,7 +391,7 @@ For a list of all the GANs in existence, refer to *The GAN Zoo*, an article by A
模式崩溃是指发电机网络生成变化不大的样本或模型开始生成相同图像的情况。 有时,概率分布实际上是多峰的,非常复杂。 这意味着它可能包含来自不同观察值的数据,并且对于样品的不同子图可能具有多个峰。 有时,GAN 不能为数据的多峰概率分布建模,并且会遭受模式崩溃。 所有生成的样本实际上都相同的 情况称为完全崩溃。
模式崩溃是指生成器网络生成变化不大的样本或模型开始生成相同图像的情况。 有时,概率分布实际上是多峰的,非常复杂。 这意味着它可能包含来自不同观察值的数据,并且对于样品的不同子图可能具有多个峰。 有时,GAN 不能为数据的多峰概率分布建模,并且会遭受模式崩溃。 所有生成的样本实际上都相同的 情况称为完全崩溃。
我们可以使用许多方法来克服模式崩溃问题。 其中包括:
......@@ -413,7 +413,7 @@ For a list of all the GANs in existence, refer to *The GAN Zoo*, an article by A
当我们使用 Sigmoid 和 Tanh 等 培养功能时,这也是一个问题。 乙状结肠激活函数将值限制在 0 到 1 之间,将`x`的大值转换为大约 1,将`x`的小值或负值转换为大约零。 Tanh 激活函数将输入值压缩为 -1 和 1 之间的范围,将大输入值转换为大约 1,将小值转换为大约负 1。当应用反向传播时,我们使用微分链式规则, 有倍增作用。 当我们到达网络的初始层时,梯度(误差)呈指数下降,从而导致梯度消失。
为了克服这个问题,我们可以使用激活功能,例如 ReLU,LeakyReLU 和 PReLU。 这些激活函数的梯度在反向传播期间不会饱和,从而导致神经网络的有效训练。 另一种解决方案是使用批处理规范化,该规范化将对网络隐藏层的输入规范化。
为了克服这个问题,我们可以使用激活函数,例如 ReLU,LeakyReLU 和 PReLU。 这些激活函数的梯度在反向传播期间不会饱和,从而导致神经网络的有效训练。 另一种解决方案是使用批处理规范化,该规范化将对网络隐藏层的输入规范化。
......
......@@ -24,7 +24,7 @@
**3D 生成对抗网络****3D-GAN**)是 GAN 的变体,就像 StackGAN,CycleGAN 和`S`**上层分辨率一样 生成对抗网络****SRGAN**。 与朴素 GAN 相似,它具有生成器和判别器模型。 这两个网络都使用 3D 卷积层,而不是使用 2D 卷积。 如果提供足够的数据,它可以学习生成具有良好视觉质量的 3D 形状。
**3D 生成对抗网络****3D-GAN**)是 GAN 的变体,就像 StackGAN,CycleGAN 和**超分辨率生成对抗网络****SRGAN**)一样 。 与朴素 GAN 相似,它具有生成器和判别器模型。 这两个网络都使用 3D 卷积层,而不是使用 2D 卷积。 如果提供足够的数据,它可以学习生成具有良好视觉质量的 3D 形状。
在仔细查看 3D-GAN 网络之前,让我们了解 3D 卷积。
......@@ -36,7 +36,7 @@
简而言之,3D 卷积操作沿`x``y``z`这三个方向对输入数据应用 3D 滤波器。 此操作将创建 3D 特征图的堆叠列表。 输出的形状类似于立方体或长方体的形状。 下图说明了 3D 卷积操作。 左立方体的突出显示部分是输入数据。 内核位于中间,形状为(3,3,3)。 右侧的块是卷积运算的输出:
简而言之,3D 卷积操作沿`x``y``z`这三个方向对输入数据应用 3D 滤波器。 此操作将创建 3D 特征图的堆叠列表。 输出的形状类似于立方体或长方体的形状。 下图说明了 3D 卷积操作。 左立方体的突出显示部分是输入数据。 内核位于中间,形状为`(3, 3, 3)`。 右侧的块是卷积运算的输出:
![](img/9128ea2e-31f5-472a-8ebc-f3add1a716e0.png)
......@@ -50,7 +50,7 @@
3D-GAN 中的两个网络都是深度卷积神经网络。 发电机网络通常是一个上采样网络。 它对噪声向量(来自概率潜在空间的向量)进行上采样,以生成形状为的 3D 图像,该形状的长度,宽度,高度和通道与输入图像相似。 判别器网络是下采样网络。 使用一系列 3D 卷积运算和密集层,它可以识别提供给它的输入数据是真实的还是伪造的。
3D-GAN 中的两个网络都是深度卷积神经网络。 生成器网络通常是一个上采样网络。 它对噪声向量(来自概率潜在空间的向量)进行上采样,以生成形状为的 3D 图像,该形状的长度,宽度,高度和通道与输入图像相似。 判别器网络是下采样网络。 使用一系列 3D 卷积运算和密集层,它可以识别提供给它的输入数据是真实的还是伪造的。
在接下来的两节中,我们将介绍生成器和判别器网络的体系结构。
......@@ -58,16 +58,16 @@
# 发电机网络的架构
# 生成器网络的架构
生成器网络包含五个体积完全卷积的层,具有以下配置:
* **卷积层**:5
* **过滤器**: 512 , 256 , 128 和 64 , 1
* **内核大小**4 x 4 x 4, 4 x 4 x 4, 4 x 4 x 4, 4 x 4 x 4, 4 x 4 x 4
* **步幅**:1、2、2、2、2 或(1,1),(2,2),(2,2),(2,2),(2,2)
* **过滤器**: 512,256,128 和 64,1
* **内核大小**`4 x 4 x 4``4 x 4 x 4``4 x 4 x 4``4 x 4 x 4``4 x 4 x 4`
* **步幅**:1、2、2、2、2 或`(1, 1), (2, 2), (2, 2), (2, 2), (2, 2)`
* **批量标准化**:是,是,是,是,否
* **激活**:ReLU, ReLU, ReLU, ReLU,Sigmoid
* **汇聚层**:否,否,否,否,否
......@@ -100,21 +100,21 @@ A fully convolutional network is a network without fully connected dense layers
* **通道**:64、128、256、512、1
* **内核大小**:4、4、4、4、4、4
* **大步前进**:2、2、2、2、1
* **激活**泄漏 ReLU,泄漏 ReLU,泄漏 ReLU,泄漏 ReLU,乙状结肠
* **激活**LReLU,LReLU,LReLU,LReLU,Sigmoid
* **批量标准化**:是,是,是,是,无
* **汇聚层**:否,否,否,否,否
* **线性层**:否,否,否,否,否
网络的输入和输出如下:
* **输入**:形状为(64,64,64)的 3D 图像
* **输入**:形状为`(64, 64, 64)`的 3D 图像
* **输出**:输入数据属于真实或假类的概率
下图显示了判别器网络中每一层的张量流以及张量的输入和输出形状。 这将使您对判别器网络有更好的了解:
![](img/7fc08303-569e-499f-bc91-e2ae9684f947.png)
判别器网络主要镜像生成器网络。 一个重要的区别是它使用中的 LeakyReLU 代替了 ReLU 作为激活功能。 而且,网络末端的 S 形层用于二进制分类,并预测所提供的图像是真实的还是伪造的。 最后一层没有规范化层,但是其他层使用批处理规范化输入。
判别器网络主要镜像生成器网络。 一个重要的区别是它使用中的 LeakyReLU 代替了 ReLU 作为激活函数。 而且,网络末端的 Sigmoid 层用于二进制分类,并预测所提供的图像是真实的还是伪造的。 最后一层没有规范化层,但是其他层使用批处理规范化输入。
......@@ -128,7 +128,7 @@ A fully convolutional network is a network without fully connected dense layers
![](img/e8c1a187-a93a-40e6-92a9-3c823a391fd9.png)
在这里, *log(D(x))*是二进制交叉熵损失或分类损失, *log(1-D(G(z)))*是对抗损失,`z`是来自概率空间 *p(z)*的潜向量, *D(x)*是判别器网络的输出, *G(z)* 是发电机网络的输出。
在这里, `log(D(X))`是二进制交叉熵损失或分类损失,`log(1 - D(G(Z)))`是对抗损失,`z`是来自概率空间`p(Z)`的潜向量, `D(X)`是判别器网络的输出, `G(Z)`是生成器网络的输出。
......@@ -156,7 +156,7 @@ A fully convolutional network is a network without fully connected dense layers
该项目的 urce 代码可在 GitHub 上的[以下链接](https://github.com/PacktPublishing/Generative-Adversarial-Networks-Projects)中找到。
该项目的代码可在 GitHub 上的[以下链接](https://github.com/PacktPublishing/Generative-Adversarial-Networks-Projects)中找到。
运行以下命令来设置项目:
......@@ -260,7 +260,7 @@ A series of voxels in a 3D image. The shaded region is a single voxel.
3D ShapeNets 数据集包含 `.mat` [ 文件格式。 我们将这些`.mat`文件转换为 NumPy ndarrays。 我们还将可视化 3D 图像,以直观了解数据集。
3D ShapeNets 数据集包含`.mat`文件格式。 我们将这些`.mat`文件转换为 NumPy N 维数组。 我们还将可视化 3D 图像,以直观了解数据集。
执行以下代码以从`.mat`文件加载 3D 图像:
......@@ -278,7 +278,7 @@ import numpy as np
voxels = np.pad(voxels, (1, 1), 'constant', constant_values=(0, 0))
```
`pad()`方法采用四个参数,它们是实际体素的 ndarray,需要填充到每个轴边缘的值的数量,模式值(`constant`)和`constant_values` 被填充。
`pad()`方法采用四个参数,它们是实际体素的 N 维数组,需要填充到每个轴边缘的值的数量,模式值(`constant`)和`constant_values` 被填充。
3. 然后,使用`scipy.ndimage`模块中的`zoom()`功能将 3D 图像转换为尺寸为`64x64x64`的 3D 图像。
......@@ -341,17 +341,17 @@ plt.show() plt.savefig(file_path)
在本节中,我们将在 Keras 框架中实现生成器网络和判别器网络。 我们需要创建两个 Keras 模型。 这两个网络都有各自独立的权重值。 让我们从发电机网络开始。
在本节中,我们将在 Keras 框架中实现生成器网络和判别器网络。 我们需要创建两个 Keras 模型。 这两个网络都有各自独立的权重值。 让我们从生成器网络开始。
# 发电机网络
# 生成器网络
为了实现发电机网络,我们需要创建 Keras 模型并添加神经网络层。 实施发电机网络所需的步骤如下:
为了实现生成器网络,我们需要创建 Keras 模型并添加神经网络层。 实施生成器网络所需的步骤如下:
1. 首先为不同的超参数指定值:
......@@ -391,7 +391,7 @@ a = Activation(activation=gen_activations[0])(a)
a = Activation(activation=gen_activations[i + 1])(a)
```
5. 然后,创建 Keras 模型并指定发电机网络的输入和输出:
5. 然后,创建 Keras 模型并指定生成器网络的输入和输出:
```py
model = Model(inputs=input_layer, outputs=a)
......@@ -432,7 +432,7 @@ def build_generator():
return gen_model
```
我们已经成功地为发电机网络创建了 Keras 模型。 接下来,为判别器网络创建 Keras 模型。
我们已经成功地为生成器网络创建了 Keras 模型。 接下来,为判别器网络创建 Keras 模型。
......@@ -766,7 +766,7 @@ generated_volumes = generator.predict(z_sample, verbose=3)
tensorboard --logdir=logs
```
现在,在浏览器中打开 `localhost:6006` 。 TensorBoard 的 标量 部分包含两种损失的图表:
现在,在浏览器中打开 `localhost:6006` 。 TensorBoard 的标量部分包含两种损失的图表:
![](img/b67a8b95-a1fe-4c06-be44-cec497dd35bf.png)
......@@ -803,7 +803,7 @@ TensorBoard 的 GRAPHS 部分包含两个网络的图形 。 如果网络性能
* **批次大小**:尝试使用 8、16、32、54 或 128 的批次大小值。
* **时期数**:尝试 100 个时期,并将其逐渐增加到 1,000-5,000。
* **学习率**:这是最重要的超参数。 用 0.1、0.001、0.0001 和其他较小的学习率进行实验。
* **发生器和判别器网络**的不同层中的激活功能:使用 S 型,tanh,ReLU,LeakyReLU,ELU,SeLU 和其他激活功能进行实验。
* **生成器和判别器网络**的不同层中的激活函数:使用 Sigmoid,tanh,ReLU,LeakyReLU,ELU,SeLU 和其他激活函数进行实验。
* **优化算法**:尝试使用 Adam,SGD,Adadelta,RMSProp 和 Keras 框架中可用的其他优化器。
* **损失函数**:二进制交叉熵是最适合 3D-GAN 的损失函数。
* **两个网络中的层数**:根据可用的训练数据量,在网络中尝试不同的层数。 如果您有足够的可用数据来进行训练,则可以使网络更深。
......
......@@ -4,7 +4,7 @@
**条件 GAN****cGAN**)是 GAN 模型的扩展。 它们允许生成具有特定条件或属性的图像,因此被证明比朴素 GAN 更好。 在本章中,我们将实现一个 cGAN,该 cGAN 一旦经过培训,就可以执行自动面部老化。 Grigory Antipov,Moez Baccouche 和 Jean-Luc Dugelay 在其名为 *有条件生成对抗网络* 的人脸衰老的论文中,首先介绍了我们将要实现的 cGAN 网络。 [可以在以下链接中找到](https://arxiv.org/pdf/1702.01983.pdf)
**条件 GAN****cGAN**)是 GAN 模型的扩展。 它们允许生成具有特定条件或属性的图像,因此被证明比朴素 GAN 更好。 在本章中,我们将实现一个 cGAN,该 cGAN 一旦经过培训,就可以执行自动面部老化。 Grigory Antipov,Moez Baccouche 和 Jean-Luc Dugelay 在其名为《使用条件生成对抗网络的人脸老化》的论文中,首先介绍了我们将要实现的 cGAN 网络。 [可以在以下链接中找到](https://arxiv.org/pdf/1702.01983.pdf)
在本章中,我们将介绍以下主题:
......@@ -24,7 +24,7 @@
到目前为止,我们已经针对不同的用例实现了不同的 GAN 网络。 条件 GAN 扩展了普通 GAN 的概念,并允许我们控制发电机网络的输出。 面部老化就是在不更改身份的情况下更改一个人的面部年龄。 在大多数其他模型(包括 GAN)中,由于不考虑面部表情和面部配件(例如太阳镜或胡须),因此会使人的外观或身份损失 50%。 Age-cGAN 会考虑所有这些属性。 在本节中,我们将探索用于面部老化的 cGAN。
到目前为止,我们已经针对不同的用例实现了不同的 GAN 网络。 条件 GAN 扩展了普通 GAN 的概念,并允许我们控制生成器网络的输出。 面部老化就是在不更改身份的情况下更改一个人的面部年龄。 在大多数其他模型(包括 GAN)中,由于不考虑面部表情和面部配件(例如太阳镜或胡须),因此会使人的外观或身份损失 50%。 Age-cGAN 会考虑所有这些属性。 在本节中,我们将探索用于面部老化的 cGAN。
......@@ -44,7 +44,7 @@ cGAN 的训练目标函数可以表示为:
![](img/115b5d5f-6623-46dc-bed1-e99a6aa5910c.png)
此处,`G`是生成器网络,`D`是判别器网络。 判别器 的损失为![](img/78a30b0f-14dc-4d20-ac13-5f3a30bc78d7.png), 发生器的损失为![](img/e81d7c4b-bd30-4887-9e84-303e9cea0a89.png)。 我们可以说 *G(z | y)*在给定 * z **和*。 在此,`z`是从正态分布得出的尺寸为 100 的先验噪声分布。
此处,`G`是生成器网络,`D`是判别器网络。 判别器的损失为![](img/78a30b0f-14dc-4d20-ac13-5f3a30bc78d7.png), 生成器的损失为![](img/e81d7c4b-bd30-4887-9e84-303e9cea0a89.png)。 我们可以说 *G(z | y)*在给定 * z **和*。 在此,`z`是从正态分布得出的尺寸为 100 的先验噪声分布。
......@@ -72,7 +72,7 @@ cGAN 的问题在于它们无法学习将属性`y`的 输入图像`x`逆映射
# 发电机网络
# 生成器网络
......@@ -110,7 +110,7 @@ Age-cGAN 具有多个培训阶段。 如上一节所述,Age-cGAN 具有四个
1. **有条件的 GAN 训练:**在此阶段,我们训练生成器网络和判别器网络。
2. **初始潜在向量逼近:**在此阶段,我们训练编码器网络。
3. **潜向量优化:**在此阶段,我们同时优化编码器和发电机网络。
3. **潜向量优化:**在此阶段,我们同时优化编码器和生成器网络。
以下屏幕截图显示了 Age-cGAN 的各个阶段:
......@@ -142,7 +142,7 @@ Stages in the Age-cGANSource: Face Aging with Conditional Generative Adversarial
![](img/0e7b1187-382e-4584-9c8b-b39c1db1fd91.png)
训练 cGAN 网络涉及优化, 功能, ![](img/e08d1823-e871-40dc-b01f-d924c155a813.png)。 训练 cGAN 可以看作是 minimax 游戏,其中同时对生成器和判别器进行训练。 在上式中, ![](img/7ce6d943-ee01-4777-b805-c300627ec0ec.png)代表发电机网络的参数,![](img/2e9c2935-f734-48ee-afae-ee24ccfa0b0a.png) 代表`G``D`的 参数 , ![](img/6923fbb8-a6ef-4c14-ab83-c8586f272630.png)是判别器模型的损失,![](img/869b6fae-e95a-4138-9df9-033a8e157e49.png)是 对于生成器模型的损失, ![](img/17a59550-253c-4e61-b15e-637119f829ca.png)是分布 所有可能的图像。
训练 cGAN 网络涉及优化, 功能, ![](img/e08d1823-e871-40dc-b01f-d924c155a813.png)。 训练 cGAN 可以看作是 minimax 游戏,其中同时对生成器和判别器进行训练。 在上式中, ![](img/7ce6d943-ee01-4777-b805-c300627ec0ec.png)代表生成器网络的参数,![](img/2e9c2935-f734-48ee-afae-ee24ccfa0b0a.png) 代表`G``D`的 参数 , ![](img/6923fbb8-a6ef-4c14-ab83-c8586f272630.png)是判别器模型的损失,![](img/869b6fae-e95a-4138-9df9-033a8e157e49.png)是 对于生成器模型的损失, ![](img/17a59550-253c-4e61-b15e-637119f829ca.png)是分布 所有可能的图像。
......@@ -162,7 +162,7 @@ Stages in the Age-cGANSource: Face Aging with Conditional Generative Adversarial
在潜在向量优化过程中,我们同时优化了编码器网络和发电机网络。 我们用于潜在向量优化的方程式如下:
在潜在向量优化过程中,我们同时优化了编码器网络和生成器网络。 我们用于潜在向量优化的方程式如下:
![](img/98bda784-ced5-4608-8c1d-38477d40cb8f.png)
......@@ -362,7 +362,7 @@ from scipy.io import loadmat
input_layer = Input(shape=(64, 64, 3))
```
2. 接下来,添加第一个卷积块,其中包含具有激活功能的 2D 卷积层,具有以下配置:
2. 接下来,添加第一个卷积块,其中包含具有激活函数的 2D 卷积层,具有以下配置:
* **过滤器**`32`
* **内核大小**`5`
* **大步前进**`2`
......@@ -403,7 +403,7 @@ enc = LeakyReLU(alpha=0.2)(enc)
Converting an`n`-dimensional tensor to a one-dimensional tensor (array) is called **flattening**.
5. 接下来,添加具有以下配置的密集(完全连接)层,批处理规范化层和激活功能
5. 接下来,添加具有以下配置的密集(完全连接)层,批处理规范化层和激活函数
* **单位(节点)**:2,096
* **批量标准化**:是
* **激活**`LeakyReLU`,其中`alpha`等于`0.2`
......@@ -470,13 +470,13 @@ def build_encoder():
return model
```
我们现在已经成功地为编码器网络创建了 Keras 模型。 接下来,为发电机网络创建 Keras 模型。
我们现在已经成功地为编码器网络创建了 Keras 模型。 接下来,为生成器网络创建 Keras 模型。
# 发电机网络
# 生成器网络
......@@ -570,13 +570,13 @@ x = Conv2D(filters=3, kernel_size=5, padding='same')(x)
x = Activation('tanh')(x)
```
9. 最后,创建 Keras 模型并指定发电机网络的输入和输出:
9. 最后,创建 Keras 模型并指定生成器网络的输入和输出:
```py
model = Model(inputs=[input_z_noise, input_label], outputs=[x])
```
发电机网络的完整代码如下所示:
生成器网络的完整代码如下所示:
```py
def build_generator():
......@@ -617,7 +617,7 @@ def build_generator():
return model
```
现在,我们已经成功创建了发电机网络。 接下来,我们将为判别器网络编写代码。
现在,我们已经成功创建了生成器网络。 接下来,我们将为判别器网络编写代码。
......@@ -645,7 +645,7 @@ image_input = Input(shape=input_shape)
label_input = Input(shape=label_shape)
```
2. 接下来,添加具有以下配置的二维卷积块(Conv2D +激活功能):
2. 接下来,添加具有以下配置的二维卷积块(Conv2D +激活函数):
* **过滤器** = `64`
* **内核大小**`3`
* **大步前进**`2`
......@@ -1018,7 +1018,7 @@ for epoch in range(epochs):
z_noise = np.random.normal(0, 1, size=(batch_size, z_shape))
```
13. 接下来,使用生成器网络生成伪造图像。 请记住,我们尚未训练发电机网络:
13. 接下来,使用生成器网络生成伪造图像。 请记住,我们尚未训练生成器网络:
```py
initial_recon_images = generator.predict_on_batch([z_noise, y_batch])
......@@ -1050,7 +1050,7 @@ for epoch in range(epochs):
g_loss = adversarial_model.train_on_batch([z_noise2, sampled_labels], [1] * batch_size)
```
前面的代码将在一批输入上训练发电机网络。 对抗模型的输入是`z_noise2``random_labels`
前面的代码将在一批输入上训练生成器网络。 对抗模型的输入是`z_noise2``random_labels`
16. 接下来,计算并打印损失:
......@@ -1150,7 +1150,7 @@ def euclidean_distance_loss(y_true, y_pred):
generator.load_weights("generator.h5")
```
在这里,我们正在加载上一步的权重,在该步骤中,我们成功地训练并保存了发电机网络的权重。
在这里,我们正在加载上一步的权重,在该步骤中,我们成功地训练并保存了生成器网络的权重。
3. 接下来,对一批潜在向量进行采样,如下所示:
......@@ -1224,7 +1224,7 @@ encoder.save_weights("encoder.h5")
在前面的两个步骤中,我们成功地训练了生成器网络,判别器网络和编码器网络。 在本节中,我们将改进编码器和发电机网络。 在这些步骤中,我们将使用**人脸识别****FR**)网络,该网络会生成输入给它的特定输入的 128 维嵌入,以改善生成器和编码器 网络。
在前面的两个步骤中,我们成功地训练了生成器网络,判别器网络和编码器网络。 在本节中,我们将改进编码器和生成器网络。 在这些步骤中,我们将使用**人脸识别****FR**)网络,该网络会生成输入给它的特定输入的 128 维嵌入,以改善生成器和编码器 网络。
执行以下步骤:
......
......@@ -40,7 +40,7 @@ DCGAN 扩展了在判别器和生成器网络中使用卷积层的思想。 DCGA
如前所述,DCGAN 网络在两个网络中都使用卷积层。 重申一下,CNN 是一个具有卷积层,紧随其后的归一化或池化层以及紧随其后的激活功能的网络。 在 DCGAN 中,判别器网络会拍摄图像,在卷积和池化层的帮助下对图像进行降采样,然后使用密集的分类层将图像分类为真实图像或伪图像。 生成器网络从潜在空间中获取随机噪声向量,使用上采样机制对其进行上采样,最后生成图像。 我们使用 Leaky ReLU 作为隐藏层的激活函数,并在 0.4 和 0.7 之间进行滤除以避免过拟合。
如前所述,DCGAN 网络在两个网络中都使用卷积层。 重申一下,CNN 是一个具有卷积层,紧随其后的归一化或池化层以及紧随其后的激活函数的网络。 在 DCGAN 中,判别器网络会拍摄图像,在卷积和池化层的帮助下对图像进行降采样,然后使用密集的分类层将图像分类为真实图像或伪图像。 生成器网络从潜在空间中获取随机噪声向量,使用上采样机制对其进行上采样,最后生成图像。 我们使用 Leaky ReLU 作为隐藏层的激活函数,并在 0.4 和 0.7 之间进行滤除以避免过拟合。
让我们看一下两个网络的配置。
......@@ -48,7 +48,7 @@ DCGAN 扩展了在判别器和生成器网络中使用卷积层的思想。 DCGA
# 配置发电机网络
# 配置生成器网络
......@@ -60,9 +60,9 @@ Source: arXiv:1511.06434 [cs.LG]
上图包含了生成器网络体系结构中的不同层,并显示了它如何生成分辨率为 64 x 64 x 3 的图像。
DCGAN 的发电机网络包含 10 层。 它执行跨步卷积以增加张量的空间分辨率。 在 Keras 中,上采样和卷积层的组合等于跨步卷积层。 基本上,生成器网络会从均匀分布中获取采样的噪声向量,并不断对其进行转换,直到生成最终图像为止。 换句话说,它采取形状的张量(`batch_size, 100`),并输出形状的张量(`batch_size, 64, 64, 3`)。
DCGAN 的生成器网络包含 10 层。 它执行跨步卷积以增加张量的空间分辨率。 在 Keras 中,上采样和卷积层的组合等于跨步卷积层。 基本上,生成器网络会从均匀分布中获取采样的噪声向量,并不断对其进行转换,直到生成最终图像为止。 换句话说,它采取形状的张量(`batch_size, 100`),并输出形状的张量(`batch_size, 64, 64, 3`)。
让我们看一下发电机网络中的不同层:
让我们看一下生成器网络中的不同层:
| **层#** | **图层名称** | **配置** |
| 1 | 输入层 | `input_shape=(batch_size, 100)``output_shape=(batch_size, 100)` |
......@@ -92,7 +92,7 @@ This configuration is valid for Keras APIs with the TensorFlow backend and the `
![](img/0bbb9055-1c43-4f7d-a900-fdf515b6d068.png)
上图给出了发电机网络架构的顶层概述。
上图给出了生成器网络架构的顶层概述。
如前所述,判别器网络是一个包含 10 层的 CNN(您可以根据需要向网络添加更多层)。 基本上,它会拍摄尺寸为 64 x 64 x 3 的图像,使用 2D 卷积层对其进行下采样,然后将其传递到完全连接的层进行分类。 它的输出是对给定图像是伪图像还是真实图像的预测。 可以为 0 或 1;可以为 0。 如果输出为 1,则传递到判别器的图像是真实的;如果输出为 0,则传递的图像是伪图像。
......@@ -363,13 +363,13 @@ print("Total number of faces:{}".format(total_num_faces))
# 发电机
# 生成器
如 DCGAN 部分的*体系结构中所述,生成器网络由一些 2D 卷积层,上采样层,整形层和批归一化层组成 。 在 Keras 中,每个操作都可以指定为一个图层。 甚至激活函数也是 Keras 中的层,可以像正常的密集层一样添加到模型中。*
执行以下步骤来创建发电机网络:
执行以下步骤来创建生成器网络:
1. 让我们开始创建一个`Sequential` Keras 模型:
......@@ -384,7 +384,7 @@ gen_model.add(Dense(units=2048))
gen_model.add(Activation('tanh'))
```
3. 接下来,添加第二层,它也是一个具有 16,384 个神经元的密集层。 接下来是 `batch normalization` 层,其中 `default hyperparameters``tanh` 作为 **激活功能**
3. 接下来,添加第二层,它也是一个具有 16,384 个神经元的密集层。 接下来是 `batch normalization` 层,其中 `default hyperparameters``tanh` 作为 **激活函数**
```py
gen_model.add(Dense(256`8`8))
......@@ -422,7 +422,7 @@ gen_model.add(UpSampling2D(size=(2, 2)))
2D 上采样层 将张量 的行和列分别以[0]和[1]的大小重复 。
8. 接下来,在第二个 2D 卷积层上添加 `64` 过滤器和,将`(5, 5)`**内核大小** `tanh` 作为激活功能
8. 接下来,在第二个 2D 卷积层上添加 `64` 过滤器和,将`(5, 5)`**内核大小** `tanh` 作为激活函数
```py
gen_model.add(Conv2D(64, (5, 5), padding='same'))
......@@ -435,7 +435,7 @@ gen_model.add(Activation('tanh'))
gen_model.add(UpSampling2D(size=(2, 2)))
```
10. 最后,在第三个 2D 卷积层上添加三个 **滤镜****内核大小`(5, 5)` ,然后是 ] `tanh` 作为激活功能:**
10. 最后,在第三个 2D 卷积层上添加三个 **滤镜****内核大小`(5, 5)` ,然后是 ] `tanh` 作为激活函数:**
```py
gen_model.add(Conv2D(3, (5, 5), padding='same'))
......@@ -491,7 +491,7 @@ def get_generator():
* 卷积层分别具有 128、256 和 512 个滤波器。 它们的内核大小分别为(5、5),(3、3)和(3、3)。
* 在卷积层之后,我们有一个平坦层,它将输入平坦化为一维张量。
* 此后,网络具有两个密集层,分别具有 1,024 个神经元和一个神经元。
* 第一密集层具有`LeakyReLU`作为激活功能,而第二层具有乙状结肠作为激活功能。 乙状结肠激活用于二进制分类。 我们正在训练辨别器网络,以区分真实图像还是伪图像。
* 第一密集层具有`LeakyReLU`作为激活函数,而第二层具有乙状结肠作为激活函数。 乙状结肠激活用于二进制分类。 我们正在训练辨别器网络,以区分真实图像还是伪图像。
执行以下步骤来创建判别器网络:
......@@ -501,7 +501,7 @@ def get_generator():
dis_model = Sequential()
```
2. 添加一个 2D 卷积层,该层采用形状为(64,64,3)的输入图像。 该层的超参数如下。 另外,添加具有`0.2`的 alpha 值的`LeakyReLU`作为激活功能
2. 添加一个 2D 卷积层,该层采用形状为(64,64,3)的输入图像。 该层的超参数如下。 另外,添加具有`0.2`的 alpha 值的`LeakyReLU`作为激活函数
* **过滤器:** 128
* **内核大小:** (5,5)
* **填充:** 相同:
......@@ -537,7 +537,7 @@ dis_model.add(MaxPooling2D(pool_size=(2, 2)))
5. 接下来,添加具有以下配置的第三个 2D 卷积层:
* **过滤器**: 512
* **内核大小** :( 3 ,3)
* **激活功能**`LeakyReLU` ,带有 alpha 0.2
* **激活函数**`LeakyReLU` ,带有 alpha 0.2
* **2D 最大池中的池大小** :( 2 ,2):
```py
......@@ -556,7 +556,7 @@ dis_model.add(Flatten())
来自平坦化层的张量的输出形状将为`(batch_size, 18432,)`
7. 接下来,添加具有`1024`神经元和`alpha` 0.2 作为激活功能`LeakyReLU`的致密层:
7. 接下来,添加具有`1024`神经元和`alpha` 0.2 作为激活函数`LeakyReLU`的致密层:
```py
dis_model.add(Dense(1024))
......@@ -618,7 +618,7 @@ def get_discriminator():
1. 加载数据集。
2. 构建和编译网络。
3. 训练判别器网络。
4. 训练发电机网络。
4. 训练生成器网络。
我们将在本节中一步一步地进行这些步骤。
......@@ -738,7 +738,7 @@ for epoch in range(epcohs):
* 最初,这两个网络都是幼稚的并且具有随机权重。
* 训练 DCGAN 网络的标准过程是首先对一批样品进行判别器训练。
* 为此,我们需要假样品和真实样品。 我们已经有了真实的样本,因此现在需要生成伪样本。
* 要生成伪样本,请在均匀分布上创建形状为(100,)的潜向量。 将此潜向量馈入未经训练的发电机网络。 生成器网络将生成伪样本,我们将其用于训练判别器网络。
* 要生成伪样本,请在均匀分布上创建形状为(100,)的潜向量。 将此潜向量馈入未经训练的生成器网络。 生成器网络将生成伪样本,我们将其用于训练判别器网络。
* 合并真实图像和伪图像以创建一组新的样本图像。 我们还需要创建一个标签数组:真实图像使用标签 1,伪图像使用标签 0。
......@@ -795,17 +795,17 @@ dis_loss_fake = dis_model.train_on_batch(generated_images, y_fake)
d_loss = (dis_loss_real+dis_loss_fake)/2 print("d_loss:", d_loss)
```
到目前为止,我们一直在训练判别器网络。 在下一部分中,让我们训练发电机网络。
到目前为止,我们一直在训练判别器网络。 在下一部分中,让我们训练生成器网络。
# 训练发电机网络
# 训练生成器网络
为了训练发电机网络,我们必须训练对抗模型。 当我们训练对抗模型时,它只训练发电机网络,而冻结判别器网络。 由于我们已经训练过判别器网络,因此我们不会对其进行训练。 执行以下步骤来训练对抗模型:
为了训练生成器网络,我们必须训练对抗模型。 当我们训练对抗模型时,它只训练生成器网络,而冻结判别器网络。 由于我们已经训练过判别器网络,因此我们不会对其进行训练。 执行以下步骤来训练对抗模型:
1. 首先重新创建一批噪声向量。 从高斯/正态分布中采样以下噪声向量:
......@@ -959,11 +959,11 @@ Tensorboard 的 **GRAPHS** 部分包含两个网络的图形。 如果网络性
* 学习率
* 批量大小
* 纪元数
* 发电机优化器
* 生成器优化器
* 判别器优化器
* 层数
* 致密层中的单位数
* 激活功能
* 激活函数
* 损失函数
*使用 Keras* 实现 DCGAN 的部分中,学习率是固定的:生成器模型为 0.0005,判别器模型为 0.0005。 批处理大小为 128。调整这些值可能会导致我们创建更好的模型。 如果您的模型没有生成合理的图像,请尝试更改这些值,然后再次运行模型。
......
......@@ -26,7 +26,7 @@
与其他 GAN 一样,SRGAN 包含一个生成器网络和一个判别器网络。 两个网络都很深。 这两个网络的功能指定如下:
* **生成器**:生成器网络拍摄尺寸为 64x64x3 的低分辨率图像,并且在一系列卷积和上采样层之后, 生成超分辨率 形状为 256x256x3 的图片
* **鉴别符** :鉴别符网络拍摄高分辨率图像,并尝试识别给定的图像是真实的(来自真实数据样本)还是伪造的(由 发电机
* **鉴别符** :鉴别符网络拍摄高分辨率图像,并尝试识别给定的图像是真实的(来自真实数据样本)还是伪造的(由 生成器
......@@ -46,11 +46,11 @@
# 发电机网络的架构
# 生成器网络的架构
如前一节所述,生成器网络是深度卷积神经网络。 发电机网络包含以下块:
如前一节所述,生成器网络是深度卷积神经网络。 生成器网络包含以下块:
* 残留块
* 残留块
......@@ -82,7 +82,7 @@
| 2D 卷积层 | `Filters=64, kernel_size=3, strides=1, padding='same'` | (64, 64, 64) | (64, 64, 64) |
| 批量归一化层 | `Momentum=0.8` | (64, 64, 64) | (64, 64, 64) |
* **上采样块**:上采样块包含一个上采样层和一个 2D 卷积层,并使用 relu 作为激活功能。 发生器网络中有两个上采样模块。 第一个升采样模块的配置如下:
* **上采样块**:上采样块包含一个上采样层和一个 2D 卷积层,并使用 relu 作为激活函数。 生成器网络中有两个上采样模块。 第一个升采样模块的配置如下:
| **图层名称** | **超参数** | **输入形状** | **输出形状** |
| 2D 上采样层 | `Size=(2, 2)` | (64, 64, 64) | (128, 128, 64) |
......@@ -321,13 +321,13 @@ from scipy.misc import imsave
# 发电机网络
# 生成器网络
我们已经在*中探讨了发电机网络的架构。*发电机网络的架构。 让我们首先在 Keras 框架中编写生成器网络的层,然后使用 Keras 框架的功能 API 创建 Keras 模型。
我们已经在*中探讨了生成器网络的架构。*生成器网络的架构。 让我们首先在 Keras 框架中编写生成器网络的层,然后使用 Keras 框架的功能 API 创建 Keras 模型。
执行以下步骤以在 Keras 中实现发电机网络:
执行以下步骤以在 Keras 中实现生成器网络:
1. 首先定义生成器网络所需的超参数:
......@@ -459,7 +459,7 @@ output = Activation('tanh')(gen6)
model = Model(inputs=[input_layer], outputs=[output], name='generator')
```
我们已经成功地为发电机网络创建了 Keras 模型。 现在,将生成器网络的整个代码包装在 Python 函数中,如下所示:
我们已经成功地为生成器网络创建了 Keras 模型。 现在,将生成器网络的整个代码包装在 Python 函数中,如下所示:
```py
def build_generator():
......@@ -510,7 +510,7 @@ def build_generator():
return model
```
我们已经成功地为发电机网络创建了 Keras 模型。 在下一节中,我们将为判别器网络创建 Keras 模型。
我们已经成功地为生成器网络创建了 Keras 模型。 在下一节中,我们将为判别器网络创建 Keras 模型。
......@@ -821,7 +821,7 @@ def build_adversarial_model(generator, discriminator, vgg):
培训 SRGAN 网络是一个分为两个步骤的过程。 第一步,我们训练判别器网络。 在第二步中,我们训练对抗网络,最终训练发电机网络。 让我们开始训练网络。
培训 SRGAN 网络是一个分为两个步骤的过程。 第一步,我们训练判别器网络。 在第二步中,我们训练对抗网络,最终训练生成器网络。 让我们开始训练网络。
执行以下步骤来训练 SRGAN 网络:
......@@ -868,7 +868,7 @@ discriminator.compile(loss='mse', optimizer=common_optimizer,
要编译判别器网络,使用 `mse` 作为损耗, `accuracy` 作为度量,并使用 `common_optimizer` 作为优化器。
3. 接下来,构建发电机网络:
3. 接下来,构建生成器网络:
```py
generator = build_generator()
......@@ -983,7 +983,7 @@ def sample_images(data_dir, batch_size, high_resolution_shape, low_resolution_sh
low_resolution_images = low_resolution_images / 127.5 - 1.
```
将像素值转换为-1 到 1 的范围非常重要。我们的生成器网络的末尾有`tanh``tanh`激活功能将值压缩到相同范围。 在计算损耗时,必须使所有值都在同一范围内。
将像素值转换为-1 到 1 的范围非常重要。我们的生成器网络的末尾有`tanh``tanh`激活函数将值压缩到相同范围。 在计算损耗时,必须使所有值都在同一范围内。
......@@ -1034,11 +1034,11 @@ d_loss_fake = discriminator.train_on_batch(generated_high_resolution_images, fak
# 训练发电机网络
# 训练生成器网络
本节中给出的步骤显示了如何训练发电机网络。 这是最后一系列步骤的延续:
本节中给出的步骤显示了如何训练生成器网络。 这是最后一系列步骤的延续:
1. 再次,对一批高分辨率和低分辨率图像进行采样并对其进行归一化:
......
......@@ -120,7 +120,7 @@ StackGAN 网络的主要组成部分是生成器网络和判别器网络。 在
# 发电机网络
# 生成器网络
......@@ -162,7 +162,7 @@ The architecture of the Stage-I discriminator network
StackGAN 的阶段 I 中使用了两个损失,如下所示:
* 发电机损耗
* 生成器损耗
* 判别器损失
鉴别符损失![](img/0a355bdc-0c6f-4cd3-a62e-4b46a301c9f6.png)可以表示为:
......@@ -171,7 +171,7 @@ StackGAN 的阶段 I 中使用了两个损失,如下所示:
公式前面的很不言自明。 它代表了判别器网络的损失函数,其中两个网络都以文本嵌入为条件。
发电机损耗![](img/b46d75ce-88c8-480a-ba3d-572b93f4c717.png)可以表示为:
生成器损耗![](img/b46d75ce-88c8-480a-ba3d-572b93f4c717.png)可以表示为:
![](img/6567c751-fa0d-4009-b4bd-b864d4ecab7c.png)
......@@ -185,7 +185,7 @@ StackGAN 的阶段 I 中使用了两个损失,如下所示:
Stage-II StackGAN 的主要组件是发电机网络和判别器网络。 生成器网络是编码器-解码器类型的网络。 在此阶段不使用随机噪声`z`,假设 ![](img/94999cb2-2d49-4263-b900-3deef877ccd1.png)已保留了随机性,其中![](img/94999cb2-2d49-4263-b900-3deef877ccd1.png)是发生器网络生成的图像 第一阶段
Stage-II StackGAN 的主要组件是生成器网络和判别器网络。 生成器网络是编码器-解码器类型的网络。 在此阶段不使用随机噪声`z`,假设 ![](img/94999cb2-2d49-4263-b900-3deef877ccd1.png)已保留了随机性,其中![](img/94999cb2-2d49-4263-b900-3deef877ccd1.png)是生成器网络生成的图像 第一阶段
我们首先使用预训练的文本编码器生成高斯条件变量 ![](img/308050a3-9d10-4f05-9e8e-d1e4e07bbb93.png) 。 这将生成嵌入 ![](img/b7167483-2ee2-469e-af9f-278f36699c79.png) 的相同文本。 第一阶段和第二阶段条件增强具有不同的完全连接层,用于生成不同的均值和标准 偏差。 这意味着 Stage-II GAN 学会了在文本嵌入中捕获有用的信息,而这些信息被 Stage-I GAN 省略了。
......@@ -195,7 +195,7 @@ Stack-I GAN 生成的图像存在的问题是,它们可能缺少生动的对
# 发电机网络
# 生成器网络
......@@ -245,7 +245,7 @@ The architecture of the Stage-II discriminator network.
与任何其他 GAN 相似,Stack-II GAN 中的生成器`G`和判别器`D`也可以通过最大化判别器的损耗并将生成器网络的损耗最小化来训练 。
发电机损耗![](img/d0ecd579-7d64-4b7c-a9c7-666c14c0e1cc.png)可以表示为:
生成器损耗![](img/d0ecd579-7d64-4b7c-a9c7-666c14c0e1cc.png)可以表示为:
![](img/24684f0c-814c-4b33-bfe7-c177cfe19a46.png)
......@@ -399,7 +399,7 @@ Stage-I StackGAN 网络中使用的网络如下:
* 文本编码器网络
* 条件增强网络
* 发电机网络
* 生成器网络
* 鉴别网络
但是,在开始编写实现之前,请创建一个 Python 文件 `main.py` ,然后按如下所示导入基本模块:
......@@ -447,7 +447,7 @@ CA 网络的目的是将文本嵌入向量(![](img/de8c23e2-ee05-44ea-876e-adf
以下代码显示了如何创建 CA 网络:
1. 首先创建一个具有 256 个节点的完整连接层,并使用`LeakyReLU`作为激活功能
1. 首先创建一个具有 256 个节点的完整连接层,并使用`LeakyReLU`作为激活函数
```py
input_layer = Input(shape=(1024,))
......@@ -506,7 +506,7 @@ def build_ca_model():
# 发电机网络
# 生成器网络
......@@ -543,7 +543,7 @@ x = Reshape((4, 4, 128 * 8), input_shape=(128 * 8 * 4 * 4,))(x)
该操作将二维张量整形为二维张量。
5. 接下来,创建一个二维向上采样卷积块。 该块包含一个上采样层,一个卷积层和一个批归一化层。 批量归一化后,使用`ReLU`作为此块的激活功能
5. 接下来,创建一个二维向上采样卷积块。 该块包含一个上采样层,一个卷积层和一个批归一化层。 批量归一化后,使用`ReLU`作为此块的激活函数
```py
x = UpSampling2D(size=(2, 2))(x)
......@@ -635,7 +635,7 @@ def build_stage1_generator():
此模型在单个网络中同时包含 CA 网络和生成器网络。 它需要两个输入并返回两个输出。 输入是文本嵌入和噪声变量,而输出是生成的图像和`mean_logsigma`
我们现在已经成功实现了发电机网络。 让我们进入判别器网络。
我们现在已经成功实现了生成器网络。 让我们进入判别器网络。
......@@ -858,17 +858,17 @@ Stage-II StackGAN 与 Stage-I StackGAN 略有不同。 生成器模型的输入
* 残留块
* 上采样块
文本编码器和 CA 网络与之前在 Stage-I 部分中使用的相似。 现在,我们将介绍发生器网络的三个组件,分别是下采样块,残差块和上采样块。
文本编码器和 CA 网络与之前在 Stage-I 部分中使用的相似。 现在,我们将介绍生成器网络的三个组件,分别是下采样块,残差块和上采样块。
# 发电机网络
# 生成器网络
发电机网络由三个不同的模块组成。 我们将逐一编写每个模块的代码。 让我们从下采样模块开始。
生成器网络由三个不同的模块组成。 我们将逐一编写每个模块的代码。 让我们从下采样模块开始。
......@@ -1201,7 +1201,7 @@ x2 = Conv2D(512, (3, 3), padding='same', strides=1, use_bias=False)(x2)
x2 = BatchNormalization()(x2)
```
之后,我们有两个输出,分别是`x``x2`。 将这两个张量相加以创建相同形状的张量。 我们还需要应用`LeakyReLU`激活功能
之后,我们有两个输出,分别是`x``x2`。 将这两个张量相加以创建相同形状的张量。 我们还需要应用`LeakyReLU`激活函数
```py
added_x = add([x, x2])
......@@ -1963,11 +1963,11 @@ tensorboard --logdir=logs
![](img/8d391386-69b9-4890-bd5a-a078ba996754.png)
阶段 I 的发电机网络的损耗图如下所示:
阶段 I 的生成器网络的损耗图如下所示:
![](img/905056c0-7994-444e-b42b-4ebce2f093d9.png)
可以类似地从 Tensorboard 获得 Stage II 的发电机网络和判别器网络的损耗图。
可以类似地从 Tensorboard 获得 Stage II 的生成器网络和判别器网络的损耗图。
这些图将帮助您决定是继续还是停止训练。 如果损失不再减少,您就可以停止培训,因为没有改善的机会。 如果损失持续增加,则必须停止训练。 使用超参数,然后选择一组您认为可以提供更好结果的超参数。 如果损失逐渐减少,请继续训练模型。
......
......@@ -24,9 +24,9 @@ CycleGAN 是一种**生成对抗性** **网络**(**GAN**)的类型,用于
为了将照片变成一幅画或一幅画,再将它们变成照片,普通 GAN 需要一对图像。 CycleGAN 是一种 GAN 网络,可以将图像从一个域 X 转换为另一个域 Y,而无需配对图像。 CycleGAN 尝试学习发电机网络,而发电机网络又学习了两个映射。 CycleGAN 无需训练大多数 GAN 中使用的单个发电机网络,而是训练两个发电机和两个判别器网络。
为了将照片变成一幅画或一幅画,再将它们变成照片,普通 GAN 需要一对图像。 CycleGAN 是一种 GAN 网络,可以将图像从一个域 X 转换为另一个域 Y,而无需配对图像。 CycleGAN 尝试学习生成器网络,而生成器网络又学习了两个映射。 CycleGAN 无需训练大多数 GAN 中使用的单个生成器网络,而是训练两个生成器和两个判别器网络。
CycleGAN 中有两个发电机网络,如下所示:
CycleGAN 中有两个生成器网络,如下所示:
1. **生成器 A** :学习映射![](img/5ee63015-1266-4f90-b3cc-dca5d99f293e.png),其中 X 是源域,`Y`是目标域。 它从源域`A`拍摄图像,并将其转换为与目标域`B`相似的图像。 基本上,网络的目的是学习映射,以使 *G(X)*`Y`相似。
2. **生成器 B** :学习映射![](img/4afb529e-38ff-40f5-b294-dd6545cd5251.png),然后从目标域 B 中获取图像,并将其转换为与源域 A 中的图像相似的图像。类似地, 网络要学习另一个映射,以便 *F(G(X)*类似于`X`)。
......@@ -60,13 +60,13 @@ CycleGAN 总体上由两种体系结构组成:生成器和判别器。 生成
# 发电机的架构
# 生成器的架构
生成器网络是自动编码器类型的网络。 它以图像作为输入并输出另一个图像。 它由两部分组成:编码器和解码器。 编码器包含具有下采样功能的卷积层,并将`128x128x3`形状的输入转换为内部表示。 解码器包含两个上采样块和最后一个卷积层,该层将内部表示形式转换为`128x128x3`形状的输出。
发电机网络包含以下块:
生成器网络包含以下块:
* 卷积块
* 残留块
......@@ -90,7 +90,7 @@ CycleGAN 总体上由两种体系结构组成:生成器和判别器。 生成
| 实例规范化层 | `axis=1` | (32, 32, 128) | (32, 32, 128) |
| 激活层 | `activation='relu'` | (32, 32, 128) | (32, 32, 128) |
* **残余块**:残余块包含两个 2D 卷积层。 两层之后是动量值等于 0.8 的批归一化层。 发电机网络包含六个残差块,其配置如下:
* **残余块**:残余块包含两个 2D 卷积层。 两层之后是动量值等于 0.8 的批归一化层。 生成器网络包含六个残差块,其配置如下:
| **图层名称** | **超参数** | **输入形状** | **输出形状** |
| 2D 卷积层 | `filters=128, kernel_size=3, strides=1, padding='same'` | (32, 32, 128) | (32、32、128) |
......@@ -101,7 +101,7 @@ CycleGAN 总体上由两种体系结构组成:生成器和判别器。 生成
加法层计算输入到块的 张量 与最后一批归一化层的输出之和。
* **上采样块**:上采样块包含转置 2D 卷积层,并使用`relu`作为激活函数。 发生器网络中有两个上采样模块。 第一个升采样模块的配置如下:
* **上采样块**:上采样块包含转置 2D 卷积层,并使用`relu`作为激活函数。 生成器网络中有两个上采样模块。 第一个升采样模块的配置如下:
| **图层名称** | **超参数** | **输入形状** | **输出形状** |
| 转置 2D 卷积层 | `filters=64, kernel_size=3, strides=2, padding='same', use_bias=False` | (32, 32, 128) | (64, 64, 64) |
......@@ -225,7 +225,7 @@ The ZeroPadding2D layer adds rows and columns of zeros at the top, bottom, left,
![](img/b0e30420-c79d-434a-b6d9-6fcaaa2a61ad.png)
前面的等式表明,训练一个 CycleGAN,需要最小化发电机网络的损耗,并使判别器网络的损耗最大化。 优化之后,我们将获得一组训练有素的网络,能够从绘画中生成照片。
前面的等式表明,训练一个 CycleGAN,需要最小化生成器网络的损耗,并使判别器网络的损耗最大化。 优化之后,我们将获得一组训练有素的网络,能够从绘画中生成照片。
......@@ -329,11 +329,11 @@ from scipy.misc import imread, imresize
# 发电机网络
# 生成器网络
在本章前面的*发电机网络的体系结构*部分中,我们已经探讨了发电机网络的体系结构。 让我们首先在 Keras 框架中编写生成器网络的层,然后使用 Keras 框架的功能 API 创建 Keras 模型。
在本章前面的*生成器网络的体系结构*部分中,我们已经探讨了生成器网络的体系结构。 让我们首先在 Keras 框架中编写生成器网络的层,然后使用 Keras 框架的功能 API 创建 Keras 模型。
执行以下步骤以在 Keras 中实现生成器网络:
......@@ -419,7 +419,7 @@ x = Conv2D(filters=3, kernel_size=7, strides=1, padding="same")(x)
output = Activation('tanh')(x)
```
这是发电机网络的最后一层。 它生成形状为(128、128、3)的图像。
这是生成器网络的最后一层。 它生成形状为(128、128、3)的图像。
10. 现在,通过为网络指定`inputs``outputs`来创建 Keras 模型,如下所示:
......@@ -427,7 +427,7 @@ output = Activation('tanh')(x)
model = Model(inputs=[input_layer], outputs=[output])
```
发电机网络的整个代码如下所示:
生成器网络的整个代码如下所示:
```py
def build_generator():
......@@ -474,7 +474,7 @@ def build_generator():
return model
```
我们已经成功地为发电机网络创建了 Keras 模型。 在下一节中,我们将为判别器网络创建 Keras 模型。
我们已经成功地为生成器网络创建了 Keras 模型。 在下一节中,我们将为判别器网络创建 Keras 模型。
......@@ -720,7 +720,7 @@ discriminatorB.compile(loss='mse', optimizer=common_optimizer, metrics=['accurac
使用`mse`作为损失函数,并使用`accuracy`作为度量标准来编译网络。
4. 接下来,创建发电机网络 A(`generatorAToB`)和 B(`generatorBToA`)。 生成器网络 A 的输入是数据集 A 的真实图像(realA),输出将是重构图像(fakeB)。 生成器网络 B 的输入是来自数据集 B 的真实图像(realB),输出将是重构图像(fakeA),如下所示:
4. 接下来,创建生成器网络 A(`generatorAToB`)和 B(`generatorBToA`)。 生成器网络 A 的输入是数据集 A 的真实图像(realA),输出将是重构图像(fakeB)。 生成器网络 B 的输入是来自数据集 B 的真实图像(realB),输出将是重构图像(fakeA),如下所示:
```py
generatorAToB = build_generator()
......@@ -945,7 +945,7 @@ d_loss = 0.5 * np.add(0.5 * np.add(dALoss1, dALoss2), 0.5 *
[real_labels, real_labels, batchA, batchB, batchA, batchB])
```
此步骤将训练发电机网络,而无需训练发电机网络。
此步骤将训练生成器网络,而无需训练生成器网络。
在每个微型批处理上完成一次迭代(循环)之后,将损耗存储在名为`dis_losses``gen_losses`的列表中,如下所示:
......@@ -1056,7 +1056,7 @@ tensorboard --logdir=logs
![](img/69b11dd7-e38d-46ad-a293-69d3827daf0d.png)
发电机网络的损耗图如下所示:
生成器网络的损耗图如下所示:
![](img/4b6517ec-d185-4ec3-a4f9-acfbba2ee45f.png)
......
......@@ -35,17 +35,17 @@ Pix2pix 是条件 GAN 的变体。 我们已经在第 3 章,“使用条件 GA
与其他 GAN 相似,pix2pix 由两个网络组成:生成器网络和判别器网络。 发电机网络的体系结构受 [U-Net](https://arxiv.org/pdf/1505.04597.pdf) 的体系结构的启发。 同样,判别器网络的架构也受到 [PatchGAN](https://arxiv.org/pdf/1604.04382.pdf) 架构的启发。 这两个网络都是深度卷积神经网络。 在本节中,我们将详细探讨 pix2pix。
与其他 GAN 相似,pix2pix 由两个网络组成:生成器网络和判别器网络。 生成器网络的体系结构受 [U-Net](https://arxiv.org/pdf/1505.04597.pdf) 的体系结构的启发。 同样,判别器网络的架构也受到 [PatchGAN](https://arxiv.org/pdf/1604.04382.pdf) 架构的启发。 这两个网络都是深度卷积神经网络。 在本节中,我们将详细探讨 pix2pix。
# 发电机网络
# 生成器网络
正如我们在上一节中提到的,发电机网络在很大程度上受到 U-Net 架构的启发。 U-Net 的架构与自动编码器网络的架构几乎相同。 它们之间的主要区别在于,U-Net 网络在编码器中的各层之间具有跳过连接,并且生成器网络和自动编码器的解码器部分不具有跳过连接。 U-Net 网络由两个网络组成:编码器网络和解码器网络。 下图从基本层面说明了 U-Net 的体系结构:
正如我们在上一节中提到的,生成器网络在很大程度上受到 U-Net 架构的启发。 U-Net 的架构与自动编码器网络的架构几乎相同。 它们之间的主要区别在于,U-Net 网络在编码器中的各层之间具有跳过连接,并且生成器网络和自动编码器的解码器部分不具有跳过连接。 U-Net 网络由两个网络组成:编码器网络和解码器网络。 下图从基本层面说明了 U-Net 的体系结构:
![](img/ba22d993-cf32-42a1-86b9-94c2b37311e8.png)
......@@ -59,7 +59,7 @@ Pix2pix 是条件 GAN 的变体。 我们已经在第 3 章,“使用条件 GA
编码器网络是发电机网络的初始网络,包含八个**卷积块**,其配置如下:
编码器网络是生成器网络的初始网络,包含八个**卷积块**,其配置如下:
| **图层名称** | **超参数** | **输入形状** | **输出形状** |
| 第一 2D 卷积层 | 过滤器= 64,kernel_size = 4,步幅= 2,padding ='same', | (256, 256, 1) | (128, 128, 64) |
......@@ -96,7 +96,7 @@ Pix2pix 是条件 GAN 的变体。 我们已经在第 3 章,“使用条件 GA
发生器网络中的解码器网络还包括八个**上采样卷积块**。 八个上采样卷积块的配置如下:
生成器网络中的解码器网络还包括八个**上采样卷积块**。 八个上采样卷积块的配置如下:
| **图层名称** | **超参数** | **输入形状** | **输出形状** |
| 第一 2D 上采样层 | 大小=(2,2) | ( 1,1,512) | ( 2,2,512) |
......@@ -153,7 +153,7 @@ Pix2pix 是条件 GAN 的变体。 我们已经在第 3 章,“使用条件 GA
串联沿着通道轴发生。 编码器网络的最后一层将张量传递到解码器网络的第一层。 在编码器网络的最后一块和解码器网络的最后一块没有串联。
发电机网络由这两个网络组成。 基本上,编码器网络是下采样器,而解码器网络是上采样器。 编码器网络 d 自己对尺寸为(256、256、1)的图像采样为尺寸为(1、1、1、512)的内部表示。 另一方面,解码器网络将 的内部表示以(1、1、1,512)维度上采样为(256、256、1)维度的输出图像 。
生成器网络由这两个网络组成。 基本上,编码器网络是下采样器,而解码器网络是上采样器。 编码器网络 d 自己对尺寸为(256、256、1)的图像采样为尺寸为(1、1、1、512)的内部表示。 另一方面,解码器网络将 的内部表示以(1、1、1,512)维度上采样为(256、256、1)维度的输出图像 。
We will cover more on the architecture in the *Keras implementation of pix2pix* section.
......@@ -474,13 +474,13 @@ from keras.optimizers import Adam
# 发电机网络
# 生成器网络
生成器网络从源域 A 拍摄尺寸为(256、256、1)的图像,并将其转换为目标域 B 中尺寸为(256、256、1)的图像。 基本上,它将图像从源域 A 转换为目标域 B。让我们在 Keras 框架中实现生成器网络。
执行以下步骤来创建发电机网络:
执行以下步骤来创建生成器网络:
1. 首先定义生成器网络所需的超参数:
......@@ -505,7 +505,7 @@ The input layer takes an input image of a shape of (256, 256, 1) and passes it t
encoder1 = LeakyReLU(alpha=leakyrelu_alpha)(encoder1)
```
第一卷积块包含具有激活功能的 2D 卷积层。 与其他七个卷积块不同,它没有批处理规范化层。
第一卷积块包含具有激活函数的 2D 卷积层。 与其他七个卷积块不同,它没有批处理规范化层。
4. 将其他七个卷积块添加到生成器网络:
......@@ -546,7 +546,7 @@ encoder8 = BatchNormalization()(encoder8)
encoder8 = LeakyReLU(alpha=leakyrelu_alpha)(encoder8)
```
这是发电机网络中编码器部分的末端。 生成器网络中的第二部分是解码器。 在接下来的几个步骤中,让我们为解码器编写代码。
这是生成器网络中编码器部分的末端。 生成器网络中的第二部分是解码器。 在接下来的几个步骤中,让我们为解码器编写代码。
5. 将第一个上采样卷积块添加到先前在 *pix2pix* 部分的体系结构中指示的参数中:
......@@ -611,7 +611,7 @@ decoder8 = Activation('tanh')(decoder8)
The 'concatenate' layer concatenates tensors along the channel dimension. You can provide a value for the axis, along which you want your tensors to be concatenated.
7. 最后,通过指定发电机网络的输入和输出来创建 Keras 模型:
7. 最后,通过指定生成器网络的输入和输出来创建 Keras 模型:
```py
# Create a Keras model
......@@ -756,7 +756,7 @@ def build_unet_generator():
return model
```
我们现在已经成功地为发电机网络创建了 Keras 模型。 在下一节中,我们将为判别器网络创建 Keras 模型。
我们现在已经成功地为生成器网络创建了 Keras 模型。 在下一节中,我们将为判别器网络创建 Keras 模型。
......@@ -900,7 +900,7 @@ output1 = concatenate([output1, output2])
final_output = Dense(2, activation="softmax")(output1)
```
`"softmax"`用作最后一个密集层的激活功能。 这将返回概率分布。
`"softmax"`用作最后一个密集层的激活函数。 这将返回概率分布。
10. 最后,通过如下指定网络的输入和输出来创建判别器模型:
......@@ -1094,7 +1094,7 @@ def build_adversarial_model(generator, discriminator):
return model
```
现在,我们已经成功地为发电机网络,判别器网络和对抗模型创建了模型。 我们准备训练 pix2pix。 在下一部分中,我们将在 Facades 数据集中训练 pix2pix 网络。
现在,我们已经成功地为生成器网络,判别器网络和对抗模型创建了模型。 我们准备训练 pix2pix。 在下一部分中,我们将在 Facades 数据集中训练 pix2pix 网络。
......@@ -1104,7 +1104,7 @@ def build_adversarial_model(generator, discriminator):
像任何其他 GAN 一样,训练 pix2pix 网络是一个两步过程。 第一步,我们训练判别器网络。 在第二步中,我们训练对抗网络,最终训练发电机网络。 让我们开始训练网络。
像任何其他 GAN 一样,训练 pix2pix 网络是一个两步过程。 第一步,我们训练判别器网络。 在第二步中,我们训练对抗网络,最终训练生成器网络。 让我们开始训练网络。
执行以下步骤来训练 SRGAN 网络:
......@@ -1272,7 +1272,7 @@ dis_losses.append(d_loss)
gen_losses.append(g_loss)
```
17. 另外,将平均损失存储到 TensorBoard 以进行可视化。 既存储损失,也要存储发电机网络的平均损失和判别器网络的平均损失:
17. 另外,将平均损失存储到 TensorBoard 以进行可视化。 既存储损失,也要存储生成器网络的平均损失和判别器网络的平均损失:
```py
write_log(tensorboard, 'discriminator_loss', np.mean(dis_losses),
......@@ -1313,7 +1313,7 @@ def save_images(real_images, real_sketches, generated_images, num_epoch, dataset
imwrite('results/X_full_{}_{}.png'.format(dataset_name, num_epoch), X[0])
```
现在,我们已经成功地在立面数据集上训练了 pix2pix 网络。 对网络进行 1000 个时代的培训,以获取高质量的发电机网络。
现在,我们已经成功地在立面数据集上训练了 pix2pix 网络。 对网络进行 1000 个时代的培训,以获取高质量的生成器网络。
......
......@@ -81,7 +81,7 @@
![](img/3ef1bf38-3d09-434a-993d-0a410667c1fe.png)
根据博弈论,这是一个不合作的博弈,它承认**纳什均衡**点。 当满足这种条件时,如果我们假设双方都知道对手的策略,那么他们就没有理由再改变自己的策略了。 在 GAN 的情况下,这种情况意味着一旦达到平衡(甚至只是理论上),生成器就可以继续输出样本,并确保它们不会被判别器误分类。 同时,判别器没有理由改变其策略,因为它可以完美地区分 *p <sub class="calibre20">数据</sub>* 和任何其他分布。 从动态角度来看,两个组件的训练速度都是不对称的。 尽管生成器通常需要更多的迭代,但判别器可以非常迅速地收敛。 但是,这样的过早收敛对于整体性能可能非常危险。 实际上,由于判别器提供的反馈,发电机也达到了最佳状态。 不幸的是,当梯度很小时,这种贡献可以忽略不计,其明显的结果是,生成器错过了提高其输出更好样本能力的机会(例如,当样本是图像时,它们的质量可能会保持非常低,甚至 具有复杂的架构)。 这种情况并不取决于发生器固有的容量不足,而是取决于判别器收敛(或非常接近收敛)后开始应用的有限次校正。 在实践中,由于没有特定的规则,唯一有效的建议是在训练过程中检查两个损失函数。 如果判别器的损失下降得太快,而发电机的损失仍然很大,那么通常最好在单个判别器步骤中插入更多的发电机训练步骤。
根据博弈论,这是一个不合作的博弈,它承认**纳什均衡**点。 当满足这种条件时,如果我们假设双方都知道对手的策略,那么他们就没有理由再改变自己的策略了。 在 GAN 的情况下,这种情况意味着一旦达到平衡(甚至只是理论上),生成器就可以继续输出样本,并确保它们不会被判别器误分类。 同时,判别器没有理由改变其策略,因为它可以完美地区分 *p <sub class="calibre20">数据</sub>* 和任何其他分布。 从动态角度来看,两个组件的训练速度都是不对称的。 尽管生成器通常需要更多的迭代,但判别器可以非常迅速地收敛。 但是,这样的过早收敛对于整体性能可能非常危险。 实际上,由于判别器提供的反馈,生成器也达到了最佳状态。 不幸的是,当梯度很小时,这种贡献可以忽略不计,其明显的结果是,生成器错过了提高其输出更好样本能力的机会(例如,当样本是图像时,它们的质量可能会保持非常低,甚至 具有复杂的架构)。 这种情况并不取决于生成器固有的容量不足,而是取决于判别器收敛(或非常接近收敛)后开始应用的有限次校正。 在实践中,由于没有特定的规则,唯一有效的建议是在训练过程中检查两个损失函数。 如果判别器的损失下降得太快,而生成器的损失仍然很大,那么通常最好在单个判别器步骤中插入更多的生成器训练步骤。
......@@ -91,7 +91,7 @@
假设我们有一个 GAN,该 GAN 已通过使用从 *p <sub class="calibre20">数据</sub>(x)*中提取的数据集`X`进行了适当的训练。 Goodfellow 等人证明,给定发生器分布 *p <sub class="calibre20">g</sub> (x)*,最佳判别器如下:
假设我们有一个 GAN,该 GAN 已通过使用从 *p <sub class="calibre20">数据</sub>(x)*中提取的数据集`X`进行了适当的训练。 Goodfellow 等人证明,给定生成器分布 *p <sub class="calibre20">g</sub> (x)*,最佳判别器如下:
![](img/bf275808-f597-4c3c-a017-6ecaa9f12a79.png)
......@@ -137,9 +137,9 @@ Examples of unimodal (left) and bimodal (right) distributions
现在,让我们想象一下我们正在处理人脸图片的多模式分布(例如下一节将要讨论的示例中的人脸图片)。 模式的内容是什么? 很难精确地回答这个问题,但是很容易理解,对应于最大数据生成过程的人脸应该包含数据集中最常见的元素(例如,如果 80% 的人留着胡须 ,我们可以合理地假设该模式将包含它)。
我们在使用 GAN 时面临的最著名,最棘手的问题之一就是**模式崩溃**,它涉及到次优的最终配置,其中生成器冻结在某个模式附近,并不断提供与 输出。 发生这种情况的原因非常难以分析(实际上,只有理论),但是我们可以理解如果重新考虑 minimax 游戏,为什么会发生这种情况。 当我们要训练两个不同的分量时,即使保证了纳什均衡,在几次迭代之后,对于最常见的模式,判别器也会变得非常有选择性。 当然,当训练发生器以欺骗判别器时,实现此目标的最简单方法是简单地避免所有采样远离模式。 这种行为增加了判别器的选择性,并创建了一个反馈过程,使 GAN 陷入只有数据生成过程只有一小部分区域的状态。
我们在使用 GAN 时面临的最著名,最棘手的问题之一就是**模式崩溃**,它涉及到次优的最终配置,其中生成器冻结在某个模式附近,并不断提供与 输出。 发生这种情况的原因非常难以分析(实际上,只有理论),但是我们可以理解如果重新考虑 minimax 游戏,为什么会发生这种情况。 当我们要训练两个不同的分量时,即使保证了纳什均衡,在几次迭代之后,对于最常见的模式,判别器也会变得非常有选择性。 当然,当训练生成器以欺骗判别器时,实现此目标的最简单方法是简单地避免所有采样远离模式。 这种行为增加了判别器的选择性,并创建了一个反馈过程,使 GAN 陷入只有数据生成过程只有一小部分区域的状态。
在梯度方面,判别器提供的用于优化发生器的信息很快变得非常稀缺,因为最常见的样本不需要任何调整。 另一方面,当生成器开始避免所有 *p(x)*不接近最大值的样本时,它们不会将判别器暴露给新的,可能有效的样本,因此梯度将 保持很小,直到消失为零。 不幸的是,没有可以用来避免此问题的全局策略,但是在本章中,我们将讨论一种建议的方法,以减轻模式崩溃(WGAN)的风险。 特别是,我们将把注意力集中在 Jensen-Shannon 发散的局限性上,在某些情况下,由于没有大的梯度,这可能导致 GAN 达到次优配置。 在本简介中,重要的是,不熟悉这些模型的读者应意识到风险,并能够在发生模式崩溃时识别出它。
在梯度方面,判别器提供的用于优化生成器的信息很快变得非常稀缺,因为最常见的样本不需要任何调整。 另一方面,当生成器开始避免所有 *p(x)*不接近最大值的样本时,它们不会将判别器暴露给新的,可能有效的样本,因此梯度将 保持很小,直到消失为零。 不幸的是,没有可以用来避免此问题的全局策略,但是在本章中,我们将讨论一种建议的方法,以减轻模式崩溃(WGAN)的风险。 特别是,我们将把注意力集中在 Jensen-Shannon 发散的局限性上,在某些情况下,由于没有大的梯度,这可能导致 GAN 达到次优配置。 在本简介中,重要的是,不熟悉这些模型的读者应意识到风险,并能够在发生模式崩溃时识别出它。
此时,我们可以继续进行实际操作,并使用 TensorFlow 建模真实的 GAN。
......@@ -192,7 +192,7 @@ nb_iterations = int(nb_samples / batch_size)
现在,我们可以基于以下结构为生成器定义 DAG:
* 具有 1,024(4×4)滤镜的 2D 卷积,步幅为[ *1,1* ),有效填充和线性输出
* 批量归一化和泄漏 ReLU 激活(当输入值为负时,性能更高;实际上,当 *x < 0* 时,标准 ReLU 的梯度为零,而泄漏 ReLU 的常数较小) 允许稍微修改的渐变)
* 批量归一化和 LReLU 激活(当输入值为负时,性能更高;实际上,当 *x < 0* 时,标准 ReLU 的梯度为零,而 LReLU 的常数较小) 允许稍微修改的渐变)
* 带有( *2、2* )步幅,相同填充和线性输出的 512(4×4)滤波器的 2D 卷积
* 批量标准化和泄漏的 ReLU 激活
* 256 个(4×4)滤波器的 2D 卷积,步幅为[ *2,2* ),,相同 填充,以及线性输出
......@@ -356,7 +356,7 @@ with graph.as_default():
![](img/4bebedd1-9438-42e7-aae9-c18aa72d2a49.png)
相同的概念适用于发电机损耗函数。 下一步需要定义两个 Adam 优化器。 如前所述,我们需要隔离变量以进行隔行训练。 因此,`minimize()`函数现在被提供了损失和必须更新的变量集。 TensorFlow 官方文档中建议使用上下文声明`tf.control_dependencies(tf.get_collection(tf.GraphKeys.UPDATE_OPS))`,只要采用批量标准化,其目标是仅在计算均值和方差之后才允许执行训练步骤(有关此技术的更多详细信息,请检查 原始论文:*批量标准化:通过减少内部协变量移位**Ioffe S.和 Szegedy C.**arXiv:1502.03167 [ cs.LG]* )。
相同的概念适用于生成器损耗函数。 下一步需要定义两个 Adam 优化器。 如前所述,我们需要隔离变量以进行隔行训练。 因此,`minimize()`函数现在被提供了损失和必须更新的变量集。 TensorFlow 官方文档中建议使用上下文声明`tf.control_dependencies(tf.get_collection(tf.GraphKeys.UPDATE_OPS))`,只要采用批量标准化,其目标是仅在计算均值和方差之后才允许执行训练步骤(有关此技术的更多详细信息,请检查 原始论文:*批量标准化:通过减少内部协变量移位**Ioffe S.和 Szegedy C.**arXiv:1502.03167 [ cs.LG]* )。
此时,我们可以创建一个会话并初始化所有变量,如下所示:
......@@ -503,7 +503,7 @@ Samples extracted from the Fashion MNIST dataset
现在,我们可以基于 DCGAN 的同一层定义生成器 DAG,如下所示:
* 具有 1,024(4×4)滤波器的 2D 卷积,步幅为[ *1,1,*), 有效 填充,以及线性输出
* 批量标准化和泄漏 ReLU 激活
* 批量标准化和 LReLU 激活
* 带有 512 个(4×4)滤波器的 2D 卷积,步幅为[ *2,2* ),,相同 填充,以及线性输出
* 批量标准化和泄漏的 ReLU 激活
* 256 个(4×4)滤波器的 2D 卷积,步幅为[ *2,2* ),,相同 填充,以及线性输出
......
......@@ -149,7 +149,7 @@
1. 没有; 生成器和判别器在功能上是不同的。
2. 不,不是这样,因为判别器的输出必须是一个概率(即 *p <sub class="calibre20">i</sub> ∈(0,1)*)。
3. 是; 这是正确的。 判别器可以学习非常快地输出不同的概率,,其损失函数的斜率可以变得接近于 0,从而减小了提供给发生器的校正反馈的幅度。
3. 是; 这是正确的。 判别器可以学习非常快地输出不同的概率,,其损失函数的斜率可以变得接近于 0,从而减小了提供给生成器的校正反馈的幅度。
4. 是; 通常会比较慢。
5. 评论者比较慢,因为每次更新后都会对变量进行裁剪。
6. 由于支撑脱节,Jensen-Shannon 散度等于 *log(2)*
......
......@@ -25,7 +25,7 @@
GAN 是学习生成类似于真实数据或训练集中数据的神经网络。 GAN 的关键思想是让生成器网络和判别器网络相互竞争:生成器试图生成看起来像真实数据的数据,而判别器试图分辨生成的数据是否真实(从已知实数 数据)或伪造(由生成器生成)。 生成器和判别器是一起训练的,在训练过程中,生成器学会生成看起来越来越像真实数据的数据,而判别器则学会将真实数据与伪数据区分开。 生成器通过尝试使判别器的输出概率为真实数据来学习,当将生成器的输出作为判别器的输入时,生成器的输出概率尽可能接近 1.0,而判别器通过尝试实现两个目标来学习:
* 当以发电机的输出作为输入时,使其输出的可能性为实,尽可能接近 0.0,这恰好是发电机的相反目标
* 当以生成器的输出作为输入时,使其输出的可能性为实,尽可能接近 0.0,这恰好是生成器的相反目标
* 当输入真实数据作为输入时,使其输出的可能性为实数,尽可能接近 1.0
In the next section, you'll see a detailed code snippet that matches the given description of the generator and the discriminator networks and their training process. If you feel like understanding more about GANs, in addition to our summary overview here, you can search for *"Introduction to GANs"* on YouTube and watch Ian Goodfellow's introduction and tutorial videos on GAN at NIPS (Neural Information Processing Systems) Conference 2016 and ICCV (International Conference on Computer Vision) 2017\. In fact, there are 7 NIPS 2016 Workshop on Adversarial Training videos and 12 ICCV 2017 GAN Tutorial videos on YouTube that you can immerse yourself in.
......
Markdown is supported
0% .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑!
想要评论请 注册