Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
D_ACMER
apachecn-dl-zh
提交
f62e9a5b
A
apachecn-dl-zh
项目概览
D_ACMER
/
apachecn-dl-zh
与 Fork 源项目一致
Fork自
OpenDocCN / apachecn-dl-zh
通知
1
Star
0
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
A
apachecn-dl-zh
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
f62e9a5b
编写于
12月 11, 2020
作者:
W
wizardforcel
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
2020-12-11 22:45:31
上级
65b7b869
变更
24
隐藏空白更改
内联
并排
Showing
24 changed file
with
192 addition
and
192 deletion
+192
-192
new/ai-py/11.md
new/ai-py/11.md
+5
-5
new/ai-py/13.md
new/ai-py/13.md
+3
-3
new/ai-py/14.md
new/ai-py/14.md
+2
-2
new/ai-py/15.md
new/ai-py/15.md
+3
-3
new/ai-py/17.md
new/ai-py/17.md
+1
-1
new/ai-py/18.md
new/ai-py/18.md
+3
-3
new/ai-py/19.md
new/ai-py/19.md
+1
-1
new/ai-py/20.md
new/ai-py/20.md
+1
-1
new/gan-proj/0.md
new/gan-proj/0.md
+1
-1
new/gan-proj/1.md
new/gan-proj/1.md
+7
-7
new/gan-proj/2.md
new/gan-proj/2.md
+5
-5
new/gan-proj/3.md
new/gan-proj/3.md
+20
-20
new/gan-proj/4.md
new/gan-proj/4.md
+10
-10
new/gan-proj/5.md
new/gan-proj/5.md
+21
-21
new/gan-proj/6.md
new/gan-proj/6.md
+65
-65
new/gan-proj/7.md
new/gan-proj/7.md
+9
-9
new/gan-proj/8.md
new/gan-proj/8.md
+23
-23
new/gan-proj/9.md
new/gan-proj/9.md
+1
-1
new/handson-unsup-learn-py/08.md
new/handson-unsup-learn-py/08.md
+3
-3
new/handson-unsup-learn-py/09.md
new/handson-unsup-learn-py/09.md
+2
-2
new/intel-mobi-proj-tf/03.md
new/intel-mobi-proj-tf/03.md
+1
-1
new/intel-mobi-proj-tf/06.md
new/intel-mobi-proj-tf/06.md
+3
-3
new/intel-mobi-proj-tf/07.md
new/intel-mobi-proj-tf/07.md
+1
-1
new/intel-mobi-proj-tf/10.md
new/intel-mobi-proj-tf/10.md
+1
-1
未找到文件。
new/ai-py/11.md
浏览文件 @
f62e9a5b
...
...
@@ -136,7 +136,7 @@ def create_toolbox(num_bits):
toolbox
.
register
(
"attr_bool"
,
random
.
randint
,
0
,
1
)
```
让我们注册
`individual`
功能
。 方法
`initRepeat`
带有三个参数–个体的容器类,用于填充容器的函数以及我们希望函数重复自身的次数:
让我们注册
`individual`
函数
。 方法
`initRepeat`
带有三个参数–个体的容器类,用于填充容器的函数以及我们希望函数重复自身的次数:
```
py
# Initialize structures
...
...
@@ -144,7 +144,7 @@ def create_toolbox(num_bits):
toolbox
.
attr_bool
,
num_bits
)
```
我们需要注册
`population`
功能
。 我们希望总体成为个体列表:
我们需要注册
`population`
函数
。 我们希望总体成为个体列表:
```
py
# Define the population to be a list of individuals
...
...
@@ -185,7 +185,7 @@ def create_toolbox(num_bits):
这是上一节中讨论的所有概念的实现。
`DEAP`
中常见的是
`toolbox`
生成器功能,我们将在本章通篇使用它。 因此,花一些时间来了解
`toolbox`
是如何产生的,这一点很重要。
从位模式的长度开始,通过定义
`main`
功能
:
从位模式的长度开始,通过定义
`main`
函数
:
```
py
if
__name__
==
"__main__"
:
...
...
@@ -394,7 +394,7 @@ def create_toolbox(strategy):
return
toolbox
```
定义
`main`
功能
。 首先定义个体数量和世代数量:
定义
`main`
函数
。 首先定义个体数量和世代数量:
```
py
if
__name__
==
"__main__"
:
...
...
@@ -671,7 +671,7 @@ def create_toolbox():
creator
.
create
(
"Individual"
,
gp
.
PrimitiveTree
,
fitness
=
creator
.
FitnessMin
)
```
创建
`toolbox`
和
`register`
功能
。 注册过程的完成类似于前面的部分:
创建
`toolbox`
和
`register`
函数
。 注册过程的完成类似于前面的部分:
```
py
toolbox
=
base
.
Toolbox
()
...
...
new/ai-py/13.md
浏览文件 @
f62e9a5b
...
...
@@ -157,7 +157,7 @@ class LastCoinStanding(TwoPlayersGame):
print
(
self
.
num_coins
,
'coins left in the pile'
)
```
定义
`main`
功能
并从定义转置表开始。 换位表用于游戏中以存储位置和运动,以加快算法的速度。
定义
`main`
函数
并从定义转置表开始。 换位表用于游戏中以存储位置和运动,以加快算法的速度。
输入以下代码:
...
...
@@ -299,7 +299,7 @@ class GameController(TwoPlayersGame):
return
-
100
if
self
.
loss_condition
()
else
0
```
定义
`main`
功能
并从定义算法开始。 Negamax 将用作此游戏的 AI 算法。 可以预先指定算法应预先考虑的步骤数。 在这种情况下,让我们选择
`7`
:
定义
`main`
函数
并从定义算法开始。 Negamax 将用作此游戏的 AI 算法。 可以预先指定算法应预先考虑的步骤数。 在这种情况下,让我们选择
`7`
:
```
py
if
__name__
==
"__main__"
:
...
...
@@ -444,7 +444,7 @@ class GameController(TwoPlayersGame):
return
-
100
if
self
.
loss_condition
()
else
0
```
定义
`main`
功能
并从定义算法开始。 然后,这两种算法将相互竞争。 Negamax 将用于第一个计算机播放器,
`SSS*`
算法将用于第二个计算机播放器。
`SSS*`
是一种搜索算法,它通过以最佳优先方式遍历树来进行状态空间搜索。 两种方法都将事先考虑的匝数作为输入参数。 在这种情况下,让我们同时使用
`5`
:
定义
`main`
函数
并从定义算法开始。 然后,这两种算法将相互竞争。 Negamax 将用于第一个计算机播放器,
`SSS*`
算法将用于第二个计算机播放器。
`SSS*`
是一种搜索算法,它通过以最佳优先方式遍历树来进行状态空间搜索。 两种方法都将事先考虑的匝数作为输入参数。 在这种情况下,让我们同时使用
`5`
:
```
py
if
__name__
==
'__main__'
:
...
...
new/ai-py/14.md
浏览文件 @
f62e9a5b
...
...
@@ -340,7 +340,7 @@ def tone_synthesizer(freq, duration, amplitude=1.0, sampling_freq=44100):
return
signal
.
astype
(
np
.
int16
)
```
定义
`main`
功能
。 让我们定义输出音频文件名:
定义
`main`
函数
。 让我们定义输出音频文件名:
```
py
if
__name__
==
'__main__'
:
...
...
@@ -428,7 +428,7 @@ if __name__=='__main__':
duration
=
item
[
1
]
```
使用
`tone_synthesizer`
功能
合成音色:
使用
`tone_synthesizer`
函数
合成音色:
```
py
# Synthesize the tone
...
...
new/ai-py/15.md
浏览文件 @
f62e9a5b
...
...
@@ -582,7 +582,7 @@ def extract_features(word, N=2):
return
{
'feature'
:
last_n_letters
.
lower
()}
```
定义
`main`
功能
并从
`scikit-learn`
包中提取训练数据。 此数据包含带有标签的男性和女性姓名:
定义
`main`
函数
并从
`scikit-learn`
包中提取训练数据。 此数据包含带有标签的男性和女性姓名:
```
py
if
__name__
==
'__main__'
:
...
...
@@ -689,7 +689,7 @@ def extract_features(words):
return
dict
([(
word
,
True
)
for
word
in
words
])
```
定义
`main`
功能
并加载带有标签的电影评论:
定义
`main`
函数
并加载带有标签的电影评论:
```
py
if
__name__
==
'__main__'
:
...
...
@@ -886,7 +886,7 @@ tokens = tokenizer.tokenize(input_text.lower())
return
tokens_stemmed
```
定义
`main`
功能
并从为您提供的文件
`data.txt`
中加载输入数据:
定义
`main`
函数
并从为您提供的文件
`data.txt`
中加载输入数据:
```
py
if
__name__
==
'__main__'
:
...
...
new/ai-py/17.md
浏览文件 @
f62e9a5b
...
...
@@ -138,7 +138,7 @@ def read_data(input_file, index):
return
output
```
定义和
`main`
功能
并指定输入文件:
定义和
`main`
函数
并指定输入文件:
```
py
if
__name__
==
'__main__'
:
...
...
new/ai-py/18.md
浏览文件 @
f62e9a5b
...
...
@@ -225,7 +225,7 @@ def get_frame(cap, scaling_factor):
return
frame
```
定义
`main`
功能
。 首先初始化视频捕获对象:
定义
`main`
函数
。 首先初始化视频捕获对象:
```
py
if
__name__
==
'__main__'
:
...
...
@@ -758,7 +758,7 @@ class ObjectTracker(object):
cv2
.
destroyAllWindows
()
```
定义
`main`
功能
并开始跟踪:
定义
`main`
函数
并开始跟踪:
```
py
if
__name__
==
'__main__'
:
...
...
@@ -1011,7 +1011,7 @@ def start_tracking():
break
```
定义
`main`
功能
并开始跟踪。 停止跟踪器后,请确保所有窗口均已正确关闭:
定义
`main`
函数
并开始跟踪。 停止跟踪器后,请确保所有窗口均已正确关闭:
```
py
if
__name__
==
'__main__'
:
...
...
new/ai-py/19.md
浏览文件 @
f62e9a5b
...
...
@@ -571,7 +571,7 @@ def visualize_output(nn, num_points_test):
plt
.
plot
(
output
.
reshape
(
num_points_test
*
4
))
```
定义
`main`
功能
并创建一个波形:
定义
`main`
函数
并创建一个波形:
```
py
if
__name__
==
'__main__'
:
...
...
new/ai-py/20.md
浏览文件 @
f62e9a5b
...
...
@@ -575,7 +575,7 @@ W_fc2, b_fc2 = create_layer([1024, 10])
y_conv
=
tf
.
matmul
(
h_fc1_drop
,
W_fc2
)
+
b_fc2
```
定义
`loss`
功能和
`optimizer`
功能
:
定义
`loss`
函数和
`optimizer`
函数
:
```
py
# Define the entropy loss and the optimizer
...
...
new/gan-proj/0.md
浏览文件 @
f62e9a5b
...
...
@@ -30,7 +30,7 @@
第 1 章,“生成对抗网络”的介绍始于 GAN 的概念。 读者将学习什么是判别器,什么是生成器以及什么是博弈论。 接下来的几个主题将涵盖生成器的结构,判别器的结构,生成器和判别器的目标函数,GAN 的训练算法,Kullback-Leibler 和 Jensen-Shannon 散度,GAN 的评估矩阵,GAN 的不同问题, GAN 中梯度消失和爆炸,纳什均衡,批量
归一
化和正则化的问题。
第 1 章,“生成对抗网络”的介绍始于 GAN 的概念。 读者将学习什么是判别器,什么是生成器以及什么是博弈论。 接下来的几个主题将涵盖生成器的结构,判别器的结构,生成器和判别器的目标函数,GAN 的训练算法,Kullback-Leibler 和 Jensen-Shannon 散度,GAN 的评估矩阵,GAN 的不同问题, GAN 中梯度消失和爆炸,纳什均衡,批量
标准
化和正则化的问题。
第 2 章,“3D-GAN – 使用 GAN 生成形状”首先简要介绍 3D-GAN 和各种架构细节。 在本章中,我们将训练 3D-GAN 生成真实世界的 3D 形状。 我们编写代码来收集 3D Shapenet 数据集,对其进行清理并使其经过训练。 然后,我们将使用 Keras 深度学习库为 3D-GAN 编写代码。
...
...
new/gan-proj/1.md
浏览文件 @
f62e9a5b
...
...
@@ -427,7 +427,7 @@ pix2pix 网络是由 Phillip Isola,朱俊彦,周廷辉和 Alexei A. Efros
当我们网络的输入分配发生变化时,就会发生内部协变量偏移。 当输入分布更改时,隐藏层将尝试学习以适应新的分布。 这减慢了训练过程。 如果进程变慢,则需要很长时间才能收敛到全局最小值。 当网络输入的统计分布与以前看到的输入完全不同时,就会出现此问题。 批量
归一
化和其他归一化技术可以解决此问题。 我们将在以下各节中进行探讨。
当我们网络的输入分配发生变化时,就会发生内部协变量偏移。 当输入分布更改时,隐藏层将尝试学习以适应新的分布。 这减慢了训练过程。 如果进程变慢,则需要很长时间才能收敛到全局最小值。 当网络输入的统计分布与以前看到的输入完全不同时,就会出现此问题。 批量
标准
化和其他归一化技术可以解决此问题。 我们将在以下各节中进行探讨。
...
...
@@ -536,17 +536,17 @@ pix2pix 网络是由 Phillip Isola,朱俊彦,周廷辉和 Alexei A. Efros
批量
归一
化是一种对特征向量进行归一化以使其没有均值或单位方差的技术。 它用于稳定学习并处理较差的权重初始化问题。 这是预处理步骤,适用于网络的隐藏层,可帮助我们减少内部协变量偏移。
批量
标准
化是一种对特征向量进行归一化以使其没有均值或单位方差的技术。 它用于稳定学习并处理较差的权重初始化问题。 这是预处理步骤,适用于网络的隐藏层,可帮助我们减少内部协变量偏移。
批量
归一化由 Ioffe 和 Szegedy 在其 2015 年论文《批量归一
化:通过减少内部协变量偏移来加速深度网络训练》中引入。
[
可以在以下链接中找到
](
https://arxiv.org/pdf/1502.03167.pdf
)
。
批量
标准化由 Ioffe 和 Szegedy 在其 2015 年论文《批量标准
化:通过减少内部协变量偏移来加速深度网络训练》中引入。
[
可以在以下链接中找到
](
https://arxiv.org/pdf/1502.03167.pdf
)
。
The benefits of batch normalization are as follows:
*
**减少内部协变量偏移**
:批量
归一
化有助于我们通过归一化值来减少内部协变量偏移。
*
**减少内部协变量偏移**
:批量
标准
化有助于我们通过归一化值来减少内部协变量偏移。
*
**更快的训练**
:如果从正态/高斯分布中采样值 ,则网络将更快地训练。 批处理规范化有助于将值白化到我们网络的内部层。 总体训练速度更快,但是由于涉及额外的计算,因此每次迭代都会变慢。
*
**更高的准确性**
:批量标准化提供了更好的准确性。
*
**较高的学习率**
:通常,当我们训练神经网络时,我们使用较低的学习率,这需要很长时间才能收敛网络。 通过批量
归一
化,我们可以使用更高的学习率,从而使我们的网络更快地达到全球最低水平。
*
**减少了丢弃法的需求**
:当我们使用丢弃时,我们会破坏网络内部层中的一些基本信息。 批量
归一
化充当一个正则化器,这意味着我们可以训练网络而无需退出层。
*
**较高的学习率**
:通常,当我们训练神经网络时,我们使用较低的学习率,这需要很长时间才能收敛网络。 通过批量
标准
化,我们可以使用更高的学习率,从而使我们的网络更快地达到全球最低水平。
*
**减少了丢弃法的需求**
:当我们使用丢弃时,我们会破坏网络内部层中的一些基本信息。 批量
标准
化充当一个正则化器,这意味着我们可以训练网络而无需退出层。
在批处理规范化中,我们将规范化应用于所有隐藏层,而不是仅将其应用于输入层。
...
...
@@ -558,7 +558,7 @@ The benefits of batch normalization are as follows:
如上一节所述,批量
归一
化仅通过利用来自该批量的信息来对一批样本进行归一化。 实例规范化是一种略有不同的方法。 在实例归一化中,我们仅通过利用来自该特征图的信息来归一化每个特征图。 实例规范化由 Dmitry Ulyanov 和 Andrea Vedaldi 在标题为《实例规范化:用于快速风格化的缺失成分》的论文中介绍,
[
可通过以下链接获得
](
https://arxiv.org/pdf/1607.08022.pdf
)
。
如上一节所述,批量
标准
化仅通过利用来自该批量的信息来对一批样本进行归一化。 实例规范化是一种略有不同的方法。 在实例归一化中,我们仅通过利用来自该特征图的信息来归一化每个特征图。 实例规范化由 Dmitry Ulyanov 和 Andrea Vedaldi 在标题为《实例规范化:用于快速风格化的缺失成分》的论文中介绍,
[
可通过以下链接获得
](
https://arxiv.org/pdf/1607.08022.pdf
)
。
...
...
new/gan-proj/2.md
浏览文件 @
f62e9a5b
...
...
@@ -99,7 +99,7 @@
*
**3D 卷积层**
:5
*
**通道**
:64、128、256、512、1
*
**核大小**
:4、4、4、4、4、4
*
**
大步前进
**
:2、2、2、2、1
*
**
步幅
**
:2、2、2、2、1
*
**激活**
:LReLU,LReLU,LReLU,LReLU,Sigmoid
*
**批量标准化**
:是,是,是,是,无
*
**池化层**
:否,否,否,否,否
...
...
@@ -264,7 +264,7 @@ unzip 3DShapeNetsCode.zip
执行以下代码以从
`.mat`
文件加载 3D 图像:
1.
使用
`scipy`
中的
`loadmat()`
功能
检索
`voxels`
。 代码如下:
1.
使用
`scipy`
中的
`loadmat()`
函数
检索
`voxels`
。 代码如下:
```
py
import
scipy.io
as
io
...
...
@@ -280,7 +280,7 @@ voxels = np.pad(voxels, (1, 1), 'constant', constant_values=(0, 0))
`pad()`
方法采用四个参数,它们是实际体素的 N 维数组,需要填充到每个轴边缘的值的数量,模式值(
`constant`
)和
`constant_values`
被填充。
3.
然后,使用
`scipy.ndimage`
模块中的
`zoom()`
功能
将 3D 图像转换为尺寸为
`64x64x64`
的 3D 图像。
3.
然后,使用
`scipy.ndimage`
模块中的
`zoom()`
函数
将 3D 图像转换为尺寸为
`64x64x64`
的 3D 图像。
```
py
import
scipy.ndimage
as
nd
...
...
@@ -801,7 +801,7 @@ TensorBoard 的 GRAPHS 部分包含两个网络的图形 。 如果网络性能
我们训练的模型可能不是一个完美的模型,但是我们可以优化超参数来改进它。 3D-GAN 中有许多可以优化的超参数。 其中包括:
*
**批量大小**
:尝试使用 8、16、32、54 或 128 的批量大小值。
*
**
时
期数**
:尝试 100 个时期,并将其逐渐增加到 1,000-5,000。
*
**
周
期数**
:尝试 100 个时期,并将其逐渐增加到 1,000-5,000。
*
**学习率**
:这是最重要的超参数。 用 0.1、0.001、0.0001 和其他较小的学习率进行实验。
*
**生成器和判别器网络**
的不同层中的激活函数:使用 Sigmoid,tanh,ReLU,LeakyReLU,ELU,SeLU 和其他激活函数进行实验。
*
**优化算法**
:尝试使用 Adam,SGD,Adadelta,RMSProp 和 Keras 框架中可用的其他优化器。
...
...
@@ -836,6 +836,6 @@ TensorBoard 的 GRAPHS 部分包含两个网络的图形 。 如果网络性能
在本章中,我们探讨了 3D-GAN。 我们首先介绍了 3D-GAN,并介绍了架构以及生成器和判别器的配置。 然后,我们经历了建立项目所需的不同步骤。 我们还研究了如何准备数据集。 最后,我们在 Keras 框架中实现了 3D-GAN,并在我们的数据集中对其进行了训练。 我们还探讨了不同的超参数选项。 我们通过探索 3D-GAN 的实际应用来结束本章。
在下一章中,我们将学习如何使用
**条件生成对抗网络
(**
cGAN
**)执行面部老化。**
在下一章中,我们将学习如何使用
**条件生成对抗网络
**
(
**cGAN**
)执行面部老化。
new/gan-proj/3.md
浏览文件 @
f62e9a5b
...
...
@@ -66,7 +66,7 @@ cGAN 的问题在于它们无法学习将属性`y`的 输入图像`x`逆映射
编码器网络的主要目标是生成所提供图像的潜向量。 基本上,它会拍摄尺寸为
`(64, 64, 3)`
的图像,并将其转换为 100 维向量。 编码器网络是一个深度卷积神经网络。 网络包含四个卷积块和两个密集层。 每个卷积块包含一个卷积层,一个批标准化层和一个激活函数。 在每个卷积块中,每个卷积层后面都有一个批处理归一化层,但第一个卷积层除外。 Age-cGAN 部分的
*Keras 实现将介绍编码器网络的配置。*
编码器网络的主要目标是生成所提供图像的潜向量。 基本上,它会拍摄尺寸为
`(64, 64, 3)`
的图像,并将其转换为 100 维向量。 编码器网络是一个深度卷积神经网络。 网络包含四个卷积块和两个密集层。 每个卷积块包含一个卷积层,一个批标准化层和一个激活函数。 在每个卷积块中,每个卷积层后面都有一个批处理归一化层,但第一个卷积层除外。 Age-cGAN 部分的
“Keras 实现”将介绍编码器网络的配置。
...
...
@@ -108,9 +108,9 @@ cGAN 的问题在于它们无法学习将属性`y`的 输入图像`x`逆映射
Age-cGAN 具有多个训练阶段。 如上一节所述,Age-cGAN 具有四个网络,并经过三个阶段的训练。 Age-cGAN 的训练包括三个阶段:
1.
**
有条件的
GAN 训练**
:在此阶段,我们训练生成器网络和判别器网络。
1.
**
条件
GAN 训练**
:在此阶段,我们训练生成器网络和判别器网络。
2.
**初始潜在向量近似**
:在此阶段,我们训练编码器网络。
3.
**潜向量优化**
:在此阶段,我们同时优化编码器和生成器网络。
3.
**潜
在
向量优化**
:在此阶段,我们同时优化编码器和生成器网络。
以下屏幕截图显示了 Age-cGAN 的各个阶段:
...
...
@@ -166,7 +166,7 @@ Age-cGAN的各个阶段,资料来源:[使用条件生成对抗网络进行
![](
img/98bda784-ced5-4608-8c1d-38477d40cb8f.png
)
*FR*
是面部识别网络。 该方程式表明,真实图像和重建图像之间的欧几里得距离应最小。 在此阶段,我们尝试最小化距离以最大程度地保留身份。
`FR`
是面部识别网络。 该方程式表明,真实图像和重建图像之间的欧几里得距离应最小。 在此阶段,我们尝试最小化距离以最大程度地保留身份。
...
...
@@ -365,7 +365,7 @@ input_layer = Input(shape=(64, 64, 3))
2.
接下来,添加第一个卷积块,其中包含具有激活函数的 2D 卷积层,具有以下配置:
*
**过滤器**
:
`32`
*
**核大小**
:
`5`
*
**
大步前进
**
:
`2`
*
**
步幅
**
:
`2`
*
**填充**
:
``same``
*
**激活**
:
`LeakyReLU`
,其中
`alpha`
等于
`0.2`
:
...
...
@@ -376,9 +376,9 @@ input_layer = Input(shape=(64, 64, 3))
3.
接下来,再添加三个卷积块,其中每个都包含一个 2D 卷积层,然后是一个批处理归一化层和一个激活函数,具有以下配置:
*
**过滤器**
:
`64`
,
`128`
,
`256`
*
**核大小**
:
`5`
,
`5`
,
`5`
*
**
跨越
**
:
`2`
,
`2`
,
`2`
*
**
步幅
**
:
`2`
,
`2`
,
`2`
*
**填充**
:
`same`
,
`same`
,
``same``
*
**批量
归一化**
:每个卷积层后面都有一个批量归一
化层
*
**批量
标准化**
:每个卷积层后面都有一个批量标准
化层
*
**激活**
:
`LealyReLU`
,
`LeakyReLU`
,
`LeakyReLU`
,其中
`alpha`
等于
`0.2`
:
```
py
...
...
@@ -404,7 +404,7 @@ enc = LeakyReLU(alpha=0.2)(enc)
将
`n`
维张量转换为一维张量(数组)称为“扁平化”。
5.
接下来,添加具有以下配置的密集(完全连接)层,批处理规范化层和激活函数:
*
**单
位
(节点)**
:2,096
*
**单
元
(节点)**
:2,096
*
**批量标准化**
:是
*
**激活**
:
`LeakyReLU`
,其中
`alpha`
等于
`0.2`
:
...
...
@@ -415,7 +415,7 @@ enc = LeakyReLU(alpha=0.2)(enc)
```
6.
接下来,使用以下配置添加第二个密集(完全连接)层:
*
**单
位
(节点)**
:
`100`
*
**单
元
(节点)**
:
`100`
*
**激活**
:无:
```
py
...
...
@@ -504,7 +504,7 @@ x = concatenate([input_z_noise, input_label])
上一步将生成级联张量。
3.
接下来,添加具有以下配置的密集(完全连接)块:
*
**单
位
(节点)**
:
`2,048`
*
**单
元
(节点)**
:
`2,048`
*
**输入尺寸**
:106
*
**激活**
:
`LeakyReLU`
的
`alpha`
等于
``0.2``
*
**退出**
:
`0.2`
:
...
...
@@ -516,7 +516,7 @@ x = Dropout(0.2)(x)
```
4.
接下来,使用以下配置添加第二个密集(完全连接)块:
*
**单
位
(节点)**
:16,384
*
**单
元
(节点)**
:16,384
*
**批量标准化**
:是
*
**激活**
:
`alpha`
等于
`0.2`
的
`LeakyReLU`
*
**退出**
:
`0.2`
:
...
...
@@ -536,12 +536,12 @@ x = Reshape((8, 8, 256))(x)
该层将生成张量为(
`batch_size`
,
`8, 8, 256`
)的张量。
6.
接下来,添加一个
升采样模块,该模块包含一个升
采样层,其后是一个具有以下配置的 2D 卷积层和一个批归一化层:
6.
接下来,添加一个
上采样模块,该模块包含一个上
采样层,其后是一个具有以下配置的 2D 卷积层和一个批归一化层:
*
**上采样大小**
:
`(2, 2)`
*
**过滤器**
:
`128`
*
**核大小**
:
`5`
*
**填充**
:
`same`
*
**批量
规范
化**
:是,
`momentum`
等于
`0.8`
*
**批量
标准
化**
:是,
`momentum`
等于
`0.8`
*
**激活**
:
`LeakyReLU`
,其中
`alpha`
等于
`0.2`
:
```
py
...
...
@@ -562,7 +562,7 @@ x = BatchNormalization(momentum=0.8)(x)
x
=
LeakyReLU
(
alpha
=
0.2
)(
x
)
```
8.
接下来,添加最后一个
升
采样块。 该配置与上一层相似,除了在卷积层中使用了三个过滤器并且不使用批处理归一化的事实:
8.
接下来,添加最后一个
上
采样块。 该配置与上一层相似,除了在卷积层中使用了三个过滤器并且不使用批处理归一化的事实:
```
py
x
=
UpSampling2D
(
size
=
(
2
,
2
))(
x
)
...
...
@@ -646,9 +646,9 @@ label_input = Input(shape=label_shape)
```
2.
接下来,添加具有以下配置的二维卷积块(Conv2D + 激活函数):
*
**过滤器**
=
`64`
*
**过滤器**
:
`64`
*
**核大小**
:
`3`
*
**
大步前进
**
:
`2`
*
**
步幅
**
:
`2`
*
**填充**
:
`same`
*
**激活**
:
`LeakyReLU`
,其中
`alpha`
等于
`0.2`
:
...
...
@@ -663,7 +663,7 @@ x = LeakyReLU(alpha=0.2)(x)
label_input1
=
Lambda
(
expand_label_input
)(
label_input
)
```
`expand_label_input`
功能
如下:
`expand_label_input`
函数
如下:
```
py
# The expand_label_input function
...
...
@@ -685,7 +685,7 @@ x = concatenate([x, label_input1], axis=3)
5.
添加具有以下配置的卷积块(2D 卷积层 + 批处理归一化 + 激活函数):
*
**过滤器**
:
`128`
*
**核大小**
:
`3`
*
**
大步前进
**
:
`2`
*
**
步幅
**
:
`2`
*
**填充**
:
`same`
*
**批量标准化**
:是
*
**激活**
:
`LeakyReLU`
,其中
`alpha`
等于
`0.2`
:
...
...
@@ -847,7 +847,7 @@ tensorboard.set_model(generator)
tensorboard
.
set_model
(
discriminator
)
```
6.
接下来,使用在
*准备数据*
部分中定义的
`load_data`
函数加载所有图像:
6.
接下来,使用在
“准备数据”
部分中定义的
`load_data`
函数加载所有图像:
```
py
images
,
age_list
=
load_data
(
wiki_dir
=
wiki_dir
,
dataset
=
"wiki"
)
...
...
@@ -1265,7 +1265,7 @@ image_resizer.compile(loss=loss, optimizer='adam')
fr_model
.
compile
(
loss
=
loss
,
optimizer
=
"adam"
)
```
请参阅
[
这里
](
https://github.com/PacktPublishing/Generative-Adversarial-Networks-Projects/Age-cGAN/main.py
)
以获取
`build_fr_model()`
功能
。
请参阅
[
这里
](
https://github.com/PacktPublishing/Generative-Adversarial-Networks-Projects/Age-cGAN/main.py
)
以获取
`build_fr_model()`
函数
。
4.
接下来,创建另一个对抗模型。 在此对抗模型中,我们将具有三个网络:编码器,生成器和面部识别模型:
...
...
new/gan-proj/4.md
浏览文件 @
f62e9a5b
...
...
@@ -235,7 +235,7 @@ gallery-dl https://danbooru.donmai.us/posts?tags=face
在本节中,我们将从图像中裁剪出面孔。 我们将使用
**python-animeface**
从图像中裁剪出面孔。 这是一个开源 GitHub 存储库,可从命令行的图像中自动裁剪面部。
[
它可以通过以下链接公开获得
](
https://github.com/nya3jp/python-animeface
)
。
在本节中,我们将从图像中裁剪出面孔。 我们将使用
`python-animeface`
从图像中裁剪出面孔。 这是一个开源 GitHub 存储库,可从命令行的图像中自动裁剪面部。
[
它可以通过以下链接公开获得
](
https://github.com/nya3jp/python-animeface
)
。
执行以下步骤来裁剪图像并调整其大小:
...
...
@@ -349,7 +349,7 @@ total_num_faces = 0 for index, filename in enumerate(glob.glob('/path/to/direc
print
(
"Total number of faces:{}"
.
format
(
total_num_faces
))
```
前面的脚本将从包含下载图像的文件夹中加载所有图像,使用
`python-animeface`
库检测脸部,然后
**从初始图像中裁剪出
**
脸部
。 然后,裁切后的图像将被调整为
`64 x 64`
的尺寸。如果要更改图像的尺寸,请相应地更改生成器和判别器的架构。 我们现在准备在我们的网络上工作。
前面的脚本将从包含下载图像的文件夹中加载所有图像,使用
`python-animeface`
库检测脸部,然后
**从初始图像中裁剪出
脸部**
。 然后,裁切后的图像将被调整为
`64 x 64`
的尺寸。如果要更改图像的尺寸,请相应地更改生成器和判别器的架构。 我们现在准备在我们的网络上工作。
...
...
@@ -386,7 +386,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
))
...
...
@@ -424,7 +424,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'
))
...
...
@@ -504,9 +504,9 @@ dis_model = Sequential()
```
2.
添加一个 2D 卷积层,该层采用形状为
`(64, 64, 3)`
的输入图像。 该层的超参数如下。 另外,添加具有
`0.2`
的
`alpha`
值的
`LeakyReLU`
作为激活函数:
*
**过滤器
:**
128
*
**核大小
:**
`(5, 5)`
*
**填充
:**
相同:
*
**过滤器
**
:
128
*
**核大小
**
:
`(5, 5)`
*
**填充
**
:
相同:
```
py
dis_model
.
add
(
Conv2D
(
filters
=
128
,
kernel_size
=
5
,
padding
=
'same'
,
...
...
@@ -524,7 +524,7 @@ dis_model.add(MaxPooling2D(pool_size=(2, 2)))
4.
接下来,添加具有以下配置的另一个 2D 卷积层:
*
**过滤器**
:256
*
**核大小**
:
`(3, 3)`
*
**核大小**
:
`(3, 3)`
*
**激活函数**
:
`LeakyReLU`
,具有
`alpha`
0.2
*
**2D 最大池中的池大小**
:
`(2, 2)`
...
...
@@ -605,7 +605,7 @@ def get_discriminator():
return
dis_model
```
在本节中,我们已成功实现了判别器和生成器网络。 在下一部分中,我们将在
*下载和准备动漫角色数据集*
部分中准备的数据集上训练模型。
在本节中,我们已成功实现了判别器和生成器网络。 在下一部分中,我们将在
“下载和准备动漫角色数据集”
部分中准备的数据集上训练模型。
...
...
@@ -685,7 +685,7 @@ gen_model = build_generator()
gen_model
.
compile
(
loss
=
'binary_crossentropy'
,
optimizer
=
gen_optimizer
)
```
使用
`binary_crossentropy`
作为生成器网络的
`loss`
功能
,并使用
`gen_optimizer`
作为优化器。
使用
`binary_crossentropy`
作为生成器网络的
`loss`
函数
,并使用
`gen_optimizer`
作为优化器。
3.
接下来,创建判别模型的实例,并对其进行编译,如下所示:
...
...
new/gan-proj/5.md
浏览文件 @
f62e9a5b
...
...
@@ -71,9 +71,9 @@
|
**层名称**
|
**超参数**
|
**输入形状**
|
**输出形状**
|
| --- | --- | --- | --- |
| 2D 卷积层 |
`Filters=64, kernel_size=3, strides=1, padding='same', activation='relu'`
|
`(64, 64, 64)`
|
`(64, 64, 64)`
|
| 批量
归一
化层 |
`Momentum=0.8`
|
`(64, 64, 64)`
|
`(64, 64, 64)`
|
| 批量
标准
化层 |
`Momentum=0.8`
|
`(64, 64, 64)`
|
`(64, 64, 64)`
|
| 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)`
|
| 批量
标准
化层 |
`Momentum=0.8`
|
`(64, 64, 64)`
|
`(64, 64, 64)`
|
| 加法层 |
`None`
|
`(64, 64, 64)`
|
`(64, 64, 64)`
|
加法层计算输入到块的张量和最后一批归一化层的输出之和。 生成器网络包含 16 个具有上述配置的残差块。
...
...
@@ -83,9 +83,9 @@
|
**层名称**
|
**超参数**
|
**输入形状**
|
**输出形状**
|
| --- | --- | --- | --- |
| 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)`
|
| 批量
标准
化层 |
`Momentum=0.8`
|
`(64, 64, 64)`
|
`(64, 64, 64)`
|
*
**上采样块**
:上采样块包含一个上采样层和一个 2D 卷积层,并使用 relu 作为激活函数。 生成器网络中有两个上采样模块。 第一个
升
采样模块的配置如下:
*
**上采样块**
:上采样块包含一个上采样层和一个 2D 卷积层,并使用 relu 作为激活函数。 生成器网络中有两个上采样模块。 第一个
上
采样模块的配置如下:
|
**层名称**
|
**超参数**
|
**输入形状**
|
**输出形状**
|
| --- | --- | --- | --- |
...
...
@@ -120,13 +120,13 @@
| 输入层 | 没有 |
`(256, 256, 3)`
|
`(256, 256, 3)`
|
| 2D 卷积层 |
`filter= 64, kernel_size = 3, stride= 1, padding='same', activcation='leakyrelu'`
|
`(256, 256, 3)`
|
`(256, 256, 64)`
|
| 2D 卷积层 |
`filter= 64, kernel_size = 3, stride= 2, padding='same', activcation='leakyrelu'`
|
`(256, 256, 64)`
|
`(128, 128, 64)`
|
| 批量
归一
化层 |
`momentum= 0.8`
|
`(128, 128, 64)`
|
`(128, 128, 64)`
|
| 批量
标准
化层 |
`momentum= 0.8`
|
`(128, 128, 64)`
|
`(128, 128, 64)`
|
| 2D 卷积层 |
`filter= 128, kernel_size = 3, stride= 1, padding='same', activcation='leakyrelu'`
|
`(128, 128, 64)`
|
`(128, 128, 128)`
|
| 批量
归一
化层 |
`momentum= 0.8`
|
`(128, 128, 128)`
|
`(128, 128, 128)`
|
| 批量
标准
化层 |
`momentum= 0.8`
|
`(128, 128, 128)`
|
`(128, 128, 128)`
|
| 2D 卷积层 |
`filter= 128, kernel_size = 3, stride= 2, padding='same', activcation='leakyrelu'`
|
`(128, 128, 128)`
|
`(64, 64, 128)`
|
| 批量
归一
化层 |
`momentum= 0.8`
|
`(64, 64, 128)`
|
`(64, 64, 128)`
|
| 批量
标准
化层 |
`momentum= 0.8`
|
`(64, 64, 128)`
|
`(64, 64, 128)`
|
| 2D 卷积层 |
`filter= 256, kernel_size = 3, stride= 1, padding='same', activcation='leakyrelu'`
|
`(64, 64, 128)`
|
`(64, 64, 256)`
|
| 批量
归一
化层 |
`momentum= 0.8`
|
`(64, 64, 256)`
|
`(64, 64, 256)`
|
| 批量
标准
化层 |
`momentum= 0.8`
|
`(64, 64, 256)`
|
`(64, 64, 256)`
|
| 2D 卷积层 |
`filter= 256, kernel_size = 3, stride= 2, padding='same', activcation='leakyrelu'`
|
`(64, 64, 256)`
|
`(32, 32, 256)`
|
现在,我们对这两个网络的架构有了清晰的了解。 在下一部分中,让我们看一下训练 SRGAN 所需的目标函数。
...
...
@@ -354,7 +354,7 @@ input_layer = Input(shape=input_shape)
配置:
*
**过滤器**
:
`64`
*
**核大小**
:
`9`
*
**
大步前进
**
:
`1`
*
**
步幅
**
:
`1`
*
**填充**
:
`same`
*
**激活**
:
`relu:`
...
...
@@ -400,9 +400,9 @@ for i in range(residual_blocks - 1):
配置:
*
**过滤器**
:
`64`
*
**核大小**
:
`3`
*
**
大步前进
**
:
``1``
*
**
步幅
**
:
``1``
*
**填充**
:
`same`
*
**批量
归一
化**
:是(动量为 0.8):
*
**批量
标准
化**
:是(动量为 0.8):
```
py
gen2
=
Conv2D
(
filters
=
64
,
kernel_size
=
3
,
strides
=
1
,
padding
=
'same'
)(
res
)
...
...
@@ -415,12 +415,12 @@ gen2 = BatchNormalization(momentum=momentum)(gen2)
gen3
=
Add
()([
gen2
,
gen1
])
```
8.
接下来,添加一个
升
采样块,如下所示:
8.
接下来,添加一个
上
采样块,如下所示:
配置:
*
**上采样大小**
:
`2`
*
**
文件管理
器**
:
`256`
*
**
过滤
器**
:
`256`
*
**核大小**
:
`3`
*
**
大步前进
**
:
`1`
*
**
步幅
**
:
`1`
*
**填充**
:
`same`
*
**激活**
:
`PReLU:`
...
...
@@ -433,9 +433,9 @@ gen4 = Activation('relu')(gen4)
9.
接下来,添加另一个上采样块,如下所示:
配置:
*
**上采样大小**
:
`2`
*
**
文件管理
器**
:
`256`
*
**
过滤
器**
:
`256`
*
**核大小**
:
`3`
*
**
大步前进
**
:
`1`
*
**
步幅
**
:
`1`
*
**填充**
:
`same`
*
**激活**
:
`PReLU:`
...
...
@@ -449,7 +449,7 @@ gen5 = Activation('relu')(gen5)
配置:
*
**过滤器**
:
`3`
(等于通道数)
*
**核大小**
:
`9`
*
**
大步前进
**
:
`1`
*
**
步幅
**
:
`1`
*
**填充**
:
`same`
*
**激活**
:
`tanh:`
...
...
@@ -547,7 +547,7 @@ input_layer = Input(shape=input_shape)
配置:
*
**过滤器**
:
`64`
*
**核大小**
:
`3`
*
**
大步前进
**
:
`1`
*
**
步幅
**
:
`1`
*
**填充**
:
`same`
*
**激活**
:
`LeakyReLU`
,
`alpha`
等于 0.2:
...
...
@@ -560,8 +560,8 @@ dis1 = LeakyReLU(alpha=leakyrelu_alpha)(dis1)
配置:
*
**过滤器**
:
`64`
,
`128`
,
`128`
,
`256`
,
`256`
,
`512`
,
`512`
*
**核大小**
:
`3`
,
`3`
,
`3`
,
`3`
,
`3`
,
`3`
,
`3`
*
**
跨越
**
:
`2`
,
`1`
,
`2`
,
`1`
,
`2`
,
`1`
,
`2`
*
每个卷积层的
**
填充**
:
`same`
*
**
步幅
**
:
`2`
,
`1`
,
`2`
,
`1`
,
`2`
,
`1`
,
`2`
*
**每个卷积层的
填充**
:
`same`
*
**激活**
:
`LealyReLU`
,每个卷积层的
`alpha`
等于 0.2:
```
py
...
...
@@ -818,7 +818,7 @@ def build_adversarial_model(generator, discriminator, vgg):
return
model
```
我们现在已经成功地在 Keras 中实现了网络。 接下来,我们将在
*数据准备*
部分中下载的数据集上训练网络。
我们现在已经成功地在 Keras 中实现了网络。 接下来,我们将在
“数据准备”
部分中下载的数据集上训练网络。
...
...
new/gan-proj/6.md
浏览文件 @
f62e9a5b
...
...
@@ -38,8 +38,8 @@
StackGAN 是一个两阶段的网络。 每个阶段都有两个生成器和两个判别器。 StackGAN 由许多网络组成,这些网络如下:
*
**
Stack-I
GAN**
:文本编码器,条件增强网络,生成器网络,判别器网络,嵌入压缩器网络
*
**
Stack-II
GAN**
:文本编码器,条件增强网络,生成器网络,判别器网络,嵌入压缩器网络
*
**
阶段 1
GAN**
:文本编码器,条件增强网络,生成器网络,判别器网络,嵌入压缩器网络
*
**
阶段 2
GAN**
:文本编码器,条件增强网络,生成器网络,判别器网络,嵌入压缩器网络
![](
img/6f2f1522-849c-4ee4-9c08-57884ea1b6b1.png
)
...
...
@@ -544,7 +544,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
)
...
...
@@ -657,12 +657,12 @@ input_layer = Input(shape=(64, 64, 3))
```
2.
接下来,添加具有以下参数的二维卷积层:
*
**过滤器**
=
`64`
*
**核大小**
=
`(4, 4)`
*
**
大步前进**
=
`2`
*
**填充**
=
`'same'`
*
**使用偏差**
=
`False`
*
**
用`alpha=0.2`激活**
=
`LeakyReLU
`
*
**过滤器**
:
`64`
*
**核大小**
:
`(4, 4)`
*
**
步幅**
:
`2`
*
**填充**
:
`'same'`
*
**使用偏差**
:
`False`
*
**
激活**
:
`LeakyReLU`
,
`alpha=0.2
`
```
py
stage1_dis
=
Conv2D
(
64
,
(
4
,
4
),
...
...
@@ -672,12 +672,12 @@ stage1_dis = LeakyReLU(alpha=0.2)(stage1_dis)
```
3.
之后,添加两个卷积层,每个卷积层之后是一个批处理归一化层和一个
`LeakyReLU`
激活函数,具有以下参数:
*
**过滤器
:**
`128`
*
**核大小
:**
`(4, 4)`
*
**
大步前进**
=
`2`
*
**填充**
=
`'same'`
*
**使用偏差**
=
`False`
*
**
用`alpha=0.2`激活**
=
`LeakyReLU
`
*
**过滤器
**
:
`128`
*
**核大小
**
:
`(4, 4)`
*
**
步幅**
:
`2`
*
**填充**
:
`'same'`
*
**使用偏差**
:
`False`
*
**
激活**
:
`LeakyReLU`
,
`alpha=0.2
`
```
py
x
=
Conv2D
(
128
,
(
4
,
4
),
padding
=
'same'
,
strides
=
2
,
use_bias
=
False
)(
x
)
...
...
@@ -686,12 +686,12 @@ x = LeakyReLU(alpha=0.2)(x)
```
4.
接下来,再添加一个 2D 卷积层,然后添加批处理规范化层和
`LeakyReLU`
激活函数,并具有以下参数:
*
**过滤器
:**
`256`
*
**核大小
:**
`(4, 4)`
*
**
大步前进**
=
`2`
*
**填充**
=
`'same'`
*
**使用偏差**
=
`False`
*
**
用`alpha=0.2`激活**
=
`LeakyReLU
`
*
**过滤器
**
:
`256`
*
**核大小
**
:
`(4, 4)`
*
**
步幅**
:
`2`
*
**填充**
:
`'same'`
*
**使用偏差**
:
`False`
*
**
激活**
:
`LeakyReLU`
,
`alpha=0.2
`
```
py
x
=
Conv2D
(
256
,
(
4
,
4
),
padding
=
'same'
,
strides
=
2
,
use_bias
=
False
)(
x
)
...
...
@@ -700,12 +700,12 @@ x = LeakyReLU(alpha=0.2)(x)
```
5.
之后,再添加一个 2D 卷积层,然后添加批处理规范化层和 LeakyReLU 激活函数,并具有以下参数:
*
**过滤器
:**
`512`
*
**核大小
:**
`(4, 4)`
*
**
大步前进**
=
`2`
*
**填充**
=
`'same'`
*
**使用偏差**
=
`False`
*
**激活**
=
`LeakyReLU`
和
`alpha=0.2`
*
**过滤器
**
:
`512`
*
**核大小
**
:
`(4, 4)`
*
**
步幅**
:
`2`
*
**填充**
:
`'same'`
*
**使用偏差**
:
`False`
*
**激活**
:
`LeakyReLU`
和
`alpha=0.2`
```
py
x
=
Conv2D
(
512
,
(
4
,
4
),
padding
=
'same'
,
strides
=
2
,
use_bias
=
False
)(
x
)
...
...
@@ -726,12 +726,12 @@ merged_input = concatenate([x, input_layer2])
```
8.
之后,添加另一个 2D 卷积层,然后添加批处理归一化层,并使用以下参数将
`LeakyReLU`
作为激活函数:
*
**过滤器**
=
`512`
*
**核大小**
=
`1`
*
**
大步前进**
=
`1`
*
**填充**
=
`'same'`
*
**批量标准化**
=
是
*
**
用`alpha 0.2`激活**
=
`LeakyReLU
`
*
**过滤器**
:
`512`
*
**核大小**
:
`1`
*
**
步幅**
:
`1`
*
**填充**
:
`'same'`
*
**批量标准化**
:
是
*
**
激活**
:
`LeakyReLU`
,
`alpha 0.2
`
```
py
x2
=
Conv2D
(
64
*
8
,
kernel_size
=
1
,
...
...
@@ -884,11 +884,11 @@ def build_adversarial_model(gen_model, dis_model):
在本节中,我们将为降采样模块编写实现。
1.
首先创建第一个下采样块。 该块包含一个以
`ReLU`
作为激活函数的 2D 卷积层。 在应用 2D 卷积之前,请在各侧用零填充输入。 该块中不同层的配置如下:
*
**填充大小
:**
`(1, 1)`
*
**过滤器
:**
`128`
*
**核大小
:**
`(3, 3)`
*
**
大步走:**
``1``
*
**激活
:**
`ReLU`
*
**填充大小
**
:
`(1, 1)`
*
**过滤器
**
:
`128`
*
**核大小
**
:
`(3, 3)`
*
**
步幅**
:
``1``
*
**激活
**
:
`ReLU`
```
py
x
=
ZeroPadding2D
(
padding
=
(
1
,
1
))(
input_lr_images
)
...
...
@@ -897,12 +897,12 @@ x = ReLU()(x)
```
2.
接下来,添加具有以下配置的第二个卷积块:
*
**填充大小
:**
`(1, 1)`
*
**过滤器
:**
`256`
*
**核大小
:**
`(4, 4)`
*
**
大步走过:**
`2`
*
**批量标准化
:**
是
*
**激活
:**
`ReLU`
*
**填充大小
**
:
`(1, 1)`
*
**过滤器
**
:
`256`
*
**核大小
**
:
`(4, 4)`
*
**
步幅**
:
`2`
*
**批量标准化
**
:
是
*
**激活
**
:
`ReLU`
```
py
x
=
ZeroPadding2D
(
padding
=
(
1
,
1
))(
x
)
...
...
@@ -912,12 +912,12 @@ x = ReLU()(x)
```
3.
之后,添加另一个具有以下配置的卷积块:
*
**填充大小
:**
`(1, 1)`
*
**过滤器
:**
`512`
*
**核大小
:**
`(4, 4)`
*
**
大步走过:**
`2`
*
**批量标准化
:**
是
*
**激活
:**
`ReLU`
*
**填充大小
**
:
`(1, 1)`
*
**过滤器
**
:
`512`
*
**核大小
**
:
`(4, 4)`
*
**
步幅**
:
`2`
*
**批量标准化
**
:
是
*
**激活
**
:
`ReLU`
```
py
x
=
ZeroPadding2D
(
padding
=
(
1
,
1
))(
x
)
...
...
@@ -976,12 +976,12 @@ def residual_block(input):
初始输入被添加到第二个 2D 卷积层的输出中。 结果张量将是块的输出。
2.
接下来,添加具有以下超参数的 2D 卷积块:
*
**填充大小
:**
`(1, 1)`
*
**过滤器
:**
`512`
*
**核大小
:**
`(3, 3)`
*
**
大步走过:**
`1`
*
**批量
归一化:**
`Yes`
*
**激活
:**
`ReLU`
*
**填充大小
**
:
`(1, 1)`
*
**过滤器
**
:
`512`
*
**核大小
**
:
`(3, 3)`
*
**
步幅**
:
`1`
*
**批量
标准化**
:
`Yes`
*
**激活
**
:
`ReLU`
```
py
x
=
ZeroPadding2D
(
padding
=
(
1
,
1
))(
c_code
)
...
...
@@ -999,7 +999,7 @@ x = residual_block(x)
x
=
residual_block
(
x
)
```
上采样块将从残差块接收该输出张量。 让我们为
升
采样块编写代码。
上采样块将从残差块接收该输出张量。 让我们为
上
采样块编写代码。
...
...
@@ -1011,16 +1011,16 @@ x = residual_block(x)
上采样块包含可提高图像空间分辨率并生成尺寸
`256x256x3`
的高分辨率图像的层。
让我们为
升
采样块编写代码:
让我们为
上
采样块编写代码:
1.
首先,添加一个包含 2D 上采样层,2D 卷积层,批归一化和激活函数的上采样块。 块中使用的不同参数如下:
*
**上采样大小
:**
`(2, 2)`
*
**过滤器
:**
`512`
*
**核大小
:**
`3`
*
**填充
:**
`"same"`
*
**
大步走:**
`1`
*
**批量标准化
:**
`Yes`
*
**激活
:**
`ReLU`
*
**上采样大小
**
:
`(2, 2)`
*
**过滤器
**
:
`512`
*
**核大小
**
:
`3`
*
**填充
**
:
`"same"`
*
**
步幅**
:
`1`
*
**批量标准化
**
:
`Yes`
*
**激活
**
:
`ReLU`
```
py
x
=
UpSampling2D
(
size
=
(
2
,
2
))(
x
)
...
...
new/gan-proj/7.md
浏览文件 @
f62e9a5b
...
...
@@ -96,14 +96,14 @@ CycleGAN 总体上由两种架构组成:生成器和判别器。 生成器架
|
**层名称**
|
**超参数**
|
**输入形状**
|
**输出形状**
|
| --- | --- | --- | --- |
| 2D 卷积层 |
`filters=128, kernel_size=3, strides=1, padding='same'`
|
`(32, 32, 128)`
|
`(32, 32, 128)`
|
| 批量
归一
化层 |
`axis=3, momentum=0.9, epsilon=1e-5`
|
`(32, 32, 128)`
|
`(32, 32, 128)`
|
| 批量
标准
化层 |
`axis=3, momentum=0.9, epsilon=1e-5`
|
`(32, 32, 128)`
|
`(32, 32, 128)`
|
| 2D 卷积层 |
`filters=138, kernel_size=3, strides=1, padding='same'`
|
`(32, 32, 128)`
| (
`(32, 32, 128)`
|
| 批量
归一
化层 |
`axis=3, momentum=0.9, epsilon=1e-5`
|
`(32, 32, 128)`
|
`(32, 32, 128)`
|
| 批量
标准
化层 |
`axis=3, momentum=0.9, epsilon=1e-5`
|
`(32, 32, 128)`
|
`(32, 32, 128)`
|
| 加法层 |
`None`
|
`(32, 32, 128)`
|
`(32, 32, 128)`
|
加法层计算输入到块的 张量 与最后一批归一化层的输出之和。
*
**上采样块**
:上采样块包含 2D 转置卷积层,并使用
`relu`
作为激活函数。 生成器网络中有两个上采样模块。 第一个
升
采样模块的配置如下:
*
**上采样块**
:上采样块包含 2D 转置卷积层,并使用
`relu`
作为激活函数。 生成器网络中有两个上采样模块。 第一个
上
采样模块的配置如下:
|
**层名称**
|
**超参数**
|
**输入形状**
|
**输出形状**
|
| --- | --- | --- | --- |
...
...
@@ -356,7 +356,7 @@ residual_blocks = 6
input_layer
=
Input
(
shape
=
input_shape
)
```
3.
将第一个卷积块与先前在
*生成器网络*
部分的架构中指定的超参数相加,如下所示:
3.
将第一个卷积块与先前在
“生成器网络”
部分的架构中指定的超参数相加,如下所示:
```
py
x
=
Conv2D
(
filters
=
32
,
kernel_size
=
7
,
strides
=
1
,
padding
=
"same"
)(
input_layer
)
...
...
@@ -402,7 +402,7 @@ for _ in range(residual_blocks):
x
=
residual_block
(
x
)
```
7.
接下来,添加一个
升
采样块,如下所示:
7.
接下来,添加一个
上
采样块,如下所示:
```
py
x
=
Conv2DTranspose
(
filters
=
64
,
kernel_size
=
3
,
strides
=
2
,
padding
=
'same'
,
use_bias
=
False
)(
x
)
...
...
@@ -410,7 +410,7 @@ x = InstanceNormalization(axis=1)(x)
x
=
Activation
(
"relu"
)(
x
)
```
8.
添加另一个
升
采样模块,如下所示:
8.
添加另一个
上
采样模块,如下所示:
```
py
x
=
Conv2DTranspose
(
filters
=
32
,
kernel_size
=
3
,
strides
=
2
,
padding
=
'same'
,
use_bias
=
False
)(
x
)
...
...
@@ -515,7 +515,7 @@ x = ZeroPadding2D(padding=(1, 1))(input_layer)
该层将在
`x`
和
`y`
轴上为输入张量添加填充。
4.
接下来,使用先前在
*判别器网络*
部分的架构中指定的超参数添加卷积块,如下所示:
4.
接下来,使用先前在
“判别器网络”
部分的架构中指定的超参数添加卷积块,如下所示:
```
py
x
=
Conv2D
(
filters
=
64
,
kernel_size
=
4
,
strides
=
2
,
padding
=
"valid"
)(
x
)
...
...
@@ -528,7 +528,7 @@ x = LeakyReLU(alpha=0.2)(x)
x
=
ZeroPadding2D
(
padding
=
(
1
,
1
))(
x
)
```
6.
接下来,使用先前在
*判别器网络*
部分中指定的超参数添加三个卷积块,如下所示:
6.
接下来,使用先前在
“判别器网络”
部分中指定的超参数添加三个卷积块,如下所示:
```
py
for
i
in
range
(
1
,
hidden_layers
+
1
):
...
...
@@ -854,7 +854,7 @@ fake_labels = np.zeros((batch_size, 7, 7, 1))
imagesA
,
imagesB
=
load_images
(
data_dir
=
data_dir
)
```
我们已经在
*中定义了`load_images`功能。*
我们已经在
定义了
`load_images`
函数。
2.
接下来,创建一个
`for`
循环,该循环应运行由时期数指定的次数,如下所示:
...
...
new/gan-proj/8.md
浏览文件 @
f62e9a5b
...
...
@@ -66,25 +66,25 @@ Pix2pix 是条件 GAN 的变体。 我们已经在第 3 章,“使用条件 GA
| 第一个 2D 卷积层 |
`filter= 64, kernel_size = 4, stride= 2, padding ='same'`
|
`(256, 256, 1)`
|
`(128, 128, 64)`
|
| 激活层 |
`Activation ='leakyrelu', alpha = 0.2`
|
`(128, 128, 64)`
|
`(128, 128, 64)`
|
| 第二个 2D 卷积层 |
`filter= 128, kernel_size = 4, stride= 2, padding ="same"`
|
`(128, 128, 64)`
|
`(64, 64, 128)`
|
| 批量
归一
化层 | 没有 |
`(64, 64, 128)`
|
`(64, 64, 128)`
|
| 批量
标准
化层 | 没有 |
`(64, 64, 128)`
|
`(64, 64, 128)`
|
| 激活层 |
`Activation ='leakyrelu', alpha = 0.2`
|
`(64, 64, 128)`
|
`(64, 64, 128)`
|
| 第三个 2D 卷积层 |
`filter= 256, kernel_size = 4, stride= 2, padding ='same'`
|
`(64, 64, 128)`
|
`(32, 32, 256)`
|
| 批量
归一
化层 | 没有 |
`(32, 32, 256)`
|
`(32, 32, 256)`
|
| 批量
标准
化层 | 没有 |
`(32, 32, 256)`
|
`(32, 32, 256)`
|
| 激活层 |
`Activation ='leakyrelu', alpha = 0.2`
|
`(32, 32, 256)`
|
`(32, 32, 256)`
|
| 第四个 2D 卷积层 |
`filter= 512, kernel_size = 4, stride= 2, padding ="same"`
|
`(32, 32, 256)`
|
`(16, 16, 512)`
|
| 批量
归一
化层 | 没有 |
`(16, 16, 512)`
|
`(16, 16, 512)`
|
| 批量
标准
化层 | 没有 |
`(16, 16, 512)`
|
`(16, 16, 512)`
|
| 激活层 |
`Activation ='leakyrelu', alpha = 0.2`
|
`(16, 16, 512)`
|
`(16, 16, 512)`
|
| 第五个 2D 卷积层 |
`filter= 512, kernel_size = 4, stride= 2, padding ="same"`
|
`(16, 16, 512)`
|
`(8, 8, 512)`
|
| 批量
归一
化层 | 没有 |
`(8, 8, 512)`
|
`(8, 8, 512)`
|
| 批量
标准
化层 | 没有 |
`(8, 8, 512)`
|
`(8, 8, 512)`
|
| 激活层 |
`Activation ='leakyrelu', alpha = 0.2`
|
`(8, 8, 512)`
|
`(8, 8, 512)`
|
| 第六个 2D 卷积层 |
`filter= 512, kernel_size = 4, stride= 2, padding ="same"`
|
`(8, 8, 512)`
|
`(4, 4, 512)`
|
| 批量
归一
化层 | 没有 |
`(4, 4, 512)`
|
`(4, 4, 512)`
|
| 批量
标准
化层 | 没有 |
`(4, 4, 512)`
|
`(4, 4, 512)`
|
| 激活层 |
`Activation ='leakyrelu', alpha = 0.2`
|
`(4, 4, 512)`
|
`(4, 4, 512)`
|
| 第七个 2D 卷积层 |
`filter= 512, kernel_size = 4, stride= 2, padding ="same"`
|
`(4, 4, 512)`
|
`(2, 2, 512)`
|
| 批量
归一
化层 | 没有 |
`(2, 2, 512)`
|
`(2, 2, 512)`
|
| 批量
标准
化层 | 没有 |
`(2, 2, 512)`
|
`(2, 2, 512)`
|
| 激活层 |
`Activation ='leakyrelu', alpha = 0.2`
|
`(2, 2, 512)`
|
`(2, 2, 512)`
|
| 第八个 2D 卷积层 |
`filter= 512, kernel_size = 4, stride= 2, padding ="same"`
|
`(2, 2, 512)`
|
`(1, 1, 512)`
|
| 批量
归一
化层 | 没有 |
`(1, 1, 512)`
|
`(1, 1, 512)`
|
| 批量
标准
化层 | 没有 |
`(1, 1, 512)`
|
`(1, 1, 512)`
|
| 激活层 |
`Activation ='leakyrelu', alpha = 0.2`
|
`(1, 1, 512)`
|
`(1, 1, 512)`
|
编码器网络之后是解码器网络。 我们将在下一节中了解解码器网络的架构。
...
...
@@ -103,40 +103,40 @@ Pix2pix 是条件 GAN 的变体。 我们已经在第 3 章,“使用条件 GA
| --- | --- | --- | --- |
| 第一个 2D 上采样层 |
`size=(2, 2)`
|
`(1, 1, 512)`
|
`(2, 2, 512)`
|
| 2D 卷积层 |
`filter= 512, kernel_size = 4, stride= 1, padding="same"`
|
`(2, 2, 512)`
|
`(2, 2, 512)`
|
| 批量
归一
化层 | 没有 |
`(2, 2, 512)`
|
`(2, 2, 512)`
|
| 批量
标准
化层 | 没有 |
`(2, 2, 512)`
|
`(2, 2, 512)`
|
| 丢弃层 | 丢弃= 0.5 |
`(2, 2, 512)`
|
`(2, 2, 512)`
|
| 级联层(编码器网络中的第 7 个卷积层) |
`axis=3`
|
`(2, 2, 512)`
|
`(2, 2, 1024)`
|
| 激活层 |
`activation="relu"`
|
`(2, 2, 1024)`
|
`(2, 2, 1024)`
|
| 第二个 2D 上采样层 |
`size=(2, 2)`
|
`(2, 2, 1024)`
|
`(4, 4, 1024)`
|
| 2D 卷积层 |
`filter= 1024, kernel_size = 4, stride= 1, padding="same"`
|
`(4, 4, 1024)`
|
`(4, 4, 1024)`
|
| 批量
归一
化层 | 没有 |
`(4, 4, 1024)`
|
`(4, 4, 1024)`
|
| 批量
标准
化层 | 没有 |
`(4, 4, 1024)`
|
`(4, 4, 1024)`
|
| 丢弃层 | 丢弃= 0.5 |
`(4, 4, 1024)`
|
`(4, 4, 1024)`
|
| 级联层(编码器网络中的第 6 个卷积层) |
`axis=3`
|
`(4, 4, 1024)`
|
`(4, 4, 1536)`
|
| 激活层 |
`activation="relu"`
|
`(4, 4, 1536)`
|
`(4, 4, 1536)`
|
| 第三个 2D 上采样层 |
`size=(2, 2)`
|
`(4, 4, 1536)`
|
`(8, 8, 1536)`
|
| 2D 卷积层 |
`filter= 1024, kernel_size = 4, stride= 1, padding="same"`
|
`(8, 8, 1536)`
|
`(8, 8, 1024)`
|
| 批量
归一
化层 | 没有 |
`(8, 8, 1024)`
|
`(8, 8, 1024)`
|
| 批量
标准
化层 | 没有 |
`(8, 8, 1024)`
|
`(8, 8, 1024)`
|
| 丢弃层 | 丢弃= 0.5 |
`(8, 8, 1024)`
|
`(8, 8, 1024)`
|
| 级联层(编码器网络中的第 5 个卷积层) |
`axis=3`
|
`(8, 8, 1024)`
|
`(8, 8, 1536)`
|
| 激活层 |
`activation="relu"`
|
`(8, 8, 1536)`
|
`(8, 8, 1536)`
|
| 第四个 2D 上采样层 |
`size=(2, 2)`
|
`(8, 8, 1536)`
|
`(16, 16, 1536)`
|
| 2D 卷积层 |
`filter= 1024, kernel_size = 4, stride= 1, padding="same"`
|
`(16, 16, 1536)`
|
`(16, 16, 1024)`
|
| 批量
归一
化层 | 没有 |
`(16, 16, 1024)`
|
`(16, 16, 1024)`
|
| 批量
标准
化层 | 没有 |
`(16, 16, 1024)`
|
`(16, 16, 1024)`
|
| 连接层(编码器网络的第 4 个卷积层) |
`axis=3`
|
`(16, 16, 1024)`
|
`(16, 16, 1536)`
|
| 激活层 |
`activation="relu"`
|
`(16, 16, 1536)`
|
`(16, 16, 1536)`
|
| 第五个 2D 上采样层 |
`size=(2, 2)`
|
`(16, 16, 1536)`
|
`(32, 32, 1536)`
|
| 2D 卷积层 |
`filter= 1024, kernel_size = 4, stride= 1, padding="same"`
|
`(32, 32, 1536)`
|
`(32, 32, 1024)`
|
| 批量
归一
化层 | 没有 |
`(32, 32, 1024)`
|
`(32, 32, 1024)`
|
| 批量
标准
化层 | 没有 |
`(32, 32, 1024)`
|
`(32, 32, 1024)`
|
| 连接层(编码器网络的第 3 个卷积层) |
`axis=3`
|
`(32, 32, 1024)`
|
`(32, 32, 1280)`
|
| 激活层 |
`activation="relu"`
|
`(32, 32, 1280)`
|
`(32, 32, 1280)`
|
| 第六个 2D 上采样层 |
`size=(2, 2)`
|
`(64, 64, 1280)`
|
`(64, 64, 1280)`
|
| 2D 卷积层 |
`filter= 512, kernel_size = 4, stride= 1, padding="same"`
|
`(64, 64, 1280)`
|
`(64, 64, 512)`
|
| 批量
归一
化层 | 没有 |
`(64, 64, 512)`
|
`(64, 64, 512)`
|
| 批量
标准
化层 | 没有 |
`(64, 64, 512)`
|
`(64, 64, 512)`
|
| 连接层(编码器网络中的第二个卷积层) |
`axis=3`
|
`(64, 64, 512)`
|
`(64, 64, 640)`
|
| 激活层 |
`activation="relu"`
|
`(64, 64, 640)`
|
`(64, 64, 640)`
|
| 第七个 2D 上采样层 |
`size=(2, 2)`
|
`(64, 64, 640)`
|
`(128, 128, 640)`
|
| 2D 卷积层 |
`filter= 256, kernel_size = 4, stride= 1, padding="same"`
|
`(128, 128, 640)`
|
`(128, 128, 256)`
|
| 批量
归一
化层 | 没有 |
`(128, 128, 256)`
|
`(128, 128, 256)`
|
| 批量
标准
化层 | 没有 |
`(128, 128, 256)`
|
`(128, 128, 256)`
|
| 连接层(编码器网络中的第一个卷积层) |
`axis=3`
|
`(128, 128, 256)`
|
`(128, 128, 320)`
|
| 激活层 |
`activation="relu"`
|
`(128, 128, 320)`
|
`(128, 128, 320)`
|
| 第八个 2D 上采样层 |
`size=(2, 2)`
|
`(128, 128, 320)`
|
`(256, 256, 320)`
|
...
...
@@ -171,25 +171,25 @@ pix2pix 中判别器网络的架构受到 PatchGAN 网络架构的启发。 Patc
| 第一个 2D 卷积层 |
`filter= 64, kernel_size = 4, stride= 2, padding ='same'`
|
`(256, 256, 1)`
|
`(256, 256, 64)`
|
| 激活层 |
`Activation ='leakyrelu', alpha = 0.2`
|
`(128, 128, 64)`
|
`(128, 128, 64)`
|
| 第二个 2D 卷积层 |
`filter= 128, kernel_size = 4, stride= 2, padding ="same"`
|
`(128, 128, 64)`
|
`(64, 64, 128)`
|
| 批量
归一
化层 | 没有 |
`(64, 64, 128)`
|
`(64, 64, 128)`
|
| 批量
标准
化层 | 没有 |
`(64, 64, 128)`
|
`(64, 64, 128)`
|
| 激活层 |
`Activation ='leakyrelu', alpha = 0.2`
|
`(64, 64, 128)`
[
| `(64, 64, 128)` |
| 第三个 2D 卷积层 | `filter= 256, kernel_size = 4, stride= 2, padding ='same'` | `(64, 64, 128)` | `(32, 32, 256)` |
| 批量
归一
化层 | 没有 | `(32, 32, 256)` | `(32, 32, 256)` |
| 批量
标准
化层 | 没有 | `(32, 32, 256)` | `(32, 32, 256)` |
| 激活层 | `Activation ='leakyrelu', alpha = 0.2` | `(32, 32, 256)` | `(32, 32, 256)` |
| 第四个 2D 卷积层 | `filter= 512, kernel_size = 4, stride= 2, padding ="same"` | `(32, 32, 256)` | `(16, 16, 512)` |
| 批量
归一
化层 | 没有 | `(16, 16, 512)` | `(16, 16, 512)` |
| 批量
标准
化层 | 没有 | `(16, 16, 512)` | `(16, 16, 512)` |
| 激活层 | `Activation ='leakyrelu', alpha = 0.2` | `(16, 16, 512)` | `(16, 16, 512)` |
| 第五个 2D 卷积层 | `filter= 512, kernel_size = 4, stride= 2, padding ="same"` | `(16, 16, 512)` | `(8, 8, 512)` |
| 批量
归一
化层 | 没有 | `(8, 8, 512)` | `(8, 8, 512)` |
| 批量
标准
化层 | 没有 | `(8, 8, 512)` | `(8, 8, 512)` |
| 激活层 | `Activation ='leakyrelu', alpha = 0.2` | `(8, 8, 512)` | `(8, 8, 512)` |
| 第六个 2D 卷积层 | `filter= 512, kernel_size = 4, stride= 2, padding ="same"` | `(8, 8, 512)` | `(4, 4, 512)` |
| 批量
归一
化层 | 没有 | `(4, 4, 512)` | `(4, 4, 512)` |
| 批量
标准
化层 | 没有 | `(4, 4, 512)` | `(4, 4, 512)` |
| 激活层 |` Activation ='leakyrelu', alpha = 0.2` | `(4, 4, 512)` | `(4, 4, 512)` |
| 第七个 2D 卷积层 | `filter= 512, kernel_size = 4, stride= 2, padding ="same"` | `(4, 4, 512)` | `(2, 2, 512)` |
| 批量
归一
化层 | 没有 | `(2, 2, 512)` | `(2, 2, 512)` |
| 批量
标准
化层 | 没有 | `(2, 2, 512)` | `(2, 2, 512)` |
| 激活层 | `Activation ='leakyrelu', alpha = 0.2` | `(2, 2, 512)` | `(2, 2, 512)` |
| 第八个 2D 卷积层 | `filter= 512, kernel_size = 4, stride= 2, padding ="same"` | `(4, 4, 512)` | `(1, 1, 512)` |
| 批量
归一
化层 | 没有 | `(1, 1, 512)` | `(1, 1, 512)` |
| 批量
标准
化层 | 没有 | `(1, 1, 512)` | `(1, 1, 512)` |
| 激活层 | `Activation ='leakyrelu', alpha = 0.2 `| `(1, 1, 512)` | `(1, 1, 512)` |
| 展开层 | 没有 | `(1, 1, 512)` | `(512, )` |
| 密集层 | `unit= 2, activation='softmax'` | `(1, 1, 512)` | `(2, )` |
...
...
@@ -1210,13 +1210,13 @@ print("Batch:{}".format(index))
val_images_batch
=
validation_facade_photos
[
index
*
batch_size
:(
index
+
1
)
*
batch_size
]
```
12.
接下来,生成一批假图像并从中提取补丁。 如下使用
`generate_and_extract_patches`
功能
:
12.
接下来,生成一批假图像并从中提取补丁。 如下使用
`generate_and_extract_patches`
函数
:
```
py
patches
,
labels
=
generate_and_extract_patches
(
train_images_batch
,
train_facades_batch
,
unet_generator
,
batch_counter
,
patch_dim
)
```
`generate_and_extract_patches`
功能
定义如下:
`generate_and_extract_patches`
函数
定义如下:
```
py
def
generate_and_extract_patches
(
images
,
facades
,
generator_model
,
batch_counter
,
patch_dim
):
...
...
new/gan-proj/9.md
浏览文件 @
f62e9a5b
...
...
@@ -164,7 +164,7 @@ GAN 已被证明对图像生成任务很有用。 GAN 中的大部分研究目
*
[
**AdaGAN**:AdaGAN:增强生成模型
](
https://arxiv.org/abs/1701.02386v1
)
*
[
**ArtGAN**:ArtGAN:带有条件分类 GAN 的艺术品合成
](
https://arxiv.org/abs/1702.03410
)
*
[
**BAGAN**:BAGAN:平衡 GAN 的数据
增强
](
https://arxiv.org/abs/1803.09655
)
*
[
**BAGAN**:BAGAN:平衡 GAN 的数据
扩充
](
https://arxiv.org/abs/1803.09655
)
*
[
**BicycleGAN**:从多模态图像迈向图像翻译
](
https://arxiv.org/abs/1711.11586
)
*
[
**CapsGAN**:CapsGAN:为生成对抗网络使用动态路由
](
https://arxiv.org/abs/1806.03968
)
*
[
**E-GAN**:进化生成对抗网络
](
https://arxiv.org/abs/1803.00657
)
...
...
new/handson-unsup-learn-py/08.md
浏览文件 @
f62e9a5b
...
...
@@ -125,7 +125,7 @@ graph = tf.Graph()
*
2D 转置卷积,具有 128(3×3)个过滤器,(2×2)步幅,ReLU 激活和相同的填充
*
具有 64 个(3×3)滤波器,(1×1)跨距,ReLU 激活和相同填充的 2D 转置卷积
*
具有 32 个(3×3)滤波器,(1×1)跨距,ReLU 激活和相同填充的 2D 转置卷积
*
2D 转置卷积,带有 1(3×3)过滤器,(1×1)
跨步
,Sigmoid 激活,以及相同的填充
*
2D 转置卷积,带有 1(3×3)过滤器,(1×1)
步幅
,Sigmoid 激活,以及相同的填充
损失函数基于重构图像和原始图像之间差异的
`L[2]`
范数。 优化器是 Adam,学习率为
*η= 0.001*
。 TensorFlow DAG 的编码器部分如下:
...
...
@@ -417,7 +417,7 @@ for e in range(nb_epochs):
在此示例中,我们想通过使用
`L[1]`
罚分来提高代码的稀疏性。 DAG 和训练过程与主要示例完全相同,唯一的区别是
`loss`
功能
,现在变为:
在此示例中,我们想通过使用
`L[1]`
罚分来提高代码的稀疏性。 DAG 和训练过程与主要示例完全相同,唯一的区别是
`loss`
函数
,现在变为:
```
py
...
...
...
@@ -504,7 +504,7 @@ ELBO 右侧的第二项是 *log p(x | z;* *θ)*的期望值。 不难看出
*
2D 转置卷积,具有 128(3×3)个过滤器,(2×2)步幅,ReLU 激活和相同的填充
*
2D 转置卷积,具有 128(3×3)个过滤器,(2×2)步幅,ReLU 激活和相同的填充
*
具有 32 个(3×3)滤波器,(1×1)跨距,ReLU 激活和相同填充的 2D 转置卷积
*
2D 转置卷积,带有 1(3×3)过滤器,(1×1)
跨步
,Sigmoid 激活,以及相同的填充
*
2D 转置卷积,带有 1(3×3)过滤器,(1×1)
步幅
,Sigmoid 激活,以及相同的填充
TensorFlow 完全控制了噪声的产生,并且基于理论部分中说明的技巧。 以下代码段显示了 DAG 的第一部分,其中包含图形定义和编码器:
...
...
new/handson-unsup-learn-py/09.md
浏览文件 @
f62e9a5b
...
...
@@ -192,7 +192,7 @@ nb_iterations = int(nb_samples / batch_size)
现在,我们可以基于以下结构为生成器定义 DAG:
*
具有 1,024(4×4)过滤器的 2D 卷积,步幅为[
*1,1*
),有效填充和线性输出
*
批量
归一
化和 LReLU 激活(当输入值为负时,性能更高;实际上,当
*x < 0*
时,标准 ReLU 的梯度为零,而 LReLU 的常数较小) 允许稍微修改的渐变)
*
批量
标准
化和 LReLU 激活(当输入值为负时,性能更高;实际上,当
*x < 0*
时,标准 ReLU 的梯度为零,而 LReLU 的常数较小) 允许稍微修改的渐变)
*
带有(
*2、2*
)步幅,相同填充和线性输出的 512(4×4)滤波器的 2D 卷积
*
批量标准化和泄漏的 ReLU 激活
*
256 个(4×4)滤波器的 2D 卷积,步幅为[
*2,2*
),,相同 填充,以及线性输出
...
...
@@ -342,7 +342,7 @@ with graph.as_default():
training_step_g
=
tf
.
train
.
AdamOptimizer
(
0.0005
,
beta1
=
0.5
).
minimize
(
loss
=
loss_g
,
var_list
=
variables_g
)
```
第一块包含占位符的声明。 为了清楚起见,虽然
`input_x`
和
`input_z`
的目的很容易理解,但
`is_training`
可能不太明显。 此布尔值标志的目的是允许在生产阶段禁用批量
归一
化(必须仅在训练阶段有效)。 下一步包括声明生成器和两个判别器(它们在形式上是相同的,因为变量是共享的,但是其中一个被提供了真实的样本,而另一个必须评估生成器的输出)。 然后,是时候定义损失函数了,它是基于一种可以加快计算速度并增加数值稳定性的技巧。
第一块包含占位符的声明。 为了清楚起见,虽然
`input_x`
和
`input_z`
的目的很容易理解,但
`is_training`
可能不太明显。 此布尔值标志的目的是允许在生产阶段禁用批量
标准
化(必须仅在训练阶段有效)。 下一步包括声明生成器和两个判别器(它们在形式上是相同的,因为变量是共享的,但是其中一个被提供了真实的样本,而另一个必须评估生成器的输出)。 然后,是时候定义损失函数了,它是基于一种可以加快计算速度并增加数值稳定性的技巧。
函数
`tf.nn.sigmoid_cross_entropy_with_logits()`
接受
*logit*
(这就是为什么我们没有将 Sigmoid 变换直接应用于判别器输出的原因),并允许我们执行以下向量计算:
...
...
new/intel-mobi-proj-tf/03.md
浏览文件 @
f62e9a5b
...
...
@@ -570,7 +570,7 @@ void RunInferenceOnImage(NSString *model)
图 3.8:使用不同的模型运行应用程序并显示检测结果
返回步骤 7 中的功能,
`FilePathForResourceName`
功能
是用于返回资源文件路径的帮助程序功能:
`mscoco_label_map.pbtxt`
文件,该文件定义了要检测的 90 个对象类的 ID,内部名称和显示名称。 ,模型图文件和测试图像。 它的实现与我们在上一章的
`HelloTensorFlow`
应用中看到的实现相同。
返回步骤 7 中的功能,
`FilePathForResourceName`
函数
是用于返回资源文件路径的帮助程序功能:
`mscoco_label_map.pbtxt`
文件,该文件定义了要检测的 90 个对象类的 ID,内部名称和显示名称。 ,模型图文件和测试图像。 它的实现与我们在上一章的
`HelloTensorFlow`
应用中看到的实现相同。
`LoadLablesFile`
和
`GetDisplayName`
函数使用 Google Protobuf API 加载和解析
`mscoco_label_map.pbtxt`
文件,并返回显示名称以显示检测到的对象的 ID。
...
...
new/intel-mobi-proj-tf/06.md
浏览文件 @
f62e9a5b
...
...
@@ -239,7 +239,7 @@ def _restore_fn(sess):
saver
.
restore
(
sess
,
checkpoint_path
)
```
在启动
`run_inference.py`
之后到达
`saver.restore`
调用时,已进行了更新的图形定义,因此我们可以在此处保存新的检查点和图形文件,从而使
`_restore_fn`
功能
如下:
在启动
`run_inference.py`
之后到达
`saver.restore`
调用时,已进行了更新的图形定义,因此我们可以在此处保存新的检查点和图形文件,从而使
`_restore_fn`
函数
如下:
```
py
def
_restore_fn
(
sess
):
...
...
@@ -350,7 +350,7 @@ x[:6]
u
'convert_image'
]
```
解决您的 iOS 应用错误的第二种可能解决方案是,像在 中所做的那样,在
`tf_op_files`
文件中添加未注册的操作实现,并重建 TensorFlow iOS 库。 就像第 5 章, “了解简单语音命令”一样。 坏消息是,由于 TensorFlow 中没有
`DecodeJpeg`
功能
的实现,因此无法将
`DecodeJpeg`
的 TensorFlow 实现添加到
`tf_op_files`
中。
解决您的 iOS 应用错误的第二种可能解决方案是,像在 中所做的那样,在
`tf_op_files`
文件中添加未注册的操作实现,并重建 TensorFlow iOS 库。 就像第 5 章, “了解简单语音命令”一样。 坏消息是,由于 TensorFlow 中没有
`DecodeJpeg`
函数
的实现,因此无法将
`DecodeJpeg`
的 TensorFlow 实现添加到
`tf_op_files`
中。
实际上,在图 6.2 中也暗示了对此烦恼的解决方法,其中
`convert_image`
节点用作
`image_feed`
输入的解码版本。 为了更准确,单击 TensorBoard 图中的转换和
**解码**
节点,如图 6.4 所示,您将从右侧的 TensorBoard 信息卡中看到输入转换(名为
`convert_image/Cast`
)的输出为
`decode/DecodeJpeg`
和
`convert_image`
,解码的输入和输出为
`image_feed`
和
`convert_image/Cast`
:
...
...
@@ -555,7 +555,7 @@ while(t){
t
.
close
();
```
6.
剩下的我们要做的就是实现
`generateCaption`
功能
。 在其中,首先加载正确的模型:
6.
剩下的我们要做的就是实现
`generateCaption`
函数
。 在其中,首先加载正确的模型:
```
py
tensorflow
::
Status
load_status
;
...
...
new/intel-mobi-proj-tf/07.md
浏览文件 @
f62e9a5b
...
...
@@ -164,7 +164,7 @@ def predict_input_fn():
print
(
next
(
predictions
)[
'argmax'
])
```
4.
在
`model_fn`
功能
中,在
`logits = _add_fc_layers(final_state)`
之后,添加以下代码:
4.
在
`model_fn`
函数
中,在
`logits = _add_fc_layers(final_state)`
之后,添加以下代码:
```
py
argmax
=
tf
.
argmax
(
logits
,
axis
=
1
)
...
...
new/intel-mobi-proj-tf/10.md
浏览文件 @
f62e9a5b
...
...
@@ -581,7 +581,7 @@ bool getProbs(int *binary, float *probs) {
}
```
`getAllowedActions`
功能
定义如下:
`getAllowedActions`
函数
定义如下:
```
py
void
getAllowedActions
(
int
bd
[],
vector
<
int
>
&
actions
)
{
...
...
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录