提交 b1322cb3 编写于 作者: W wizardforcel

2021-01-15 21:59:14

上级 dc52161a
......@@ -18,7 +18,7 @@
“第 1 章”,“深度学习和 PyTorch 简介”,介绍了深度学习及其应用以及 PyTorch 的主要语法。 本章还显示了如何定义网络体系结构和训练模型。
“第 2 章”,“神经网络的构建基块”,引入了神经网络的概念,并解释了当今的三种主要网络架构:人工神经网络,卷积神经网络和递归神经网络。 对于每种体系结构,都提供了培训过程和各层的说明。
“第 2 章”,“神经网络的构建基块”,引入了神经网络的概念,并解释了当今的三种主要网络架构:人工神经网络,卷积神经网络和循环神经网络。 对于每种体系结构,都提供了培训过程和各层的说明。
“第 3 章”,“使用 DNN 的分类问题”,引入了要使用人工神经网络解决的现实数据问题。 探索了数据集的预处理以及定义和训练模型的过程,并通过使用误差分析提高了模型的准确性。
......@@ -26,7 +26,7 @@
“第 5 章”,“样式迁移”,演示了执行样式转移任务的过程,其中将两个图像作为输入来创建新图像,并使用来自两个输入图像的元素。
“第 6 章”和“使用 RNN 分析数据序列”,更详细地探讨了递归神经网络。 在本章中,使用顺序数据作为输入解决了三个流行的数据问题。
“第 6 章”和“使用 RNN 分析数据序列”,更详细地探讨了循环神经网络。 在本章中,使用顺序数据作为输入解决了三个流行的数据问题。
## 约定
......
......@@ -491,7 +491,7 @@ Optimizer.step()
Optimizer.step()
如果 i5 == 0:
如果 i% 5 == 0:
打印(i,loss.item())
......
此差异已折叠。
......@@ -2,7 +2,7 @@
总览
在本章中,我们将看一个银行业中的实际例子,以解决分类数据问题。 您将学习如何利用 PyTorch 的自定义模块来定义网络体系结构并训练模型。 您还将探索错误分析的概念,以提高模型的性能。 最后,您将研究部署模型的不同方法,以便将来使用它。 到本章结束时,您将对该过程有深刻的了解,以便可以使用**深神经网络****DNN**)在 PyTorch 中。
在本章中,我们将看一个银行业中的实际例子,以解决分类数据问题。 您将学习如何利用 PyTorch 的自定义模块来定义网络体系结构并训练模型。 您还将探索错误分析的概念,以提高模型的性能。 最后,您将研究部署模型的不同方法,以便将来使用它。 到本章结束时,您将对该过程有深刻的了解,以便可以使用**深神经网络****DNN**)在 PyTorch 中。
# 简介
......@@ -62,7 +62,7 @@
注意
本章其余部分将重点解决与信用卡使用有关的数据问题。 要下载将要使用的数据集,请转到[这里](http://archive.ics.uci.edu/ml/datasets/default+of+credit+card+clients),单击**数据 文件夹**链接,然后下载 **.xls** 文件。 [该数据集也可在本书的 GitHub 存储库中找到](https://packt.live/38qLadV)。
本章其余部分将重点解决与信用卡使用有关的数据问题。 要下载将要使用的数据集,请转到[这里](http://archive.ics.uci.edu/ml/datasets/default+of+credit+card+clients),单击**数据文件夹**链接,然后下载`.xls`文件。 [该数据集也可在本书的 GitHub 存储库中找到](https://packt.live/38qLadV)。
## 探索数据集
......@@ -74,17 +74,17 @@
**内容**:建立一个模型,该模型能够确定客户是否会拖欠即将到来的付款。
**为什么**:能够预测下个月要收到的付款金额(以货币为单位)。 这将帮助公司确定该月的支出策略,并允许他们定义要与每个客户一起执行的操作,既可以确保将要付款的客户将来的付款,也可以提高将要付款的客户的付款可能性。 默认。
**意义**:能够预测下个月要收到的付款金额(以货币为单位)。 这将帮助公司确定该月的支出策略,并允许他们定义要与每个客户一起执行的操作,既可以确保将要付款的客户将来的付款,也可以提高将要付款的客户的付款可能性。 默认。
**方式**:使用历史数据包含人口统计信息,信用历史记录以及有或没有拖欠付款的客户以前的账单,以训练模型。 在对输入数据进行培训之后,该模型应该能够确定客户是否可能拖欠下一次付款。
考虑到这一点,似乎目标功能应该是说明客户是否会在下次付款时违约,这将导致二进制结果(是/否)。 这意味着要开发的学习任务是分类任务,因此损失函数应该能够测量这种学习类型的差异(例如,交叉熵函数,如上一章所述)。 。
明确定义问题后,您需要确定最终模型的优先级。 这意味着确定所有输出类别是否同样重要。 例如,建立模型的时候,测量肺部肿块是否恶变的模型应主要集中在使**假阴性**最小化(模型预测为无恶性肿块,但实际上是恶性的患者)上。 识别手写字符不应只关注一个特定的字符,而应最大化其在平等地识别所有字符方面的性能。
明确定义问题后,您需要确定最终模型的优先级。 这意味着确定所有输出类别是否同样重要。 例如,建立模型的时候,测量肺部肿块是否恶变的模型应主要集中在使**假负例**最小化(模型预测为无恶性肿块,但实际上是恶性的患者)上。 识别手写字符不应只关注一个特定的字符,而应最大化其在平等地识别所有字符方面的性能。
考虑到这一点以及 Why 语句中的解释,信用卡客户默认**数据集**的模型优先级应该是在不优先考虑任何类别标签的情况下最大化模型的整体性能 。 这主要是因为“为什么”声明宣称研究的主要目的应该是更好地了解银行将要收到的资金,并对可能拖欠付款的客户采取某些措施(针对 例如,提供将债务分成较小的付款),以及针对那些不会违约的人采取不同的行动(例如,提供优惠作为对行为良好的客户的奖励)。****
据此,本案例研究中使用的性能指标是**准确**,其重点是使**正确分类的实例**最大化。 这是指任何类别标签正确分类的实例与实例总数的比率。
据此,本案例研究中使用的性能指标是**准确**,其重点是使**正确分类的实例**最大化。 这是指任何类别标签正确分类的实例与实例总数的比率。
下表简要说明了数据集中存在的每个功能,这些功能可以帮助确定它们与研究目的的相关性,并确定一些需要执行的准备任务:
......@@ -114,9 +114,9 @@
注意
为了能够使用 Pandas 读取 Excel 文件,请确保已在计算机或虚拟环境上安装了 **xlrd** 。 要安装 **xlrd** ,您需要在 Anaconda 提示符下运行 **conda install -c anaconda xlrd**
为了能够使用 Pandas 读取 Excel 文件,请确保已在计算机或虚拟环境上安装了`xlrd`。 要安装`xlrd`,您需要在 Anaconda 提示符下运行`conda install -c anaconda xlrd`
以下是用于使用**大熊猫**读取 Excel 文件并打印出数据集标题的代码段:
以下是用于使用 Pandas 读取 Excel 文件并打印出数据集标题的代码段:
将熊猫作为 pd 导入
......@@ -126,7 +126,7 @@
data.head()
我们使用**跳过行**参数删除 Excel 文件的第一行,该行无关,因为它包含第二组标题。
我们使用`skipline`参数删除 Excel 文件的第一行,该行无关,因为它包含第二组标题。
执行代码后,将获得以下结果:
......@@ -194,11 +194,11 @@ print(“ rows:”,data.shape [0],“列数:”,data.shape [1])
百分比= count / data_clean.shape [0]
离群值[data_clean.columns [i]] =“%.3f”%百分比
离群值[data_clean.columns [i]] =“% .3f”% 百分比
打印(异常值)
这将导致一个字典,其中包含每个要素名称作为键,并且该值表示该要素离群值的比例。 从这些结果中,可以观察到包含更多异常值的特征是 **BILL_AMT1** 和 **BILL_AMT4** ,它们各自占总数的 2.3%
这将导致一个字典,其中包含每个要素名称作为键,并且该值表示该要素离群值的比例。 从这些结果中,可以观察到包含更多异常值的特征是`BILL_AMT1`和`BILL_AMT4`,它们各自占总数的 2.3%
这意味着,鉴于异常值对每个特征的参与度太低,因此不需要采取进一步的措施,因此它们不太可能对最终模型产生影响。
......@@ -208,11 +208,11 @@ print(“ rows:”,data.shape [0],“列数:”,data.shape [1])
**收集更多数据**:尽管这并非总是可用的途径,但它可能有助于平衡类或允许删除过度代表的类而不会严重减少数据集。
**更改性能指标**:某些指标(例如准确性)不适用于测量不平衡数据集的性能。 反过来,建议使用诸如精度或召回分类问题之类的指标来衡量性能。
**更改表现指标**:某些指标(例如准确性)不适用于测量不平衡数据集的性能。 反过来,建议使用诸如精度或召回分类问题之类的指标来衡量性能。
**重采样数据集**:这需要修改数据集以平衡类。 可以通过两种不同的方式来完成此操作:在代表性不足的类中添加实例的副本(称为过采样),或删除代表性不足的类的实例(称为欠采样)。
可以通过简单地计算**目标**功能中每个类的出现来检测类不平衡,如下所示:
可以通过简单地计算`target`属性中每个类的出现来检测类不平衡,如下所示:
目标= data_clean [“下个月的默认付款”]
......@@ -220,11 +220,11 @@ print(“ rows:”,data.shape [0],“列数:”,data.shape [1])
否= target [target == 0] .count()
print(“是%:” + str(是/ len(目标)* 100)+“-否%:” \
print(“是%:” + str(是/ len(目标)* 100)+“-否%:” \
+ str(否/ len(目标)* 100))
根据前面的代码,可以得出结论,拖欠付款的客户数量占数据集的 22.12。 这些结果也可以使用以下代码行显示在绘图中:
根据前面的代码,可以得出结论,拖欠付款的客户数量占数据集的 22.12%。 这些结果也可以使用以下代码行显示在绘图中:
导入 matplotlib.pyplot 作为 plt
......@@ -264,13 +264,13 @@ data_resampled = pd.concat([data_no,over_sampling],\
轴= 0)
首先,我们将每个类标签的数据分成独立的 DataFrame。 接下来,我们使用 Pandas 的 **sample()**函数来构造一个新的 DataFrame,其中包含的重复表示实例数与过量表示的实例数据帧一样多。
首先,我们将每个类标签的数据分成独立的 DataFrame。 接下来,我们使用 Pandas 的`sample()`函数来构造一个新的 DataFrame,其中包含的重复表示实例数与过量表示的实例数据帧一样多。
注意
请记住, **sample()**函数的第一个参数(**否**)是指先前计算的过分代表类中的项目数。
请记住, `sample()`函数的第一个参数(`no`)是指先前计算的过分代表类中的项目数。
最后, **concat()**函数用于连接过度代表的类的 DataFrame 和大小相同的新创建的 DataFrame,以便创建要在后续步骤中使用的最终数据集。
最后, `concat()`函数用于连接过度代表的类的 DataFrame 和大小相同的新创建的 DataFrame,以便创建要在后续步骤中使用的最终数据集。
使用新创建的数据集,可以再次计算整个数据集中目标要素中每个类标签的参与度,这现在应该反映出具有相同参与度的两个类标签的均等表示的数据集。 此时,数据集的最终形状应等于(46728,23)。
......@@ -314,13 +314,13 @@ final_data.to_csv(“ dccc_prepared.csv”,index = False)
## 用于分类任务的 ANN
*活动 2.02* 中所示,*从“第 2 章”和*神经网络的构建模块*开发用于回归问题*的深度学习解决方案 ],为回归任务而构建的神经网络使用输出作为连续值,这就是为什么在输出层不具有激活函数且仅具有一个输出节点(实际值)的原因,就像在构建用于预测房价的模型的情况下一样 根据房屋和邻里的特征
“活动 2.02”中所示,从“第 2 章”和“神经网络的构建模块”开发用于回归问题的深度学习解决方案,为回归任务而构建的神经网络使用输出作为连续值,这就是为什么在输出层不具有激活函数且仅具有一个输出节点(实际值)的原因,就像在构建用于预测房价的模型的情况下一样 根据房屋和邻里的特征
鉴于此,要测量与此类模型相关的性能,您应该计算地面真实值和预测值之间的差,例如,计算 125.3(预测)与 126.38(地面真实值)之间的距离 。 如前所述,有许多方法可以测量此差异,例如**均方误差****MSE**),或另一种变化是**均方根误差****RMSE**),是最常用的指标。
与此相反,分类任务的输出是属于每个输出标签或类的某些输入要素集合的概率,这是使用 Sigmoid(用于二进制分类)或 softmax(用于多类分类)完成的 )激活功能。 对于二元分类任务,输出层应包含一个(对于 Sigmoid)或两个(对于 softmax)输出节点,而对于多类分类任务,输出层应等于类标签的数量。
计算属于每个输出类别的输入特征的似然性的这种能力,再加上 **argmax** 函数,将以较高的概率检索类别作为最终预测。
计算属于每个输出类别的输入特征的似然性的这种能力,再加上`argmax`函数,将以较高的概率检索类别作为最终预测。
注意
......@@ -370,7 +370,7 @@ nn.Linear(D_h,D_o),\
nn.Softmax())
此处, **D_i** 表示输入尺寸(输入数据中的特征), **D_h** 表示隐藏尺寸(隐藏层中的节点数), **D_o** 是指输出尺寸。
此处,`D_i`表示输入尺寸(输入数据中的特征),`D_h`表示隐藏尺寸(隐藏层中的节点数),`D_o`是指输出尺寸。
使用自定义模块,可以构建等效的网络体系结构,如下所示:
......@@ -450,7 +450,7 @@ o = F.softmax(self.linear2(z))
打印(型号)
**print** 语句的输出应如下所示:
`print`语句的输出应如下所示:
分类器
......@@ -470,9 +470,9 @@ o = F.softmax(self.linear2(z))
## 定义损失函数并训练模型
重要的是要提到,交叉熵损失函数要求网络的输出是原始的(在通过使用 **softmax** 激活函数获得概率之前),这就是为什么通常会发现 用于分类问题的神经网络体系结构,而没有针对输出层的激活功能。 此外,为了通过这种方法进行预测,必须在训练模型后将 **softmax** 激活函数应用于网络的输出。
重要的是要提到,交叉熵损失函数要求网络的输出是原始的(在通过使用`softmax`激活函数获得概率之前),这就是为什么通常会发现 用于分类问题的神经网络体系结构,而没有针对输出层的激活功能。 此外,为了通过这种方法进行预测,必须在训练模型后将`softmax`激活函数应用于网络的输出。
解决此问题的另一种方法是对输出层使用 **log_softmax** 激活函数。 这样,损失函数可以定义为负对数似然损失(**nn.NLLLoss**)。 最后,可以通过从网络输出中获取指数来获得属于每个类别标签的一组要素的概率。 这是本章活动中将使用的方法。
解决此问题的另一种方法是对输出层使用`log_softmax`激活函数。 这样,损失函数可以定义为负对数似然损失(`nn.NLLLoss`)。 最后,可以通过从网络输出中获取指数来获得属于每个类别标签的一组要素的概率。 这是本章活动中将使用的方法。
一旦定义了模型体系结构,下一步将是对负责根据训练数据进行模型训练的部分进行编码,并在训练和验证集上测量其性能。
......@@ -492,9 +492,9 @@ batch_size = 100
接下来,循环的第一个**用于遍历我们之前定义的时期数。**
请记住,**时期**是指整个数据集通过网络体系结构前后传递的次数。 **batch_size** 是指单个批次(数据集的一部分)中训练示例的数量。 最后,**迭代**是指完成一个时期所需的批处理数量。
请记住,**时期**是指整个数据集通过网络体系结构前后传递的次数。`batch_size`是指单个批次(数据集的一部分)中训练示例的数量。 最后,**迭代**是指完成一个时期所需的批处理数量。
循环的第二个**用于遍历总数据集的每个批次,直到完成一个纪元为止。 在此循环中,发生以下计算:**
第二个`for`循环遍历总数据集的每个批次,直到完成一个纪元为止。 在此循环中,发生以下计算:
1. 在一批训练集上训练模型。 在此获得预测。
2. 通过比较上一步的预测值和训练集的标签(真实情况)来计算损失。
......@@ -504,7 +504,7 @@ batch_size = 100
获取模型预测的指数,以便获得属于每个类标签的给定数据片段的概率。
使用 **topk()**方法可以获得较高的类标签。
使用`topk`方法可以获得较高的类标签。
使用 scikit-learn 的“度量”部分,计算准确性,精确度或查全率。 您还可以探索其他性能指标。
......@@ -634,12 +634,12 @@ batch_size = 100
即使使用种子,考虑到训练集在每个时期之前都经过了改组,该活动的确切结果也无法重现。
2. 读取先前准备的数据集,该数据集应已命名为 **dccc_prepared.csv**
2. 读取先前准备的数据集,该数据集应已命名为`dccc_prepared.csv`
3. 将功能与目标分开。
4. 使用 scikit-learn 的 **train_test_split** 函数,将数据集分为训练,验证和测试集。 使用 60:20:20 的分配比例。 将 **random_state** 设置为`0`
4. 使用 scikit-learn 的`train_test_split`函数,将数据集分为训练,验证和测试集。 使用 60:20:20 的分配比例。 将`random_state`设置为`0`
5. 考虑到要素矩阵应为浮点型,而目标矩阵则应为非浮点型,将验证和测试集转换为张量。 目前暂时不要转换训练集,因为它们将进行进一步的转换。
6. 构建用于定义网络层的自定义模块类。 包括一个前向功能,该功能指定将应用于每层输出的激活功能。 对于除输出之外的所有层,请使用 **ReLU** ,在此处应使用 **log_softmax**
7. 实例化模型并定义训练模型所需的所有变量。 将时期数设置为 **50** ,并将批大小设置为 **128** 。 使用 **0.001** 的学习率。
6. 构建用于定义网络层的自定义模块类。 包括一个前向功能,该功能指定将应用于每层输出的激活功能。 对于除输出之外的所有层,请使用 **ReLU**,在此处应使用`log_softmax`
7. 实例化模型并定义训练模型所需的所有变量。 将时期数设置为`50`,并将批大小设置为 **128** 。 使用`0.001`的学习率。
8. Train the network using the training set's data. Use the validation sets to measure performance. To do this, save the loss and the accuracy for both the training and validation sets in each epoch.
注意
......@@ -748,7 +748,7 @@ batch_size = 100
## 练习 3 .02:提高模型的性能
对于此活动,我们将实施在练习中定义的操作,以减少影响模型性能的高偏差。 请考虑以下情形:团队成员对您所做的工作和代码的组织印象深刻,但是考虑到他们对客户的承诺,他们却要求您尝试将性能提高到 80。 请按照以下步骤完成此活动:
对于此活动,我们将实施在练习中定义的操作,以减少影响模型性能的高偏差。 请考虑以下情形:团队成员对您所做的工作和代码的组织印象深刻,但是考虑到他们对客户的承诺,他们却要求您尝试将性能提高到 80%。 请按照以下步骤完成此活动:
注意
......@@ -765,7 +765,7 @@ batch_size = 100
4. 绘制两组数据的损失和准确性。
5. 使用性能最佳的模型,对测试集进行预测(在微调过程中不应使用该预测)。 通过计算该组模型的准确性,将预测结果与真实情况进行比较。
预期输出:通过模型体系结构和此处定义的参数获得的精度应为 80左右。
预期输出:通过模型体系结构和此处定义的参数获得的精度应为 80% 左右。
注意
......
......@@ -601,7 +601,7 @@ batch_size =批量大小)
1. 导入所需的库。
2. 设置要对数据执行的转换,这将是数据到张量的转换以及像素值的归一化。
3. 设置批量为 100 张图像,并从 **CIFAR10** 数据集下载训练和测试数据。
4. 使用 20的验证大小,定义将用于将数据集分为这两组的训练和验证采样器。
4. 使用 20% 的验证大小,定义将用于将数据集分为这两组的训练和验证采样器。
5. 使用 **DataLoader()**函数定义用于每组数据的批次。
6. Define the architecture of your network. Use the following information to do so:
......@@ -615,9 +615,9 @@ batch_size =批量大小)
每个卷积层之后的池化层,滤镜大小和跨度为 2。
展平图像后,滤除项设置为 20
展平图像后,滤除项设置为 20%
线性 1:一个完全连接的层,接收上一层的展平矩阵作为输入,并生成 100 个单位的输出。 为此层使用 ReLU 激活功能。 此处,辍学期限设置为 20
线性 1:一个完全连接的层,接收上一层的展平矩阵作为输入,并生成 100 个单位的输出。 为此层使用 ReLU 激活功能。 此处,辍学期限设置为 20%
Linear2:一个完全连接的层,可生成 10 个输出,每个类标签一个。 将 **log_softmax** 激活功能用于输出层。
......@@ -745,7 +745,7 @@ transform = transform [“ test”])
1. 复制上一个活动中的笔记本。
2. Change the definition of the **transform** variable so that it includes, in addition to normalizing and converting the data into tensors, the following transformations:
对于训练/验证集, **RandomHorizo​​ntalFlip** 函数的概率为 50%(0.5), **RandomGrayscale** 函数的概率为 10%(0.1)。
对于训练/验证集, **RandomHorizo​​ntalFlip** 函数的概率为 50% (0.5), **RandomGrayscale** 函数的概率为 10% (0.1)。
对于测试集,请勿添加任何其他转换。
......@@ -765,7 +765,7 @@ transform = transform [“ test”])
4. 计算测试集上所得模型的准确性。
预期输出:模型在测试集上的性能应为 75左右。
预期输出:模型在测试集上的性能应为 75% 左右。
注意
......@@ -843,7 +843,7 @@ x = F.log_softmax(self.linear2(x),dim = 1)
对于此活动,我们将在前一个活动的体系结构上实现批量归一化,以查看是否有可能进一步提高测试集上模型的性能。 让我们看一下以下情况。
您在性能方面所做的最后改进使您的队友印象深刻,现在他们对您的期望更高。 他们要求您最后一次尝试改进模型,以使准确性提高到 80。 请按照以下步骤完成此活动:
您在性能方面所做的最后改进使您的队友印象深刻,现在他们对您的期望更高。 他们要求您最后一次尝试改进模型,以使准确性提高到 80%。 请按照以下步骤完成此活动:
1. 复制上一个活动中的笔记本。
2. 将批量归一化添加到每个卷积层以及第一个 FC 层。
......
......@@ -640,7 +640,7 @@ features [layers [index]] = x
#打印目标图像
如果 iprint_statement == 0 或 i == 1:
如果 i% print_statement == 0 或 i == 1:
print('Total loss:',total_loss.item())
......
......@@ -2,7 +2,7 @@
总览
本章扩展了递归神经网络的概念。 您将了解**递归神经网络****RNN**)的学习过程以及它们如何存储内存。 本章将介绍**长短期存储器****LSTM**)网络体系结构,该体系结构使用短期和长期存储器来解决数据序列中的数据问题。 在本章的最后,您将牢固地掌握 RNN 以及如何解决**自然语言处理****NLP**)数据问题。
本章扩展了循环神经网络的概念。 您将了解**循环神经网络****RNN**)的学习过程以及它们如何存储内存。 本章将介绍**长短期存储器****LSTM**)网络体系结构,该体系结构使用短期和长期存储器来解决数据序列中的数据问题。 在本章的最后,您将牢固地掌握 RNN 以及如何解决**自然语言处理****NLP**)数据问题。
# 简介
......@@ -18,7 +18,7 @@
[本章中提供的所有代码都可以在以下位置找到](https://packt.live/2yn253K)
# 递归神经网络
# 循环神经网络
就像人类不会每秒重新设置思想一样,旨在理解人类语言的神经网络也不应这样做。 这意味着,为了理解段落中甚至整个书中的每个单词,您或模型需要理解之前的单词,这可以帮助给可能具有不同含义的单词提供上下文。
......
......@@ -58,7 +58,7 @@
Optimizer.step()
如果 i10 == 0:
如果 i% 10 == 0:
打印(loss.item())
......@@ -152,11 +152,11 @@
百分比= count / data.shape [0]
离群值[data.columns [i]] =“%.3f”%百分比
离群值[data.columns [i]] =“% .3f”% 百分比
打印(异常值)
输出字典应显示所有要素均不包含代表超过 5数据的离群值。
输出字典应显示所有要素均不包含代表超过 5% 数据的离群值。
6. Separate the features from the target data:
......@@ -288,7 +288,7 @@
Optimizer.step()
如果 i250 == 0:
如果 i% 250 == 0:
打印(i,loss.item())
......@@ -734,7 +734,7 @@
model.train()
如果 e50 == 0 或 e == 1:
如果 e% 50 == 0 或 e == 1:
x_axis.append(e)
......@@ -820,7 +820,7 @@
打印(acc_test)
通过模型体系结构和此处定义的参数获得的精度应为 80左右。
通过模型体系结构和此处定义的参数获得的精度应为 80% 左右。
注意
......@@ -1084,9 +1084,9 @@
在每个卷积层之后使用池化层,滤镜大小和步幅为 2。
展平图像后,使用掉落项设置为 20
展平图像后,使用掉落项设置为 20%
线性 1:一个完全连接的层,接收上一层的展平矩阵作为输入,并生成 100 个单位的输出。 为此层使用 ReLU 激活功能。 此处的辍学期限设置为 20
线性 1:一个完全连接的层,接收上一层的展平矩阵作为输入,并生成 100 个单位的输出。 为此层使用 ReLU 激活功能。 此处的辍学期限设置为 20%
Linear2:一个完全连接的层,可生成 10 个输出,每个类标签一个。 将 **log_softmax** 激活功能用于输出层:
......@@ -1206,7 +1206,7 @@
#验证给定时期的模型
如果 e5 == 0 或 e == 1:
如果 e% 5 == 0 或 e == 1:
x_axis.append(e)
......@@ -1328,7 +1328,7 @@
#验证给定时期的模型
如果 e5 == 0 或 e == 1:
如果 e% 5 == 0 或 e == 1:
x_axis.append(e)
......@@ -1476,7 +1476,7 @@
打印(acc_test / iter_3)
测试集的准确性与其他两组所达到的准确性非常相似,这意味着该模型能够对看不见的数据表现出同样出色的性能。 它应该在 72左右。
测试集的准确性与其他两组所达到的准确性非常相似,这意味着该模型能够对看不见的数据表现出同样出色的性能。 它应该在 72% 左右。
注意
......@@ -1496,7 +1496,7 @@
2. Change the definition of the **transform** variable so that it includes, in addition to normalizing and converting the data into tensors, the following transformations:
对于训练/验证集,请使用 **RandomHorizo​​ntalFlip** 函数,其概率为 50%(**0.5**),并使用 **RandomGrayscale** 函数,其概率为 10%(**0.1**)。
对于训练/验证集,请使用 **RandomHorizo​​ntalFlip** 函数,其概率为 50% (**0.5**),并使用 **RandomGrayscale** 函数,其概率为 10% (**0.1**)。
对于测试集,请勿添加任何其他转换:
......@@ -1540,7 +1540,7 @@
4. Calculate the accuracy of the resulting model on the testing set.
该模型在测试设备上的性能提高了约 75
该模型在测试设备上的性能提高了约 75%
注意
......@@ -1630,7 +1630,7 @@
4. Calculate the accuracy of the resulting model on the testing set.
该模型在测试设备上的性能已提高了约 78
该模型在测试设备上的性能已提高了约 78%
注意
......@@ -1936,7 +1936,7 @@
#打印目标图像
如果 iprint_statement == 0 或 i == 1:
如果 i% print_statement == 0 或 i == 1:
print('Total loss:',total_loss.item())
......@@ -2124,7 +2124,7 @@
loss.append(loss.item())
如果 i1000 == 0:
如果 i% 1000 == 0:
print(“ epoch:”,i,“ = ...损失函数:”,损失[-1])
......@@ -2422,7 +2422,7 @@
loss.append(np.mean(batch_loss))
如果 e2 == 0:
如果 e% 2 == 0:
print(“ epoch:”,e,“ ...损失函数:”,损失[-1])
......@@ -2496,7 +2496,7 @@
loss.append(np.mean(batch_loss))
如果 e50 == 0:
如果 e% 50 == 0:
print(“ epoch:”,e,“ ...损失函数:”,\
......@@ -2776,7 +2776,7 @@
追加(精度)
如果 e1 == 0:
如果 e% 1 == 0:
print(“ Epoch:”,e,“ ...损失函数:”,损失[-1],\
......
......@@ -1059,7 +1059,7 @@ plot_loss(train_loss,val_loss)
![](img/97d99dae-968d-45c3-9d2f-13cf0b663c2b.png)
在本节中,我们探索了使用 MNIST 数据集的暹罗网络的实现以及使用 Omniglot 数据集的匹配网络体系结构。 在 Siamese 网络编码练习中,我们创建了一个小的卷积层,并由一个完全连接的层姐妹体系结构进行了扩展。 训练模型后,我们还绘制了模型获得的二维嵌入图,并观察了某些数字如何聚类在一起。 同样,在匹配网络编码练习中,我们为匹配网络的每个模块实现了小型体系结构,例如嵌入提取器,注意力模型和完全上下文嵌入。 我们还观察到,仅用 100 个时期,我们就可以达到约 86的精度,并绘制了匹配网络架构的精度和损耗图。
在本节中,我们探索了使用 MNIST 数据集的暹罗网络的实现以及使用 Omniglot 数据集的匹配网络体系结构。 在 Siamese 网络编码练习中,我们创建了一个小的卷积层,并由一个完全连接的层姐妹体系结构进行了扩展。 训练模型后,我们还绘制了模型获得的二维嵌入图,并观察了某些数字如何聚类在一起。 同样,在匹配网络编码练习中,我们为匹配网络的每个模块实现了小型体系结构,例如嵌入提取器,注意力模型和完全上下文嵌入。 我们还观察到,仅用 100 个时期,我们就可以达到约 86% 的精度,并绘制了匹配网络架构的精度和损耗图。
您可能还观察到某些模型是从头开始训练的-我们可能已经使用了转移学习体系结构,或者增加了 LSTM 体系结构的隐藏大小,或者也许被认为是加权的交叉熵损失函数。 总是有实验和改进的空间。 如果您想进一步尝试使用该模型,建议您访问本书的 GitHub 页面。
......
......@@ -80,7 +80,7 @@
![](img/f6a0bbfd-bfe5-4d2d-8d0e-015fc55c1642.png)
所有操作(包括读取,写入和寻址的四个阶段)都是差分的,因此可以使用反向传播和任何基于梯度下降的优化器从头到尾训练整个 NMT 模型。 控制器是一个神经网络,可以是前馈网络,也可以是递归神经网络,例如**长短期记忆****LSTM**)。 它已显示在各种算法任务(例如复制任务)上均具有良好的性能,这些任务将在本章的稍后部分实现。
所有操作(包括读取,写入和寻址的四个阶段)都是差分的,因此可以使用反向传播和任何基于梯度下降的优化器从头到尾训练整个 NMT 模型。 控制器是一个神经网络,可以是前馈网络,也可以是循环神经网络,例如**长短期记忆****LSTM**)。 它已显示在各种算法任务(例如复制任务)上均具有良好的性能,这些任务将在本章的稍后部分实现。
既然我们了解了 NTM 的体系结构和工作原理,我们就可以开始研究 MANN,这是对 NMT 的修改,并且经过修改可以在一次学习中表现出色。
......@@ -206,7 +206,7 @@ MANN 的读取操作与 NTM 的读取操作非常相似,唯一的区别是此
在选择嵌入网络时,元网络使用 LSTM 体系结构。 如我们所见,匹配网络和 LSTM 元学习者也遵循相同的策略,分别用于提取数据和元信息的上下文嵌入。 这是因为 LSTM 体系结构倾向于记住历史,这使得元学习者的目标能够跨任务提取重要信息。
例如,假设我们正在培训我们的网络以完成多种任务,例如猫的品种分类和狗的品种分类。 当我们使用 LSTM 元学习器进行训练时,它会学习例如狗品种分类中体重更新的策略,并使用这些学习到的信息以较少的步骤和较少的数据来优化其用于猫品种分类的操作。 使用元网络在 Omniglot 数据集上达到了 95.92%的准确性,而人类的准确性仅为 95.5%,因此,元网络被认为是最新模型之一。
例如,假设我们正在培训我们的网络以完成多种任务,例如猫的品种分类和狗的品种分类。 当我们使用 LSTM 元学习器进行训练时,它会学习例如狗品种分类中体重更新的策略,并使用这些学习到的信息以较少的步骤和较少的数据来优化其用于猫品种分类的操作。 使用元网络在 Omniglot 数据集上达到了 95.92% 的准确性,而人类的准确性仅为 95.5%,因此,元网络被认为是最新模型之一。
# 编码练习
......
......@@ -20,7 +20,7 @@
[“第 4 章”](../Text/4.html#_idTextAnchor070) *,文本预处理,词干和词法化*展示了如何预处理文本数据以用于 NLP 深度学习模型。
[“第 5 章”](../Text/5.html#_idTextAnchor092) *,递归神经网络和情感分析*,介绍了递归神经网络的基础知识,并向您展示如何使用它们来建立情感神经网络分析模型。 刮。
[“第 5 章”](../Text/5.html#_idTextAnchor092) *,循环神经网络和情感分析*,介绍了循环神经网络的基础知识,并向您展示如何使用它们来建立情感神经网络分析模型。 刮。
[“第 6 章”](../Text/6.html#_idTextAnchor112) *,用于文本分类的卷积神经网络*,介绍了卷积神经网络的基础知识,并向您展示了如何使用它们为 分类文本。
......
......@@ -132,7 +132,7 @@
![](img/Formula_01_016.png)
为了计算准确性,我们只需将正确预测为垃圾邮件/非垃圾邮件的电子邮件数量除以我们做出的预测总数即可。 如果我们正确地预测了 1,000 封电子邮件中的 990 封电子邮件,则我们的准确性为 99。 但是,高精度不一定意味着我们的模型是好的:
为了计算准确性,我们只需将正确预测为垃圾邮件/非垃圾邮件的电子邮件数量除以我们做出的预测总数即可。 如果我们正确地预测了 1,000 封电子邮件中的 990 封电子邮件,则我们的准确性为 99%。 但是,高精度不一定意味着我们的模型是好的:
![Figure 1.9 – Table showing data predicted as spam/non-spam ](img/B12365_01_9.jpg)
......
......@@ -224,7 +224,7 @@ self.fc4 = nn.Linear(98,10)
图 2.12 –我们的神经网络
在这里,我们可以看到我们的最后一层输出了 **10** 个单位。 这是因为我们希望预测每个图像是否为 0 到 9 之间的数字,总共是 10 种不同的可能分类。 我们的输出是长度为 **10** 的向量,并且包含图像的 10 种可能值中的每一个的预测。 在进行最终分类时,我们将数值最高的数字分类作为模型的最终预测。 例如,对于给定的预测,我们的模型可能会预测图像类型为 1 的概率为 10%,类型 2 的概率为 10%,类型 3 的概率为 80%。 因此,我们将类型 3 作为预测,因为它以最高概率被预测。
在这里,我们可以看到我们的最后一层输出了 **10** 个单位。 这是因为我们希望预测每个图像是否为 0 到 9 之间的数字,总共是 10 种不同的可能分类。 我们的输出是长度为 **10** 的向量,并且包含图像的 10 种可能值中的每一个的预测。 在进行最终分类时,我们将数值最高的数字分类作为模型的最终预测。 例如,对于给定的预测,我们的模型可能会预测图像类型为 1 的概率为 10%,类型 2 的概率为 10%,类型 3 的概率为 80%。 因此,我们将类型 3 作为预测,因为它以最高概率被预测。
## 实施辍学
......@@ -232,7 +232,7 @@ self.fc4 = nn.Linear(98,10)
self.dropout = nn.Dropout(p = 0.2)
辍学是一种规范化我们的神经网络以防止过度拟合的方法。 在每个训练纪元上,对于已应用丢包的层中的每个节点,都有可能(此处定义为`p`= 20)该层内的每个节点将不用于训练/反向传播 。 这意味着,在训练时,我们的网络会针对过拟合变得健壮,因为在训练过程的每次迭代中都不会使用每个节点。 这可以防止我们的网络过于依赖网络中特定节点的预测。
辍学是一种规范化我们的神经网络以防止过度拟合的方法。 在每个训练纪元上,对于已应用丢包的层中的每个节点,都有可能(此处定义为`p`= 20% )该层内的每个节点将不用于训练/反向传播 。 这意味着,在训练时,我们的网络会针对过拟合变得健壮,因为在训练过程的每次迭代中都不会使用每个节点。 这可以防止我们的网络过于依赖网络中特定节点的预测。
## 定义前向通行证
......@@ -308,7 +308,7 @@ opt = optim.Adam(model.parameters(),lr = 0.001)
5. Finally, after each epoch is complete, we print the total loss. We can observe this to make sure our model is learning:
打印('Epoch [%d /%d]损失:%.4f'%(epoch + 1,50,loss.data.item()))
打印('Epoch [% d /% d]损失:% .4f'% (epoch + 1,50,loss.data.item()))
一般而言,我们预计损失会在每个时期减少。 我们的输出将如下所示:
......@@ -386,7 +386,7 @@ preds = len(预测标签)
图 2.17 –准确性得分
恭喜你! 您的第一个神经网络能够正确识别近 90的看不见的数字图像。 随着我们的前进,我们将看到可能会带来更先进的性能。 但是,到目前为止,我们已经证明使用 PyTorch 创建简单的深度神经网络非常简单。 只需几行代码就可以编写代码,从而获得超越基本机器学习模型(例如回归)所能达到的性能。
恭喜你! 您的第一个神经网络能够正确识别近 90% 的看不见的数字图像。 随着我们的前进,我们将看到可能会带来更先进的性能。 但是,到目前为止,我们已经证明使用 PyTorch 创建简单的深度神经网络非常简单。 只需几行代码就可以编写代码,从而获得超越基本机器学习模型(例如回归)所能达到的性能。
# 用于 PyTorch 的 NLP
......@@ -510,7 +510,7 @@ loss.backward()
Optimizer.step()
如果时代10 == 0:
如果时代% 10 == 0:
print('Epoch:',str(epoch + 1),',Loss:'+ str(loss.item()))
......
......@@ -418,7 +418,7 @@ n-gram 帮助我们做的一件事是了解自然语言是如何形成的。 如
图 3.17 –概率的表格表示
有了这个,我们可以计算出出现 Python 的概率,假设前一个单词*为*出现的概率仅为 20%,而*英语*出现的概率仅为 10%。 我们可以进一步扩展此模型,以使用我们认为适当的来表示单词的三元组或任何 n 元组。 我们已经证明,可以使用 n-gram 语言建模将关于单词之间的相互关系的更多信息引入我们的模型,而不必天真地假设单词是独立分布的。
有了这个,我们可以计算出出现 Python 的概率,假设前一个单词*为*出现的概率仅为 20%,而*英语*出现的概率仅为 10%。 我们可以进一步扩展此模型,以使用我们认为适当的来表示单词的三元组或任何 n 元组。 我们已经证明,可以使用 n-gram 语言建模将关于单词之间的相互关系的更多信息引入我们的模型,而不必天真地假设单词是独立分布的。
# 令牌化
......
......@@ -401,4 +401,4 @@ lemmatize_with_pos(句子)
在本章中,我们通过探讨两种方法的功能,它们的用例以及如何实现它们,详细讨论了词干和词根化。 既然我们已经涵盖了深度学习和 NLP 预处理的所有基础知识,我们就可以开始从头开始训练我们自己的深度学习模型。
在下一章中,我们将探讨 NLP 的基础知识,并演示如何在深度 NLP 领域中建立最广泛使用的模型:递归神经网络。
\ No newline at end of file
在下一章中,我们将探讨 NLP 的基础知识,并演示如何在深度 NLP 领域中建立最广泛使用的模型:循环神经网络。
\ No newline at end of file
# “第 5 章”:递归神经网络和情感分析
# “第 5 章”:循环神经网络和情感分析
在本章中,我们将研究**递归神经网络****RNN**),这是 PyTorch 中基本前馈神经网络的变体,我们学习了如何在 [*中进行构建 ]第 1 章*](../Text/1.html#_idTextAnchor015) *,机器学习基础*。 通常,RNN 可用于任何可以将数据表示为序列的任务。 其中包括使用以序列表示的历史数据的时间序列进行股票价格预测之类的事情。 我们通常在 NLP 中使用 RNN,因为可以将文本视为单个单词的序列,并可以对其进行建模。 传统的神经网络将单个矢量作为模型的输入,而 RNN 可以采用整个矢量序列。 如果我们将文档中的每个单词表示为矢量嵌入,则可以将整个文档表示为矢量序列(或 3 阶张量)。 然后,我们可以使用 RNN(以及更复杂的 RNN 形式,称为**长短期记忆****LSTM**))从我们的数据中学习。
在本章中,我们将研究**循环神经网络****RNN**),这是 PyTorch 中基本前馈神经网络的变体,我们学习了如何在 [*中进行构建 ]第 1 章*](../Text/1.html#_idTextAnchor015) *,机器学习基础*。 通常,RNN 可用于任何可以将数据表示为序列的任务。 其中包括使用以序列表示的历史数据的时间序列进行股票价格预测之类的事情。 我们通常在 NLP 中使用 RNN,因为可以将文本视为单个单词的序列,并可以对其进行建模。 传统的神经网络将单个矢量作为模型的输入,而 RNN 可以采用整个矢量序列。 如果我们将文档中的每个单词表示为矢量嵌入,则可以将整个文档表示为矢量序列(或 3 阶张量)。 然后,我们可以使用 RNN(以及更复杂的 RNN 形式,称为**长短期记忆****LSTM**))从我们的数据中学习。
在本章中,我们将介绍 RNN 的基础知识和更高级的 LSTM。 然后,我们将研究情绪分析,并通过一个实际的示例来研究如何使用 PyTorch 构建 LSTM 对文档进行分类。 最后,我们将在简单的云应用程序平台 Heroku 上托管我们的简单模型,这将使​​我们能够使用我们的模型进行预测。
......@@ -389,7 +389,7 @@ n_layers = 2
标签= np.array([int(x)for data in data ['Sentiment']。values])
接下来,我们定义培训和验证比率。 在这种情况下,我们将在 80%的数据上训练模型,在另外 10%的数据上进行验证,最后在剩余的 10%的数据上进行测试:
接下来,我们定义培训和验证比率。 在这种情况下,我们将在 80% 的数据上训练模型,在另外 10% 的数据上进行验证,最后在剩余的 10% 的数据上进行测试:
train_ratio = 0.8
......@@ -465,7 +465,7 @@ Optimizer.step()
如果我们自己运行此循环,我们将训练我们的模型。 但是,我们想在每个时期之后评估模型的性能,以便根据验证数据集确定模型的性能。 我们这样做如下:
if(步骤print_every)== 0:
if(步骤% print_every)== 0:
net.eval()
......@@ -535,7 +535,7 @@ print(“测试精度:{:. 2f}”。format(num_correct / len(test_loader.
图 5.19 –输出值
然后,我们将模型预测与真实标签进行比较,以获得 **correct_tensor** ,这是一个评估我们模型的每个预测是否正确的向量。 然后,我们对该向量求和,然后将其除以其长度,以获得模型的总精度。 在这里,我们获得了 76的准确性。 尽管我们的模型肯定还远非完美,但鉴于我们的训练量很小且训练时间有限,这一点也不差! 仅用于说明从 NLP 数据学习时 LSTM 的有用性。 接下来,我们将展示如何使用模型从新数据进行预测。
然后,我们将模型预测与真实标签进行比较,以获得 **correct_tensor** ,这是一个评估我们模型的每个预测是否正确的向量。 然后,我们对该向量求和,然后将其除以其长度,以获得模型的总精度。 在这里,我们获得了 76% 的准确性。 尽管我们的模型肯定还远非完美,但鉴于我们的训练量很小且训练时间有限,这一点也不差! 仅用于说明从 NLP 数据学习时 LSTM 的有用性。 接下来,我们将展示如何使用模型从新数据进行预测。
## 使用我们的模型进行预测
......
......@@ -123,7 +123,7 @@ CNN 背后的基本概念是卷积。 **卷积**本质上是一个滑动窗口
通过这种方式,我们的模型现在将能够在多个类上执行分类任务,并且我们不再局限于我们之前看过的 0 或 1 二进制分类。 具有更多类的模型可能会因预测而受到影响,因为有更多不同的类可以区分。
在二元分类模型中,假设我们有一个平衡的数据集,我们希望我们的模型仅执行随机猜测就可以达到 50%的准确性,而具有五个不同类别的多类模型只能具有 基线精度为 20%。 这意味着仅仅因为多类模型的准确度远低于 100%,并不意味着模型本身固有地在做出预测方面就很糟糕。 当涉及从数百个不同类别进行预测的训练模型时,尤其如此。 在这些情况下,仅具有 50%准确性的模型将被认为表现良好。
在二元分类模型中,假设我们有一个平衡的数据集,我们希望我们的模型仅执行随机猜测就可以达到 50% 的准确性,而具有五个不同类别的多类模型只能具有 基线精度为 20%。 这意味着仅仅因为多类模型的准确度远低于 100%,并不意味着模型本身固有地在做出预测方面就很糟糕。 当涉及从数百个不同类别进行预测的训练模型时,尤其如此。 在这些情况下,仅具有 50% 准确性的模型将被认为表现良好。
现在我们已经定义了多类分类问题,我们需要加载数据以训练模型。
......@@ -205,7 +205,7 @@ train_data.examples [0] .label
图 6.13 –训练和验证集的大小
这表明我们的培训验证率约为 70%至 30%。 值得注意的是,我们的输入句子是如何被标记化的,即标点符号被当作它们自己的标记。
这表明我们的培训验证率约为 70% 至 30%。 值得注意的是,我们的输入句子是如何被标记化的,即标点符号被当作它们自己的标记。
现在我们知道我们的神经网络不会将原始文本作为输入,我们必须找到某种方法将其转换为某种形式的嵌入表示。 虽然我们可以训练自己的嵌入层,但可以改用我们在 [“第 3 章”](../Text/3.html#_idTextAnchor051) 中讨论过的预先计算的**手套**向量来转换数据 *,执行文本嵌入*。 这还具有使模型更快地训练的额外好处,因为我们将不需要从头开始手动训练嵌入层:
......@@ -295,7 +295,7 @@ batch_size = 64,
图 6.15 –卷积层寻找变量
我们可以看到我们的 **ModuleList** 函数适应了我们想要训练的过滤器的数量和大小。 接下来,在 CNN 初始化中,我们定义其余的层,即将对数据进行分类的线性层和将对网络进行正则化的退出层:
我们可以看到我们的 **ModuleList** 函数适应了我们想要训练的过滤器的数量和大小。 接下来,在 CNN 初始化中,我们定义其余的层,即将对数据进行分类的线性层和将对网络进行正则化的丢弃层:
self.fc = nn.Linear(len(filter_sizes)* n_filters,output_dim)
......@@ -341,7 +341,7 @@ dropout_pc = 0.5
输入维度将始终是词汇量的长度,而输出维度将是我们希望预测的类的数量。 在这里,我们从六个不同的类别进行预测,因此我们的输出向量的长度为`6`。 我们的嵌入维数是 GLoVe 向量的长度(在这种情况下为 **200**)。 填充索引可以从我们的词汇表中手动获取。
可以手动调整接下来的三个超参数,因此您不妨尝试选择不同的值,以了解这如何影响网络的最终输出。 我们传递了一个过滤器大小列表,以便我们的模型将使用大小为`2``3``4`的卷积训练卷积层。 我们将针对每种滤镜尺寸训练 100 个滤镜,因此总共将有 300 个滤镜。 我们还为我们的网络定义了 50的辍学率,以确保其充分正规化。 如果模型似乎容易过拟合或过拟合,则可以升高/降低此值。 一般的经验法则是,如果模型拟合不足,则尝试降低辍学率;如果模型拟合过度,则尝试提高辍学率。
可以手动调整接下来的三个超参数,因此您不妨尝试选择不同的值,以了解这如何影响网络的最终输出。 我们传递了一个过滤器大小列表,以便我们的模型将使用大小为`2``3``4`的卷积训练卷积层。 我们将针对每种滤镜尺寸训练 100 个滤镜,因此总共将有 300 个滤镜。 我们还为我们的网络定义了 50% 的辍学率,以确保其充分正规化。 如果模型似乎容易过拟合或过拟合,则可以升高/降低此值。 一般的经验法则是,如果模型拟合不足,则尝试降低辍学率;如果模型拟合过度,则尝试提高辍学率。
初始化模型后,我们需要将权重加载到嵌入层中。 可以很容易地完成以下操作:
......@@ -471,9 +471,9 @@ torch.save(model.state_dict(),“ cnn_ [model.pt](http://model.pt) ”
print(f’Epoch:{epoch + 1:02} | Epoch Time:{int(end_time-start_time)} s’)
打印(f’\ t 火车损失:{train_loss:.3f} |火车 Acc:{train_ acc * 100:.2f}’)
打印(f’\ t 火车损失:{train_loss:.3f} |火车 Acc:{train_ acc * 100:.2f}% ’)
打印(f’\ t 损失值:{valid_loss:.3f} |累积值:{valid_ acc * 100:.2f}’)
打印(f’\ t 损失值:{valid_loss:.3f} |累积值:{valid_ acc * 100:.2f}% ’)
结果为以下输出:
......@@ -543,4 +543,4 @@ print(“预测类为:“ + str(pred_class))
在本章中,我们展示了如何使用 CNN 从 NLP 数据中学习以及如何使用 PyTorch 从头开始训练 CNN。 虽然深度学习方法与 RNN 中使用的方法有很大不同,但从概念上讲,CNN 以算法方式使用 n 语法语言模型背后的动机,以便从其邻近单词的上下文中提取有关句子中单词的隐式信息。 现在我们已经掌握了 RNN 和 CNN,我们可以开始扩展这些技术,以构建更高级的模型。
在下一章中,我们将学习如何构建利用卷积神经网络和递归神经网络元素的模型,并在序列上使用它们来执行更高级的功能,例如文本翻译。 这些被称为序列到序列网络。
\ No newline at end of file
在下一章中,我们将学习如何构建利用卷积神经网络和循环神经网络元素的模型,并在序列上使用它们来执行更高级的功能,例如文本翻译。 这些被称为序列到序列网络。
\ No newline at end of file
......@@ -2,7 +2,7 @@
在前两章中,我们使用神经网络对文本进行分类并执行情感分析。 两项任务都涉及获取 NLP 输入并预测一些值。 就我们的情感分析而言,这是一个介于 0 和 1 之间的数字,代表我们句子的情感。 就我们的句子分类模型而言,我们的输出是一个多类预测,其中我们的句子属于多个类别。 但是,如果我们不仅希望做出单个预测,还希望做出整个句子,该怎么办? 在本章中,我们将构建一个序列到序列模型,该模型将一种语言的句子作为输入,并输出另一种语言的句子翻译。
我们已经探索了用于 NLP 学习的几种类型的神经网络架构,即 [“第 5 章”](../Text/5.html#_idTextAnchor092) *中的递归神经网络,递归神经网络和情感分析*,以及卷积 [“第 6 章”](../Text/6.html#_idTextAnchor112) *中的神经网络,使用 CNN 的文本分类*。 在本章中,我们将再次使用这些熟悉的 RNN,而不仅仅是构建简单的 RNN 模型,我们还将 RNN 用作更大,更复杂的模型的一部分,以执行序列到序列的翻译。 通过使用我们在前几章中了解到的 RNN 的基础,我们可以展示如何扩展这些概念,以创建适合目的的各种模型。
我们已经探索了用于 NLP 学习的几种类型的神经网络架构,即 [“第 5 章”](../Text/5.html#_idTextAnchor092) *中的循环神经网络,循环神经网络和情感分析*,以及卷积 [“第 6 章”](../Text/6.html#_idTextAnchor112) *中的神经网络,使用 CNN 的文本分类*。 在本章中,我们将再次使用这些熟悉的 RNN,而不仅仅是构建简单的 RNN 模型,我们还将 RNN 用作更大,更复杂的模型的一部分,以执行序列到序列的翻译。 通过使用我们在前几章中了解到的 RNN 的基础,我们可以展示如何扩展这些概念,以创建适合目的的各种模型。
在本章中,我们将介绍以下主题:
......@@ -360,7 +360,7 @@ pred = self.fc_out(output.squeeze(0))
5. 接下来,我们遍历并做出预测。 我们将隐藏状态(从编码器的输出)传递到解码器,以及初始输入(即 **<起始>** 令牌)。 这将返回我们序列中所有单词的预测。 但是,我们只对当前步骤中的单词感兴趣。 也就是说,序列中的下一个单词。 请注意,我们是如何从 1 而不是 0 开始循环的,所以我们的第一个预测是序列中的第二个单词(因为预测的第一个单词将始终是起始标记)。
6. This output consists of a vector of the target vocabulary’s length, with a prediction for each word within the vocabulary. We take the **argmax** function to identify the actual word that is predicted by the model.
然后,我们需要为下一步选择新的输入。 我们将教师强迫率设置为 50%,这意味着 50%的时间,我们将使用刚刚做出的预测作为解码器的下一个输入,而其他 50%的时间,我们将采用真正的目标 。 正如我们之前所讨论的,这比仅依赖模型的预测可以帮助我们的模型更快地学习。
然后,我们需要为下一步选择新的输入。 我们将教师强迫率设置为 50%,这意味着 50% 的时间,我们将使用刚刚做出的预测作为解码器的下一个输入,而其他 50% 的时间,我们将采用真正的目标 。 正如我们之前所讨论的,这比仅依赖模型的预测可以帮助我们的模型更快地学习。
然后,我们继续执行此循环,直到对序列中的每个单词有完整的预测为止:
......
......@@ -201,7 +201,7 @@ corpus_name = "movie_corpus"
words_to_keep.append(k)
print('要保留的单词:{} / {} = {:.2}'。format(
print('要保留的单词:{} / {} = {:.2% }'。format(
len(words_to_keep),len(self.word2index),
......@@ -379,7 +379,7 @@ corpus_name = "movie_corpus"
pair_to_keep.append(p)
print(“从{}对修剪成{},占总数的{:.2}。\
print(“从{}对修剪成{},占总数的{:.2% }。\
格式(len(all_pairs),len(pairs_to_keep),
......@@ -875,11 +875,11 @@ corpus_name = "movie_corpus"
12. On every iteration, we also make sure we print our progress so far, keeping track of how many iterations we have completed and what our loss was for each epoch:
如果迭代print_every == 0:
如果迭代% print_every == 0:
print_loss_avg = print_loss / print_every
print(“迭代:{};完成百分比:{:.1f}; \
print(“迭代:{};完成百分比:{:.1f}% ; \
平均损失:{:. 4f}“。format(迭代,
......@@ -891,7 +891,7 @@ corpus_name = "movie_corpus"
13. For the sake of completion, we also need to save our model state after every few epochs. This allows us to revisit any historical models we have trained; for example, if our model were to begin overfitting, we could revert back to an earlier iteration:
如果(迭代save_every == 0):
如果(迭代% save_every == 0):
目录= os.path.join(save_dir,model_name,\
......
......@@ -51,7 +51,7 @@ BERT 是作为预训练的模型发布的,这意味着用户可以下载和实
### 掩盖语言建模
为了创建这种双向语言表示,BERT 使用了两种不同的技术,第一种是屏蔽语言建模。 这种方法通过用掩蔽标记代替输入句子,从而有效地隐藏了 15的单词。 然后,模型基于句子中其他单词的上下文,尝试预测被屏蔽单词的真实值。 双向进行此预测是为了在两个方向上捕获句子的上下文:
为了创建这种双向语言表示,BERT 使用了两种不同的技术,第一种是屏蔽语言建模。 这种方法通过用掩蔽标记代替输入句子,从而有效地隐藏了 15% 的单词。 然后,模型基于句子中其他单词的上下文,尝试预测被屏蔽单词的真实值。 双向进行此预测是为了在两个方向上捕获句子的上下文:
**输入***我们[MASK_1]在句子*中隐藏了部分[MASK_2]
......@@ -250,7 +250,7 @@ BERT 是按照**变压器**的原理构建的,现在将对其进行详细说
* **roBERTa**:由 Facebook 构建的 BERT 的变体。 删除 BERT 的下一个句子预测元素,但通过实现动态屏蔽来增强单词屏蔽策略。
* **xlm** / **BERT**:也是由 Facebook 构建的,该模型对 BERT 应用了双语言训练机制,从而使它能够学习不同语言的单词之间的关系。 这使 BERT 可以有效地用于机器翻译任务,与基本的序列到序列模型相比,表现出更高的性能。
* **distilBERT**:BERT 的更紧凑版本,保留了原始版本的 95,但将学习到的参数数量减半,从而减少了模型的总大小和训练时间。
* **distilBERT**:BERT 的更紧凑版本,保留了原始版本的 95%,但将学习到的参数数量减半,从而减少了模型的总大小和训练时间。
* **ALBERT**:此经过 Google 训练的模型使用了自己独特的训练方法,称为句子顺序预测。 BERT 的这种变体在许多任务上均表现出优于标准 BERT 的性能,现在被认为是 BERT 之前的最先进技术(说明了事物可以快速改变的速度!)。
虽然 BERT 可能是最著名的,但也有其他基于变压器的模型被认为是最新技术。 通常被认为与 BERT 竞争的主要竞争对手是 GPT-2。
......@@ -327,7 +327,7 @@ GPT-2 的语言生成功能意味着它能够使用很少的提示来生成非
随着“假新闻”的兴起和使用互联网的错误信息的传播,类似的示例说明了使用这些模型生成逼真的文本是多么简单。 让我们考虑一个示例,其中代理希望在线上生成有关多个主题的虚假新闻。 现在,他们甚至不需要自己编写虚假信息。 从理论上讲,他们可以训练 NLP 模型为他们执行此操作,然后再在 Internet 上散布这些虚假信息。 GPT-2 的作者在训练并将模型发布给公众时特别注意这一点,并指出该模型有可能被滥用和滥用,因此只有在他们看不到证据的情况下才向公众发布更大更复杂的模型。 较小型号的误用。
这可能成为 NLP 深度学习向前发展的重点。 当我们使用可以接近人类复杂程度的聊天机器人和文本生成器(例如 GPT-2)时,需要充分了解对这些模型的使用和误用。 研究表明,GPT-2 生成的文本被认为与《纽约时报》的真实人类书面文章(83%)几乎一样可信(72%)。 随着将来我们继续开发更复杂的深层 NLP 模型,随着模型生成的文本变得越来越现实,这些数字可能会收敛。
这可能成为 NLP 深度学习向前发展的重点。 当我们使用可以接近人类复杂程度的聊天机器人和文本生成器(例如 GPT-2)时,需要充分了解对这些模型的使用和误用。 研究表明,GPT-2 生成的文本被认为与《纽约时报》的真实人类书面文章(83% )几乎一样可信(72% )。 随着将来我们继续开发更复杂的深层 NLP 模型,随着模型生成的文本变得越来越现实,这些数字可能会收敛。
此外,GPT-2 的作者还证明可以对模型进行微调以防滥用。 通过在意识形态极端立场上微调 GPT-2 并生成文本,可以证明可以生成支持这些意识形态的宣传文本。 虽然还显示可以训练反模型来检测这些模型生成的文本,但是随着这些模型变得更加复杂,我们将来可能在这里再次面临进一步的问题。
......
......@@ -4,7 +4,7 @@
本节包含以下章节:
* [“第 5 章”](../Text/5.html#_idTextAnchor092)*递归神经网络和情感分析*
* [“第 5 章”](../Text/5.html#_idTextAnchor092)*循环神经网络和情感分析*
* [“第 6 章”](../Text/6.html#_idTextAnchor112)*卷积神经网络用于文本分类*
* [“第 7 章”](../Text/7.html#_idTextAnchor124)*使用序列到序列神经网络的文本翻译*
* [“第 8 章”](../Text/8.html#_idTextAnchor139)*使用基于注意力的神经网络构建聊天机器人*
......
......@@ -2,7 +2,7 @@
**人工** **智能****AI**)继续流行并破坏了广泛的领域,但这是一个复杂而艰巨的话题。 在本书中,您将掌握构建深度学习应用程序的方法,以及如何使用 PyTorch 进行研究和解决实际问题。
本书从张量处理的基础开始,采用基于配方的方法,然后介绍了**卷积** **神经网络****CNN**)和 PyTorch 中的**递归神经网络****RNN**)。 熟悉这些基本网络后,您将使用深度学习来构建医学图像分类器。 接下来,您将使用 TensorBoard 进行可视化。 您还将深入研究**生成性** **对抗性** **网络****GAN**)和**深度** **增强** **学习****DRL**),然后最终将模型大规模部署到生产中。 您将发现针对机器学习,深度学习和强化学习中常见问题的解决方案。 您将学习如何在计算机视觉,**自然** **语言** **处理****NLP**)中实现 AI 任务并解决实际问题。 其他实际领域。
本书从张量处理的基础开始,采用基于配方的方法,然后介绍了**卷积** **神经网络****CNN**)和 PyTorch 中的**循环神经网络****RNN**)。 熟悉这些基本网络后,您将使用深度学习来构建医学图像分类器。 接下来,您将使用 TensorBoard 进行可视化。 您还将深入研究**生成性** **对抗性** **网络****GAN**)和**深度** **增强** **学习****DRL**),然后最终将模型大规模部署到生产中。 您将发现针对机器学习,深度学习和强化学习中常见问题的解决方案。 您将学习如何在计算机视觉,**自然** **语言** **处理****NLP**)中实现 AI 任务并解决实际问题。 其他实际领域。
到本书结尾,您将拥有使用 PyTorch 框架的 AI 中最重要且应用最广泛的技术的基础。
......@@ -18,7 +18,7 @@
[第 3 章](../Text/3.html)*用于计算机视觉的卷积神经网络*首先介绍了用于更高级任务的一类神经网络,即卷积神经网络。 在这里,我们将与 PyTorch 一起探索 TorchVision,训练 CNN 模型,并使用 TensorBoard 可视化其进度。 我们还将介绍与卷积网络构建块相关的各种任务。 卷积神经网络(CNN 或 ConvNet)是一类 DNN,最常用于分析图像。
[第 4 章](../Text/4.html)*用于 NLP 的递归神经网络*探索递归神经网络,并研究 RNN 中的各种修改以及最佳实践。
[第 4 章](../Text/4.html)*用于 NLP 的循环神经网络*探索循环神经网络,并研究 RNN 中的各种修改以及最佳实践。
[第 5 章](../Text/5.html)*转移学习和 TensorBoard* 显示了如何使用经过训练的 ResNet-50 模型训练图像分类器以区分正常和肺炎的胸部 X 射线。 我们将替换分类器,并使用两个输出单位来代表正常和肺炎类别。
......
......@@ -546,7 +546,7 @@ Training loss: 0.2596
# 这个怎么运作...
在此配方中,我们更改了`__init__()`方法,以 0.25 的丢失率添加了该丢失层,这意味着将应用该丢失的层中 25的神经元将被随机关闭。 然后,我们编辑`forward`函数,将其应用于其中具有 256 个单位的第一个隐藏层,然后对第二个层(具有 128 个单位)应用该滤除。 在完成激活功能之后,我们在两个层中都应用了激活。 我们必须牢记,必须仅在隐藏层上应用辍学,以防止我们丢失输入数据和丢失输出。
在此配方中,我们更改了`__init__()`方法,以 0.25 的丢失率添加了该丢失层,这意味着将应用该丢失的层中 25% 的神经元将被随机关闭。 然后,我们编辑`forward`函数,将其应用于其中具有 256 个单位的第一个隐藏层,然后对第二个层(具有 128 个单位)应用该滤除。 在完成激活功能之后,我们在两个层中都应用了激活。 我们必须牢记,必须仅在隐藏层上应用辍学,以防止我们丢失输入数据和丢失输出。
# 还有更多...
......
......@@ -512,7 +512,7 @@ pip install torchvision==0.x.x
>>from torch.utils.data.sampler import SubsetRandomSampler
```
8. 我们将选择 20的训练数据作为验证数据:
8. 我们将选择 20% 的训练数据作为验证数据:
```py
>>validation_size = 0.2
......@@ -589,9 +589,9 @@ pip install torchvision==0.x.x
但是,我们没有添加垂直翻转,因为我们预计在评估阶段不会有动物的上下颠倒的图像输入到模型中。 之后,我们使用`ToTensor()`变换将图像转换为张量。 准备好张量后,我们使用`Normalize()`变换分别为红色,绿色和蓝色通道中的每一个设置了均值和标准差。 之后,我们在数据集中使用`CIFAR10()`方法来使用 CIFAR10 数据集。 然后,将`download`参数设置为`True`,以便如果根目录`CIFAR10`(第一个参数)中不存在数据集,则将其下载并保存在该目录中。
对于训练数据,我们将`train`参数设置为`True`,并使用`transform`参数传递了要应用于数据的转换。 这使我们能够动态创建图像而无需显式创建新图像。 现在,为了准备测试数据,我们将`train`参数设置为`False`。 我们将训练和测试数据集的大小分别设置为 50,000 和 10,000。 然后,我们使用训练集的 20%(由`validation_size`定义)从训练集准备了验证集。 我们随机选择了 20%的训练集来创建验证集,以使验证集不会偏向特定类别的动物。 然后,我们使用训练集的大小,并使用 Python 中的`range()`准备了索引列表。
对于训练数据,我们将`train`参数设置为`True`,并使用`transform`参数传递了要应用于数据的转换。 这使我们能够动态创建图像而无需显式创建新图像。 现在,为了准备测试数据,我们将`train`参数设置为`False`。 我们将训练和测试数据集的大小分别设置为 50,000 和 10,000。 然后,我们使用训练集的 20% (由`validation_size`定义)从训练集准备了验证集。 我们随机选择了 20% 的训练集来创建验证集,以使验证集不会偏向特定类别的动物。 然后,我们使用训练集的大小,并使用 Python 中的`range()`准备了索引列表。
然后,我们使用`numpy`中的`random.shuffle()`方法对索引列表进行混排。 指标列表随机化后,我们将指标的前 20%移至验证集,将其余 80%的指标移至训练集。 我们通过将原始训练量乘以原始训练集的百分比用作验证集来找到分割索引。 我们使用`split_index`进行拆分。 然后,我们使用`torch.utils.data`中的`SubsetRandomSampler()`方法从给定的索引列表中随机抽取元素,而不进行替换。 最后,我们使用`DataLoader()`组合了数据集和采样器,以对数据集进行迭代。 然后,我们将数据加载器用于训练,验证和测试集,以在训练模型时对数据进行迭代。
然后,我们使用`numpy`中的`random.shuffle()`方法对索引列表进行混排。 指标列表随机化后,我们将指标的前 20% 移至验证集,将其余 80% 的指标移至训练集。 我们通过将原始训练量乘以原始训练集的百分比用作验证集来找到分割索引。 我们使用`split_index`进行拆分。 然后,我们使用`torch.utils.data`中的`SubsetRandomSampler()`方法从给定的索引列表中随机抽取元素,而不进行替换。 最后,我们使用`DataLoader()`组合了数据集和采样器,以对数据集进行迭代。 然后,我们将数据加载器用于训练,验证和测试集,以在训练模型时对数据进行迭代。
# 还有更多...
......
# 用于 NLP 的递归神经网络
# 用于 NLP 的循环神经网络
在本章中,我们将处理**递归神经网络****RNNs**),这是一种专门处理顺序数据或时变数据的神经网络。 利用卷积神经网络,我们处理在空间上彼此相关的数据点,其中一组像素值保存有关图像的信息。 但是请考虑一下节奏,节奏是由一段时间内一系列变化的声音信号形成的。 数据点彼此之间具有时间关系。 在递归神经网络中,神经元之间的连接在时间序列上形成有向图,表现出时间动态行为。 传统的前馈网络不存储先前的输入; 但是,RNN 使用存储单元来记住先前的输入,因此根据到目前为止的输入顺序来处理当前输入。
在本章中,我们将处理**循环神经网络****RNNs**),这是一种专门处理顺序数据或时变数据的神经网络。 利用卷积神经网络,我们处理在空间上彼此相关的数据点,其中一组像素值保存有关图像的信息。 但是请考虑一下节奏,节奏是由一段时间内一系列变化的声音信号形成的。 数据点彼此之间具有时间关系。 在循环神经网络中,神经元之间的连接在时间序列上形成有向图,表现出时间动态行为。 传统的前馈网络不存储先前的输入; 但是,RNN 使用存储单元来记住先前的输入,因此根据到目前为止的输入顺序来处理当前输入。
在本章中,我们将介绍以下食谱:
......@@ -19,7 +19,7 @@
![](img/616ddb15-b5e8-4d9f-b8fb-e5147173866f.png)
图 1:递归神经网络
图 1:循环神经网络
在上图中,我们可以看到 RNN 中的输入,输出和循环本身。 RNN 是为信息的持久性而设计的,而循环组件则可以实现这一点。
......@@ -29,9 +29,9 @@
图 2:RNN 的展开图
在上图中,我们可以看到 RNN 的展开图,其中一个步骤的信息被馈送到下一个步骤,从而创建同一网络的多个副本,所有这些信息都封装在循环循环中。 递归神经网络接受输入并给出输出,但是该输出不仅取决于给定实例上的输入,还取决于提供给网络的输入的整个历史,网络会在数学上记住这些输入。
在上图中,我们可以看到 RNN 的展开图,其中一个步骤的信息被馈送到下一个步骤,从而创建同一网络的多个副本,所有这些信息都封装在循环循环中。 循环神经网络接受输入并给出输出,但是该输出不仅取决于给定实例上的输入,还取决于提供给网络的输入的整个历史,网络会在数学上记住这些输入。
递归神经网络能够接收可变大小的输入序列并产生可变大小的输出序列,从而执行与完全连接的神经网络中固定数量的计算相反的可变数量的计算。 进一步的 RNN 允许信息持久化,并在接收到的输入之间共享该信息。 在给定实例上生成的输出基于到目前为止所看到的所有输入的历史记录。
循环神经网络能够接收可变大小的输入序列并产生可变大小的输出序列,从而执行与完全连接的神经网络中固定数量的计算相反的可变数量的计算。 进一步的 RNN 允许信息持久化,并在接收到的输入之间共享该信息。 在给定实例上生成的输出基于到目前为止所看到的所有输入的历史记录。
这是 LSTM 的示意图:
......@@ -39,7 +39,7 @@
图 3:LSTM
**长短期记忆****LSTM**)网络是一种递归神经网络,是 RNN 之上的一种进步。
**长短期记忆****LSTM**)网络是一种循环神经网络,是 RNN 之上的一种进步。
这是双向 LSTM:
......@@ -371,7 +371,7 @@ TorchText 具有用于处理嵌入的`vocab`模块。 我们可以通过在此
# 建立 LSTM 网络
**长短期记忆****LSTM**)网络是一种递归神经网络,具有内部门控,有助于更好地保持信息。 这些门是微小的神经网络,用于控制何时需要保存信息以及何时可以擦除或忘记信息。 RNN 受梯度消失和爆炸的影响,因此很难学习长期依赖关系。 LSTM 可以抵抗爆炸和消失的梯度,尽管在数学上仍然可行。
**长短期记忆****LSTM**)网络是一种循环神经网络,具有内部门控,有助于更好地保持信息。 这些门是微小的神经网络,用于控制何时需要保存信息以及何时可以擦除或忘记信息。 RNN 受梯度消失和爆炸的影响,因此很难学习长期依赖关系。 LSTM 可以抵抗爆炸和消失的梯度,尽管在数学上仍然可行。
# 怎么做...
......@@ -466,7 +466,7 @@ return self.fc(hidden)
我们使用`torch.nn`模块创建了从`torch.nn.Module`继承的模型类`LSTMClassifier`,并初始化了基类构造函数。 然后,我们定义嵌入层,其中输入维与词汇量大小相同,输出为嵌入维,然后将嵌入层输出传递到 LSTM 层,其中输入维为嵌入维,然后 定义隐藏状态维度。
然后,我们定义了完全连接的层和退出层。 接下来,我们定义`forward()`方法,该方法接受输入序列,并将其传递给嵌入层,从而产生尺寸为`embedding_dim`的输出,该输出是输入序列的嵌入向量。 然后将这个字向量传递到 LSTM 层,该层输出三个状态-输出状态,隐藏状态和单元状态。
然后,我们定义了完全连接的层和丢弃层。 接下来,我们定义`forward()`方法,该方法接受输入序列,并将其传递给嵌入层,从而产生尺寸为`embedding_dim`的输出,该输出是输入序列的嵌入向量。 然后将这个字向量传递到 LSTM 层,该层输出三个状态-输出状态,隐藏状态和单元状态。
隐藏状态张量保存了到目前为止 LSTM 所见过的所有序列的信息,因此我们采用了隐藏状态,应用了`dropout`,并将其通过完全连接层传递给最终输出向量,其大小等于 类数。 例如,对于有毒评论数据集,输出类别的数量为六; 但是,对于具有两个状态(正向和负向)的情感分析器,我们甚至可以考虑只具有一个输出,以便`1`代表积极情感,`0`代表消极情感。
......
......@@ -18,7 +18,7 @@ GAN 中的两个模型称为生成器和鉴别器,其中生成器负责创建
在此图中,有一个数据源,其中包含训练图像`x`,生成器必须捕获其属性并重新创建。 生成器接收随机向量`z`,该向量充当生成器创建伪图像的种子。 生成器获取种子并生成 *x <sup>*</sup>* 图像,鉴别器从真实和虚假图像中获取图像,并输出给定​​输入为真实的概率(假设 图像用 1 表示,伪图像用 0 表示)。 然后,我们获得分类误差,并使用它来迭代训练鉴别器和生成器。 鉴别器的目的是使分类误差最小,而发生器的目的是使分类误差最大化。
从理论上讲,生成器和判别器达到平衡,其中生成器已捕获了生成的伪图像中真实图像的所有特征,而从进一步的训练中没有任何收获。 类似地,鉴别者只能以 50的概率猜测图像是伪造的还是真实的,因为这两个图像就其性质而言完全无法区分。 在那个状态下,GAN 已经收敛。 然而,实际上,这种状态很难实现。 在本章中,我们将探讨 GAN 的概念以及 PyTorch 中各种 GAN 的实现。
从理论上讲,生成器和判别器达到平衡,其中生成器已捕获了生成的伪图像中真实图像的所有特征,而从进一步的训练中没有任何收获。 类似地,鉴别者只能以 50% 的概率猜测图像是伪造的还是真实的,因为这两个图像就其性质而言完全无法区分。 在那个状态下,GAN 已经收敛。 然而,实际上,这种状态很难实现。 在本章中,我们将探讨 GAN 的概念以及 PyTorch 中各种 GAN 的实现。
在本章中,我们将介绍以下食谱:
......
......@@ -885,7 +885,7 @@ Rewards: 350.0
# 这个怎么运作...
在此配方中,我们改进了深度遗传算法。 根据论文*深神经进化:我们将超参数设置为*,将`MUTATION_POWER`设置为`0.02`。遗传算法是用于训练深度神经网络以进行强化学习*的一种竞争选择。 我们不需要使用 PyTorch 来进行梯度计算,因为我们不需要依靠梯度下降来改善模型和创建环境。*
在此配方中,我们改进了深度遗传算法。 根据论文*深神经进化:我们将超参数设置为*,将`MUTATION_POWER`设置为`0.02`。遗传算法是用于训练深度神经网络以进行强化学习*的一种竞争选择。 我们不需要使用 PyTorch 来进行梯度计算,因为我们不需要依靠梯度下降来改善模型和创建环境。*
然后,我们创建了一些代理,以开始我们的进化,并通过遍历`generations`将它们运行了预定的代数,在其中我们获得了每一代所有代理的奖励。 然后,我们选择了得分最高的父母,并通过`child_agent`函数传递这些父母指数以获得下一代。 之后,我们打印出前 5 个得分的平均值。
......
......@@ -16,7 +16,7 @@
[第 4 章](../Text/4.html "Chapter 4\. Computer Vision")*计算机视觉*是迄今为止深度学习最成功的结果,它讨论了成功背后的关键思想,并贯穿了使用最广泛的视觉算法– **卷积神经网络(CNN)**。 我们将逐步实现 CNN 以了解其工作原理,然后使用 PyTorch 的 nn 包中预定义的 CNN。 本章可帮助您制作简单的 CNN 和基于高级 CNN 的视觉算法,称为语义分割。
[第 5 章](../Text/5.html "Chapter 5\. Sequential Data Processing")*顺序数据处理*着眼于递归神经网络,它是目前最成功的顺序数据处理算法。 本章向您介绍主要的 RNN 组件,例如**长短期内存****LSTM**)网络和**门控循环单元****GRU**)。 然后,在探索递归神经网络之前,我们将经历 RNN 实现中的算法更改,例如双向 RNN,并增加层数。 为了理解递归网络,我们将使用斯坦福大学 NLP 小组的著名示例(堆栈增强的解析器-解释器神经网络(SPINN)),并将其在 PyTorch 中实现。
[第 5 章](../Text/5.html "Chapter 5\. Sequential Data Processing")*顺序数据处理*着眼于循环神经网络,它是目前最成功的顺序数据处理算法。 本章向您介绍主要的 RNN 组件,例如**长短期内存****LSTM**)网络和**门控循环单元****GRU**)。 然后,在探索循环神经网络之前,我们将经历 RNN 实现中的算法更改,例如双向 RNN,并增加层数。 为了理解递归网络,我们将使用斯坦福大学 NLP 小组的著名示例(堆栈增强的解析器-解释器神经网络(SPINN)),并将其在 PyTorch 中实现。
[第 6 章](../Text/6.html "Chapter 6\. Generative Networks")*生成网络,*简要讨论了生成网络的历史,然后解释了各种生成网络。 在这些不同的类别中,本章向我们介绍了自回归模型和 GAN。 我们将研究作为自动回归模型一部分的 PixelCNN 和 WaveNet 的实现细节,然后详细研究 GAN。
......
......@@ -167,7 +167,7 @@ with tf.Session() as sess:
势在必行的编程风格始终拥有较大的用户群,因为程序流程对于任何开发人员都是直观的。 动态能力是命令式图形构建的良好副作用。 与静态图不同,动态图体系结构不会在数据传递之前构建图。 程序将等待数据到达并在遍历数据时构建图形。 结果,每次数据迭代都会构建一个新的图实例,并在完成向后传递后销毁它。 由于图形是为每次迭代构建的,因此它不依赖于数据大小,长度或结构。 自然语言处理是需要这种方法的领域之一。
例如,如果您试图对成千上万的句子进行情感分析,则需要使用静态图形来破解并采取变通办法。 在普通的**递归神经网络****RNN**)模型中,每个单词都经过一个 RNN 单元,该单元生成输出和隐藏状态。 该隐藏状态将提供给下一个 RNN,后者处理句子中的下一个单词。 由于您在构建静态图形时做了一个固定长度的插槽,因此您需要增加短句并减少长句。
例如,如果您试图对成千上万的句子进行情感分析,则需要使用静态图形来破解并采取变通办法。 在普通的**循环神经网络****RNN**)模型中,每个单词都经过一个 RNN 单元,该单元生成输出和隐藏状态。 该隐藏状态将提供给下一个 RNN,后者处理句子中的下一个单词。 由于您在构建静态图形时做了一个固定长度的插槽,因此您需要增加短句并减少长句。
![Using dynamic graphs](img/B09475_01_06.jpg)
......@@ -198,7 +198,7 @@ for epoch in range(epochs):
在 PyTorch 代码中,输入变量定义未创建占位符。 而是将变量对象包装到您的输入上。 图形定义不会执行一次; 相反,它在循环内,并且每次迭代都在构建图形。 您在每个图实例之间共享的唯一信息是您要优化的权重矩阵。
在这种方法中,如果您在遍历数据时改变了数据大小或形状,则在图形中运行新形状的数据绝对好,因为新创建的图形可以接受新形状。 可能性不止于此。 如果要动态更改图形的行为,也可以这样做。 在[第 5 章](../Text/5.html "Chapter 5\. Sequential Data Processing")*顺序数据处理,*中的递归神经网络会话中给出的示例均基于此思想。
在这种方法中,如果您在遍历数据时改变了数据大小或形状,则在图形中运行新形状的数据绝对好,因为新创建的图形可以接受新形状。 可能性不止于此。 如果要动态更改图形的行为,也可以这样做。 在[第 5 章](../Text/5.html "Chapter 5\. Sequential Data Processing")*顺序数据处理,*中的循环神经网络会话中给出的示例均基于此思想。
## 探索深度学习
......@@ -262,7 +262,7 @@ for epoch in range(epochs):
图 1.12:自动编码器的结构
#### 递归神经网络
#### 循环神经网络
RNN 是最常见的深度学习算法之一,它们席卷全球。 我们现在在自然语言处理或理解中几乎拥有所有最先进的性能,这是由于 RNN 的变体。 在循环网络中,您尝试识别数据中的最小单位,并使数据成为这些单位的组。 在自然语言的示例中,最常见的方法是使一个单词成为一个单元,并在处理该句子时将其视为一组单词。 您展开整个句子的 RNN,然后一次处理一个单词。 RNN 具有适用于不同数据集的变体,有时,选择变体时可以考虑效率。 长**短期记忆****LSTM**)和**门控循环单元****GRU**)细胞是最常见的 RNN 单元。
......@@ -270,11 +270,11 @@ RNN 是最常见的深度学习算法之一,它们席卷全球。 我们现在
图 1.13:循环网络中单词的向量表示
#### 递归神经网络
#### 循环神经网络
顾名思义,递归神经网络是树状网络,用于了解序列数据的层次结构。 递归网络已在**自然语言处理**应用程序中大量使用,尤其是 Salesforce 首席科学家 Richard Socher 及其团队。
顾名思义,循环神经网络是树状网络,用于了解序列数据的层次结构。 递归网络已在**自然语言处理**应用程序中大量使用,尤其是 Salesforce 首席科学家 Richard Socher 及其团队。
词向量,我们将在[第 5 章](../Text/5.html "Chapter 5\. Sequential Data Processing")*顺序数据处理*中很快看到,它们能够将词的含义有效地映射到向量空间中,但是涉及到含义 在整个句子中,没有像 word2vec 这样的单词适合的解决方案。 递归神经网络是此类应用最常用的算法之一。 递归网络可以创建一个解析树和组成向量,并映射其他层次关系,这反过来又帮助我们找到了结合单词和句子的规则。 **斯坦福自然语言推断**小组发现了一种著名的且使用良好的算法,称为 **SNLI** ,这是递归网络使用的一个很好的例子。
词向量,我们将在[第 5 章](../Text/5.html "Chapter 5\. Sequential Data Processing")*顺序数据处理*中很快看到,它们能够将词的含义有效地映射到向量空间中,但是涉及到含义 在整个句子中,没有像 word2vec 这样的单词适合的解决方案。 循环神经网络是此类应用最常用的算法之一。 递归网络可以创建一个解析树和组成向量,并映射其他层次关系,这反过来又帮助我们找到了结合单词和句子的规则。 **斯坦福自然语言推断**小组发现了一种著名的且使用良好的算法,称为 **SNLI** ,这是递归网络使用的一个很好的例子。
![Recursive neural networks](img/B09475_01_14.jpg)
......
......@@ -22,7 +22,7 @@
建立数据管道与网络的体系结构一样重要,尤其是在实时训练网络时。 从野外获得的数据永远不会干净,在将其扔到网络之前,您必须对其进行处理。 例如,如果我们要收集数据以预测某人是否购买产品,那么最终将出现异常值。 离群值可以是任何种类且不可预测的。 例如,某人可能不小心下了订单,或者他们可以访问后来下订单的朋友,依此类推。
从理论上讲,深神经网络非常适合从数据集中查找模式和解,因为它们应该模仿人的大脑。 但是,实际上,情况并非总是如此。 如果您的数据干净且格式正确,您的网络将能够通过找到模式来轻松解决问题。 PyTorch 开箱即用地提供了数据预处理包装器,我们将在[第 3 章](../Text/3.html "Chapter 3\. Deep Learning Workflow")*深度学习工作流程*中进行讨论。 除此之外,我们将讨论如何格式化或清除数据集。
从理论上讲,深神经网络非常适合从数据集中查找模式和解,因为它们应该模仿人的大脑。 但是,实际上,情况并非总是如此。 如果您的数据干净且格式正确,您的网络将能够通过找到模式来轻松解决问题。 PyTorch 开箱即用地提供了数据预处理包装器,我们将在[第 3 章](../Text/3.html "Chapter 3\. Deep Learning Workflow")*深度学习工作流程*中进行讨论。 除此之外,我们将讨论如何格式化或清除数据集。
为简单起见,我们将使用一些简单的函数来生成数据。 让我们开始为 *FizzBu​​zz* 模型构建简单的数据集。 当我们的模型得到一个数字时,它应该预测下一个输出,就好像是在玩游戏的人一样。 例如,如果输入为三,则模型应预测下一个数字为四。 如果输入为八,则模型应显示“嘶嘶声”,因为九可以被三整除。
......
......@@ -573,7 +573,7 @@ class SegmentationModel(nn.Module):
在本章中,我们已经介绍了 CNN,这是迄今为止计算机视觉取得所有成功的关键。 CNN 的许多体系结构变体已用于不同目的,但是所有这些实现的核心是 CNN 的基本构建块。 关于 CNN 的技术局限性,已经进行了大量研究,尤其是从人类视觉仿真的角度。 已经证明,CNN 不能完全模拟人类视觉系统的工作方式。 这使许多研究小组认为应该有替代方案。 替代 CNN 的一种最流行的方法是使用胶囊网络,这也是杰弗里·欣顿实验室的成果。 但是现在,CNN 正在作为成千上万的实时和关键计算机视觉应用程序的核心。
在下一章中,我们将研究另一种基本的网络架构:递归神经网络。
在下一章中,我们将研究另一种基本的网络架构:循环神经网络。
### 参考
......
......@@ -4,9 +4,9 @@
在本章中,我们将研究顺序数据。 人们用于顺序数据处理的规范数据是自然语言,尽管时间序列数据,音乐,声音和其他数据也被视为顺序数据。 **自然语言处理****NLP**)和理解已被广泛探索,并且它是当前活跃的研究领域。 人类的语言异常复杂,我们整个词汇的可能组合超过了宇宙中原子的数量。 但是,深层网络通过使用诸如嵌入和注意之类的某些技术可以很好地处理此问题。
## 递归神经网络简介
## 循环神经网络简介
**递归神经网络****RNN**)是顺序数据处理的实际实现。 顾名思义,RNN 重新遍历上一次运行中保存的信息的数据,并试图像人类一样找到序列的含义。
**循环神经网络****RNN**)是顺序数据处理的实际实现。 顾名思义,RNN 重新遍历上一次运行中保存的信息的数据,并试图像人类一样找到序列的含义。
尽管原始 RNN(在输入中为每个单元展开一个简单的 RNN 单元)是一个革命性的想法,但未能提供可用于生产的结果。 主要障碍是长期依赖问题。 当输入序列的长度增加时,网络到达最后一个单元时将无法从初始单位(单词,如果是自然语言)中记住信息。 我们将在接下来的部分中看到 RNN 单元包含的内容以及如何将其展开。
......@@ -18,7 +18,7 @@
数据处理是序列数据(尤其是自然语言)的主要挑战之一。 PyTorch 提供了一些实用程序包来处理该问题。 我们将使用预处理后的数据来简化实施,但是我们将遍历实用程序包以了解它们的工作原理。 与这些实用程序包一起,我们将使用`torchtext`,它消除了处理输入数据时将面临的许多困难。
尽管本章全都是关于顺序数据的,但我们将专注于顺序数据的一个子集,这是自然语言。 特定于自然语言的一些研究人员认为,我们使用 LSTM 或 GRU 处理输入的方式不是应该如何处理自然语言。 自然语言在单词之间保持树状的层次关系,我们应该加以利用。 **堆栈增强型解析器-解释器神经网络****SPINN**)[2]是来自 Stanford NLP 组的一种此类实现。 这种处理树状结构序列数据的特殊类型的网络是*递归神经网络*(与递归神经网络不同)。 在本章的最后一部分中,我们将详细介绍 SPINN。
尽管本章全都是关于顺序数据的,但我们将专注于顺序数据的一个子集,这是自然语言。 特定于自然语言的一些研究人员认为,我们使用 LSTM 或 GRU 处理输入的方式不是应该如何处理自然语言。 自然语言在单词之间保持树状的层次关系,我们应该加以利用。 **堆栈增强型解析器-解释器神经网络****SPINN**)[2]是来自 Stanford NLP 组的一种此类实现。 这种处理树状结构序列数据的特殊类型的网络是*循环神经网络*(与循环神经网络不同)。 在本章的最后一部分中,我们将详细介绍 SPINN。
## 问题
......@@ -291,7 +291,7 @@ class Merger(nn.Module):
```
在这里,`Merger`节点被构建为模拟 SPINN 的实际实现。 `Merger``forward`功能获得两个序列:`prem``hypo`。 我们首先通过正常减法确定两个句子之间的差异,然后通过逐元素相乘找到它们之间的乘积。 然后,我们将实际句子与差异和刚刚找到的乘积连接起来,然后将它们传递给批处理规范化层和退出层。
在这里,`Merger`节点被构建为模拟 SPINN 的实际实现。 `Merger``forward`功能获得两个序列:`prem``hypo`。 我们首先通过正常减法确定两个句子之间的差异,然后通过逐元素相乘找到它们之间的乘积。 然后,我们将实际句子与差异和刚刚找到的乘积连接起来,然后将它们传递给批处理规范化层和丢弃层。
`Merger`节点也是我们的简单 RNN 的最终分类器层的一部分,该分类器由其他几个节点组成。
......@@ -339,7 +339,7 @@ class RNNClassifier(nn.Module):
图 5.5:辍学
PyTorch 作为`torch.nn`程序包的一部分提供了更高级别的退出层,该层在初始化时接受退出因子。 它的`forward`功能只是关闭一些输入。
PyTorch 作为`torch.nn`程序包的一部分提供了更高级别的丢弃层,该层在初始化时接受退出因子。 它的`forward`功能只是关闭一些输入。
#### 培训
......@@ -479,9 +479,9 @@ RNN 实现通常是单向的,这就是到目前为止我们已经实现的。
实际上,*就是您所需要的全部* [5]是该论文的作者仅通过关注并删除所有其他复杂的网络体系结构(如 LSTM)就能够获得 SOTA 结果的方法。
### 递归神经网络
### 循环神经网络
语言研究人员的一部分永远不会认可 RNN 的工作方式,即从左到右依次进行,尽管那是多少人阅读一个句子。 某些人坚信语言具有层次结构,利用这种结构有助于我们轻松解决 NLP 问题。 递归神经网络是使用该方法解决 NLP 的尝试,其中,基于要处理的语言的短语,将序列安排为树。 SNLI 是为此目的而创建的数据集,其中每个句子都排列成一棵树。
语言研究人员的一部分永远不会认可 RNN 的工作方式,即从左到右依次进行,尽管那是多少人阅读一个句子。 某些人坚信语言具有层次结构,利用这种结构有助于我们轻松解决 NLP 问题。 循环神经网络是使用该方法解决 NLP 的尝试,其中,基于要处理的语言的短语,将序列安排为树。 SNLI 是为此目的而创建的数据集,其中每个句子都排列成一棵树。
我们正在尝试构建的特定递归网络是 SPINN,它是通过充分考虑这两个方面的优点而制成的。 SPINN 从左到右处理数据,就像人类的阅读方式一样,但仍保持层次结构完整。 从左向右读取的方法相对于按层次进行解析还有另一个优势:网络从左向右读取时可以最终学习生成解析树。 这可以通过使用称为移位减少解析器的特殊实现以及堆栈和缓冲区数据结构的使用来实现。
......
......@@ -98,9 +98,9 @@ MDP 定义有五件事:
图 7.3:垃圾收集机器人的 MDP
例如,假设机器人处于高电量状态。 如果决定搜索垃圾桶,则状态保持高状态的概率为 70%,状态变为低状态的概率为 30%,每种状态获得的奖励为 4。
例如,假设机器人处于高电量状态。 如果决定搜索垃圾桶,则状态保持高状态的概率为 70%,状态变为低状态的概率为 30%,每种状态获得的奖励为 4。
同样,如果电池处于高电量状态,则决定在其当前位置等待,电池处于高电量状态的可能性为 100,但是获得的奖励也很低。
同样,如果电池处于高电量状态,则决定在其当前位置等待,电池处于高电量状态的可能性为 100%,但是获得的奖励也很低。
花一点时间浏览所有动作和状态,以更好地了解它们。 通过详细说明代理可以处于的所有状态以及代理在其所有状态下可以执行的所有操作,并确定每个操作的概率,可以指定环境。 一旦指定了所有这些,就可以指定环境的一站式动态。
......
......@@ -6,7 +6,7 @@ PyTorch 以其干净的框架而闻名,因此要获得研究所需的生产能
解决此问题的第一步是使**开放式神经网络交换****ONNX**)格式稳定,并与所有流行的框架兼容(至少与具有良好功能的框架兼容) 模块)。 ONNX 定义了深度学习图所需的基本运算符和标准数据类型。 这引导了 ONNX 进入 PyTorch 核心的道路,并且它与 ONNX 转换器一起为流行的深度学习框架(例如 CNTK,MXNet,TensorFlow 等)构建。
ONNX 很棒,并且每个人都喜欢它,但是 ONNX 的主要缺点之一是其脚本模式。 也就是说,ONNX 运行一次图形以获取有关图形的信息,然后将其转换为 ONNX 格式。 因此,ONNX 无法迁移模型中的控制流(将`for`循环用于递归神经网络(RNN)模型的不同序列长度)。
ONNX 很棒,并且每个人都喜欢它,但是 ONNX 的主要缺点之一是其脚本模式。 也就是说,ONNX 运行一次图形以获取有关图形的信息,然后将其转换为 ONNX 格式。 因此,ONNX 无法迁移模型中的控制流(将`for`循环用于循环神经网络(RNN)模型的不同序列长度)。
生产 PyTorch 的第二种方法是在 PyTorch 本身中构建高性能后端。 Caffe2 的核心与 PyTorch 核心合并在一起,而不是从头开始构建一个,但 Python API 保持不变。 但是,这并不能解决 Python 语言所具有的问题。
......@@ -156,7 +156,7 @@ Flask 为我们提供了`request`实用程序,它是一个全局变量,但
接下来是使用`run()`方法的`controller`文件。 在这里,我们将输入数字转换为 10 位二进制数(请记住,这是我们作为输入传递给[第 2 章](../Text/2.html "Chapter 2\. A Simple Neural Network")*简单神经网络*的 fizzbuzz 网络)的函数 火炬张量。 然后将二进制张量传递给我们模型的正向函数,以得到具有预测的 1 x 4 张量。
通过从加载了保存的`.pth`文件的模型文件中调用`FizBuz`类来创建我们的模型。 我们使用 Torch 的`load_state_dict`方法将参数加载到初始化的模型中。 之后,我们将模型转换为`eval()`模式,这将模型设置为评估模式(它在评估模式下关闭了 batchnorm 退出层)。 模型的输出是运行`max`并确定哪个索引具有最大值,然后将其转换为可读输出的概率分布。
通过从加载了保存的`.pth`文件的模型文件中调用`FizBuz`类来创建我们的模型。 我们使用 Torch 的`load_state_dict`方法将参数加载到初始化的模型中。 之后,我们将模型转换为`eval()`模式,这将模型设置为评估模式(它在评估模式下关闭了 batchnorm 丢弃层)。 模型的输出是运行`max`并确定哪个索引具有最大值,然后将其转换为可读输出的概率分布。
#### 准备生产的服务器
......
......@@ -306,7 +306,7 @@ Accuracy of the network on the 10000 test images: 53 %
```
看起来比偶然更好,准确率是 10(从 10 个班级中随机选择一个班级)。 好像网络学到了一些东西。
看起来比偶然更好,准确率是 10% (从 10 个班级中随机选择一个班级)。 好像网络学到了一些东西。
嗯,哪些类的表现良好,哪些类的表现不佳:
......
......@@ -341,7 +341,7 @@ for i in range(len(classes)):
```
现在,您将看到一个“ PR Curves”选项卡,其中包含每个类别的精确调用曲线。 继续四处戳; 您会发现在某些类别中,模型的“曲线下面积”接近 100,而在另一些类别中,该面积更低:
现在,您将看到一个“ PR Curves”选项卡,其中包含每个类别的精确调用曲线。 继续四处戳; 您会发现在某些类别中,模型的“曲线下面积”接近 100%,而在另一些类别中,该面积更低:
![intermediate/../../_static/img/tensorboard_pr_curves.png](img/d15de2be2b754f9a4f46418764232b5e.png)
......
......@@ -244,7 +244,7 @@ Epsilon: 0.3 Test Accuracy = 869 / 10000 = 0.0869
### 准确性与 Epsilon](docs / modern-java-zh /
第一个结果是精度与ε曲线的关系。 如前所述,随着ε的增加,我们预计测试精度会降低。 这是因为更大的ε意味着我们朝着将损失最大化的方向迈出了更大的一步。 请注意,即使 epsilon 值是线性间隔的,曲线中的趋势也不是线性的。 例如,\(\ epsilon = 0.05 \)处的精度仅比\(\ epsilon = 0 \)低约 4,但\(\ epsilon = 0.2 \)处的精度比\(\ epsilon = 0.15 \)。 另外,请注意,模型的准确性在\(\ epsilon = 0.25 \)和\(\ epsilon = 0.3 \)之间达到 10 类分类器的随机准确性。
第一个结果是精度与ε曲线的关系。 如前所述,随着ε的增加,我们预计测试精度会降低。 这是因为更大的ε意味着我们朝着将损失最大化的方向迈出了更大的一步。 请注意,即使 epsilon 值是线性间隔的,曲线中的趋势也不是线性的。 例如,\(\ epsilon = 0.05 \)处的精度仅比\(\ epsilon = 0 \)低约 4%,但\(\ epsilon = 0.2 \)处的精度比\(\ epsilon = 0.15 \)。 另外,请注意,模型的准确性在\(\ epsilon = 0.25 \)和\(\ epsilon = 0.3 \)之间达到 10 类分类器的随机准确性。
```py
plt.figure(figsize=(5,5))
......
......@@ -12,7 +12,7 @@
### 什么是 GAN?](docs / modern-java-zh /
GAN 是用于教授 DL 模型以捕获培训数据分布的框架,因此我们可以从同一分布中生成新数据。 GAN 由 Ian Goodfellow 于 2014 年发明,并在论文[生成对抗网络](https://papers.nips.cc/paper/5423-generative-adversarial-nets.pdf)中首次进行了描述。 它们由两个不同的模型组成:*生成器**鉴别器*。 生成器的工作是生成看起来像训练图像的“假”图像。 鉴别器的工作是查看图像并从生成器输出它是真实的训练图像还是伪图像。 在训练过程中,生成器不断尝试通过生成越来越好的伪造品而使鉴别器的性能超过智者,而鉴别器正在努力成为更好的侦探并正确地对真实和伪造图像进行分类。 博弈的平衡点是当生成器生成的伪造品看起来像直接来自训练数据时,而鉴别器则总是猜测生成器输出是真实还是伪造品的 50置信度。
GAN 是用于教授 DL 模型以捕获培训数据分布的框架,因此我们可以从同一分布中生成新数据。 GAN 由 Ian Goodfellow 于 2014 年发明,并在论文[生成对抗网络](https://papers.nips.cc/paper/5423-generative-adversarial-nets.pdf)中首次进行了描述。 它们由两个不同的模型组成:*生成器**鉴别器*。 生成器的工作是生成看起来像训练图像的“假”图像。 鉴别器的工作是查看图像并从生成器输出它是真实的训练图像还是伪图像。 在训练过程中,生成器不断尝试通过生成越来越好的伪造品而使鉴别器的性能超过智者,而鉴别器正在努力成为更好的侦探并正确地对真实和伪造图像进行分类。 博弈的平衡点是当生成器生成的伪造品看起来像直接来自训练数据时,而鉴别器则总是猜测生成器输出是真实还是伪造品的 50% 置信度。
现在,让我们从鉴别符开始定义一些在整个教程中使用的符号。 令\(x \)为代表图像的数据。 \(D(x)\)是鉴别器网络,其输出\(x \)来自训练数据而不是生成器的(标量)概率。 在这里,由于我们要处理图像,因此\(D(x)\)的输入是 CHW 大小为 3x64x64 的图像。 直观地,当\(x \)来自训练数据时,\(D(x)\)应该为高,而当\(x \)来自发生器时,它应该为低。 \(D(x)\)也可以被认为是传统的二进制分类器。
......
......@@ -302,7 +302,7 @@ def train(model, epoch, log_interval):
```
现在我们有了训练功能,我们需要制作一个用于测试网络准确性的功能。 我们将模型设置为`eval()`模式,然后对测试数据集进行推断。 调用`eval()`将网络中所有模块中的训练变量设置为 false。 某些层(例如批处理归一化层和退出层)在训练期间的行为会有所不同,因此此步骤对于获取正确的结果至关重要。
现在我们有了训练功能,我们需要制作一个用于测试网络准确性的功能。 我们将模型设置为`eval()`模式,然后对测试数据集进行推断。 调用`eval()`将网络中所有模块中的训练变量设置为 false。 某些层(例如批处理归一化层和丢弃层)在训练期间的行为会有所不同,因此此步骤对于获取正确的结果至关重要。
```py
def number_of_correct(pred, target):
......@@ -358,7 +358,7 @@ with tqdm(total=n_epoch) as pbar:
```
2 个纪元后,测试集的网络准确度应超过 65%,而 21 个纪元后,网络应达到 85%。 让我们看一下训练集中的最后几句话,看看模型是如何做到的。
2 个纪元后,测试集的网络准确度应超过 65%,而 21 个纪元后,网络应达到 85%。 让我们看一下训练集中的最后几句话,看看模型是如何做到的。
```py
def predict(tensor):
......
......@@ -164,7 +164,7 @@ torch.Size([5, 1, 57])
## 创建网络](docs / modern-java-zh /
在进行自动分级之前,在 Torch 中创建一个递归神经网络涉及在多个时间步长上克隆图层的参数。 图层保留了隐藏状态和渐变,这些图层现在完全由图形本身处理。 这意味着您可以非常“纯”的方式将 RNN 用作常规前馈层。
在进行自动分级之前,在 Torch 中创建一个循环神经网络涉及在多个时间步长上克隆图层的参数。 图层保留了隐藏状态和渐变,这些图层现在完全由图形本身处理。 这意味着您可以非常“纯”的方式将 RNN 用作常规前馈层。
该 RNN 模块(主要从 PyTorch for Torch 用户教程的[复制)只有两个线性层,它们在输入和隐藏状态下运行,在输出之后是 LogSoftmax 层。](https://pytorch.org/tutorials/beginner/former_torchies/nn_tutorial.html#example-2-recurrent-net)
......
......@@ -31,7 +31,7 @@
……取得不同程度的成功。
通过[序列到序列网络](https://arxiv.org/abs/1409.3215)的简单但强大的构想,使这成为可能,其中两个递归神经网络协同工作,将一个序列转换为另一个序列。 编码器网络将输入序列压缩为一个向量,而解码器网络将该向量展开为一个新序列。
通过[序列到序列网络](https://arxiv.org/abs/1409.3215)的简单但强大的构想,使这成为可能,其中两个循环神经网络协同工作,将一个序列转换为另一个序列。 编码器网络将输入序列压缩为一个向量,而解码器网络将该向量展开为一个新序列。
![](img/b01274082109b1019682274a0d4ca4d8.png)
......@@ -244,7 +244,7 @@ eng 2803
## Seq2Seq 模型](docs / modern-java-zh /
递归神经网络(RNN)是在序列上运行并将其自身的输出用作后续步骤的输入的网络。
循环神经网络(RNN)是在序列上运行并将其自身的输出用作后续步骤的输入的网络。
[序列到序列网络](https://arxiv.org/abs/1409.3215)或 seq2seq 网络或[编码器解码器网络](https://arxiv.org/pdf/1406.1078v3.pdf)是由两个称为编码器和解码器的 RNN 组成的模型。 编码器读取输入序列并输出单个向量,而解码器读取该向量以产生输出序列。
......@@ -462,7 +462,7 @@ def train(input_tensor, target_tensor, encoder, decoder, encoder_optimizer, deco
```
这是一个帮助功能,用于在给定当前时间和进度的情况下打印经过的时间和估计的剩余时间。
这是一个帮助功能,用于在给定当前时间和进度% 的情况下打印经过的时间和估计的剩余时间。
```py
import time
......
......@@ -206,7 +206,7 @@ True
## 性能提升] [docs / modern-java-zh /
在具有 Tensor Cores 支持的 Nvidia 硬件上观察到了最大的性能提升。 在运行 [Nvidia](https://github.com/NVIDIA/apex) 提供的 AMP(自动混合精度)培训脚本时,我们可以将性能提高 22以上。
在具有 Tensor Cores 支持的 Nvidia 硬件上观察到了最大的性能提升。 在运行 [Nvidia](https://github.com/NVIDIA/apex) 提供的 AMP(自动混合精度)培训脚本时,我们可以将性能提高 22% 以上。
`python main_amp.py -a resnet50 --b 200 --workers 16 --opt-level O2  ./data`
......@@ -245,7 +245,7 @@ True
```
传递`--channels-last true`允许以 Channels Last 格式运行模型,观察到 22的 perf 增益。
传递`--channels-last true`允许以 Channels Last 格式运行模型,观察到 22% 的 perf 增益。
`python main_amp.py -a resnet50 --b 200 --workers 16 --opt-level O2 --channels-last true ./data`
......@@ -288,7 +288,7 @@ True
```
以下型号列表完全支持 Channels Last,并在 Volta 设备上显示了 8%-35%的 perf 增益:`alexnet``mnasnet0_5``mnasnet0_75``mnasnet1_0``mnasnet1_3``mobilenet_v2``resnet101``resnet152``resnet18``resnet34``resnet50``resnext50_32x4d``shufflenet_v2_x0_5``shufflenet_v2_x1_0``shufflenet_v2_x1_5``shufflenet_v2_x2_0``squeezenet1_0``squeezenet1_1``vgg11``vgg11_bn``vgg13``vgg13_bn``vgg16``vgg16_bn``vgg19``vgg19_bn``wide_resnet101_2``wide_resnet50_2`
以下型号列表完全支持 Channels Last,并在 Volta 设备上显示了 8% -35% 的 perf 增益:`alexnet``mnasnet0_5``mnasnet0_75``mnasnet1_0``mnasnet1_3``mobilenet_v2``resnet101``resnet152``resnet18``resnet34``resnet50``resnext50_32x4d``shufflenet_v2_x0_5``shufflenet_v2_x1_0``shufflenet_v2_x1_5``shufflenet_v2_x2_0``squeezenet1_0``squeezenet1_1``vgg11``vgg11_bn``vgg13``vgg13_bn``vgg16``vgg16_bn``vgg19``vgg19_bn``wide_resnet101_2``wide_resnet50_2`
## 转换现有模型](docs / modern-java-zh /
......
......@@ -422,7 +422,7 @@ Forward: 349.335 us | Backward 443.523 us
```
我们已经可以看到前进功能的明显提速(超过 30)。 对于后退功能,可以看到加速,尽管不是很大。 我在上面编写的后向通行证没有特别优化,并且肯定可以改进。 而且,PyTorch 的自动微分引擎可以自动并行化计算图,可以整体上使用更高效的操作流程,并且也可以用 C ++来实现,因此有望实现更快的速度。 不过,这是一个良好的开始。
我们已经可以看到前进功能的明显提速(超过 30% )。 对于后退功能,可以看到加速,尽管不是很大。 我在上面编写的后向通行证没有特别优化,并且肯定可以改进。 而且,PyTorch 的自动微分引擎可以自动并行化计算图,可以整体上使用更高效的操作流程,并且也可以用 C ++来实现,因此有望实现更快的速度。 不过,这是一个良好的开始。
#### GPU 设备上的性能] [docs / modern-java-zh /
......
......@@ -114,7 +114,7 @@ optimizer = optim.SGD(net.parameters(), lr=config["lr"], momentum=0.9)
```
我们还将训练数据分为训练和验证子集。 因此,我们训练了 80%的数据,并计算了其余 20%的验证损失。 我们遍历训练和测试集的批处理大小也是可配置的。
我们还将训练数据分为训练和验证子集。 因此,我们训练了 80% 的数据,并计算了其余 20% 的验证损失。 我们遍历训练和测试集的批处理大小也是可配置的。
### 通过 DataParallel 添加(多)GPU 支持](docs / modern-java-zh /
......@@ -1698,7 +1698,7 @@ Best trial test set accuracy: 0.5537
如果运行代码,则示例输出如下所示:
为了避免浪费资源,大多数审判​​已提早停止。 效果最好的试验的验证准确度约为 58,可以在测试仪上进行确认。
为了避免浪费资源,大多数审判​​已提早停止。 效果最好的试验的验证准确度约为 58%,可以在测试仪上进行确认。
就是这样了! 您现在可以调整 PyTorch 模型的参数。
......
......@@ -108,7 +108,7 @@ print(list(module.named_buffers()))
要修剪模块(在此示例中,为 LeNet 架构的`conv1`层),请首先从`torch.nn.utils.prune`中可用的那些技术中选择一种修剪技术(或[通过子类化`BasePruningMethod`实现您自己的](#extending-torch-nn-utils-pruning-with-custom-pruning-functions))。 然后,指定模块和该模块中要修剪的参数的名称。 最后,使用所选修剪技术所需的适当关键字参数,指定修剪参数。
在此示例中,我们将在`conv1`层中名为`weight`的参数中随机修剪 30的连接。 模块作为第一个参数传递给函数; `name`使用其字符串标识符在该模块中标识参数; `amount`表示与修剪的连接百分比(如果是介于 0 和 1 之间的浮点数),或表示与修剪的连接的绝对数量(如果它是非负整数)。
在此示例中,我们将在`conv1`层中名为`weight`的参数中随机修剪 30% 的连接。 模块作为第一个参数传递给函数; `name`使用其字符串标识符在该模块中标识参数; `amount`表示与修剪的连接百分比(如果是介于 0 和 1 之间的浮点数),或表示与修剪的连接的绝对数量(如果它是非负整数)。
```py
prune.random_unstructured(module, name="weight", amount=0.3)
......@@ -617,7 +617,7 @@ dict_keys(['conv1.weight_mask', 'conv2.weight_mask', 'fc1.weight_mask', 'fc2.wei
## 全局修剪](docs / modern-java-zh /
到目前为止,我们仅查看了通常称为“局部”修剪的情况,即通过比较每个条目的统计信息(权重,激活度,梯度等)来逐个修剪模型中的张量的做法。 到该张量中的其他条目。 但是,一种通用且可能更强大的技术是通过删除(例如)删除整个模型中最低的 20%的连接,而不是删除每一层中最低的 20%的连接来一次修剪模型。 这很可能导致每个层的修剪百分比不同。 让我们看看如何使用`torch.nn.utils.prune`中的`global_unstructured`进行操作。
到目前为止,我们仅查看了通常称为“局部”修剪的情况,即通过比较每个条目的统计信息(权重,激活度,梯度等)来逐个修剪模型中的张量的做法。 到该张量中的其他条目。 但是,一种通用且可能更强大的技术是通过删除(例如)删除整个模型中最低的 20% 的连接,而不是删除每一层中最低的 20% 的连接来一次修剪模型。 这很可能导致每个层的修剪百分比不同。 让我们看看如何使用`torch.nn.utils.prune`中的`global_unstructured`进行操作。
```py
model = LeNet()
......@@ -638,7 +638,7 @@ prune.global_unstructured(
```
现在,我们可以检查每个修剪参数中引起的稀疏性,该稀疏性将不等于每层中的 20%。 但是,全球稀疏度将(大约)为 20%
现在,我们可以检查每个修剪参数中引起的稀疏性,该稀疏性将不等于每层中的 20%。 但是,全球稀疏度将(大约)为 20%
```py
print(
......
......@@ -18,7 +18,7 @@
* BERT,或者说 Transformers 的双向嵌入表示,是一种预训练语言表示的新方法,它可以在许多常见的自然语言处理(NLP)任务(例如问题解答,文本分类, 和别的。 可以在此处找到[](https://arxiv.org/pdf/1810.04805.pdf)
* PyTorch 中的动态量化支持将浮点模型转换为具有静态 int8 或 float16 数据类型的权重和动态量化激活的量化模型。 当权重量化为 int8 时,激活(每批)动态量化为 int8。 在 PyTorch 中,我们有 [torch.quantization.quantize_dynamic API](https://pytorch.org/docs/stable/quantization.html#torch.quantization.quantize_dynamic) ,该 API 用仅动态权重的量化版本替换了指定的模块,并输出了量化模型。
* 我们在通用语言理解评估基准[(GLUE)](https://gluebenchmark.com/)中演示了 [Microsoft Research Paraphrase 语料库(MRPC)任务](https://www.microsoft.com/en-us/download/details.aspx?id=52398)的准确性和推理性能结果。 MRPC(Dolan 和 Brockett,2005 年)是从在线新闻源中自动提取的句子对的语料库,带有人工注释,说明句子中的句子在语义上是否等效。 由于班级不平衡(正向为 68%,负向为 32%),我们遵循常规做法并报告 [F1 得分](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.f1_score.html)。 MRPC 是用于语言对分类的常见 NLP 任务,如下所示。
* 我们在通用语言理解评估基准[(GLUE)](https://gluebenchmark.com/)中演示了 [Microsoft Research Paraphrase 语料库(MRPC)任务](https://www.microsoft.com/en-us/download/details.aspx?id=52398)的准确性和推理性能结果。 MRPC(Dolan 和 Brockett,2005 年)是从在线新闻源中自动提取的句子对的语料库,带有人工注释,说明句子中的句子在语义上是否等效。 由于班级不平衡(正向为 68%,负向为 32% ),我们遵循常规做法并报告 [F1 得分](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.f1_score.html)。 MRPC 是用于语言对分类的常见 NLP 任务,如下所示。
![../_img/bert.png](img/b43b70d8a6eef9ea4f75867b5e83b483.png)
......@@ -402,7 +402,7 @@ time_model_evaluation(quantized_model, configs, tokenizer)
```
在 MRPC 任务的微调 BERT 模型上应用训练后动态量化后,我们的 F1 分数准确性为 0.6。 作为比较,在[的最新论文](https://arxiv.org/pdf/1910.06188.pdf)(表 1)中,通过应用训练后动态量化,可以达到 0.8788;通过应用量化感知训练,可以达到 0.8956。 主要区别在于我们在 PyTorch 中支持非对称量化,而该论文仅支持对称量化。
在 MRPC 任务的微调 BERT 模型上应用训练后动态量化后,我们的 F1 分数准确性为 0.6%。 作为比较,在[的最新论文](https://arxiv.org/pdf/1910.06188.pdf)(表 1)中,通过应用训练后动态量化,可以达到 0.8788;通过应用量化感知训练,可以达到 0.8956。 主要区别在于我们在 PyTorch 中支持非对称量化,而该论文仅支持对称量化。
请注意,在本教程中,为了进行单线程比较,我们将线程数设置为 1。 我们还为这些量化的 INT8 运算符支持运算内并行化。 用户现在可以通过`torch.set_num_threads(N)`设置多线程(`N`是内部运算并行线程的数量)。 启用帧内并行支持的一项初步要求是使用正确的[后端](https://pytorch.org/docs/stable/notes/cpu_threading_torchscript_inference.html#build-options)(例如 OpenMP,Native 或 TBB)构建 PyTorch。 您可以使用`torch.__config__.parallel_info()`检查并行化设置。 在使用 PyTorch 和本机后端进行并行化的同一台 MacBook Pro 上,我们可以花大约 46 秒的时间来处理 MRPC 数据集的评估。
......
......@@ -466,7 +466,7 @@ Size (MB): 13.999657
```
我们看到 300 张图像的准确率达到 78,这是 ImageNet 的坚实基础,特别是考虑到我们的模型只有 14.0 MB。
我们看到 300 张图像的准确率达到 78%,这是 ImageNet 的坚实基础,特别是考虑到我们的模型只有 14.0 MB。
这将是我们比较的基准。 接下来,让我们尝试不同的量化方法
......@@ -558,7 +558,7 @@ Size (MB): 3.631847
```
对于这个量化模型,我们发现在这 300 张相同的图像上,准确率仅低至〜62。 不过,我们确实将模型的大小减小到了 3.6 MB 以下,几乎减少了 4 倍。
对于这个量化模型,我们发现在这 300 张相同的图像上,准确率仅低至〜62%。 不过,我们确实将模型的大小减小到了 3.6 MB 以下,几乎减少了 4 倍。
此外,我们可以通过使用不同的量化配置来显着提高准确性。 我们使用推荐的配置对 x86 架构进行量化,重复相同的练习。 此配置执行以下操作:
......@@ -589,7 +589,7 @@ QConfig(activation=functools.partial(<class 'torch.quantization.observer.Histogr
```
仅更改这种量化配置方法,就可以将准确性提高到 76%以上! 尽管如此,这仍比上述 78%的基准差 1-2%。 因此,让我们尝试量化意识的训练。
仅更改这种量化配置方法,就可以将准确性提高到 76% 以上! 尽管如此,这仍比上述 78% 的基准差 1-2%。 因此,让我们尝试量化意识的训练。
## 5.量化意识训练](docs / modern-java-zh /
......@@ -750,7 +750,7 @@ Training: * Acc@1 63.000 Acc@5 81.333
```
在这里,我们只对少数几个时期执行量化感知训练。 尽管如此,量化意识训练在整个 imagenet 数据集上的准确性仍超过 71%,接近浮点精度 71.9%
在这里,我们只对少数几个时期执行量化感知训练。 尽管如此,量化意识训练在整个 imagenet 数据集上的准确性仍超过 71%,接近浮点精度 71.9%
有关量化意识训练的更多信息:
......
......@@ -172,7 +172,7 @@ plot([mp_mean, rn_mean],
![](img/7f2d776cf49fcf3fd44fd84a238a3cc6.png)
结果表明,模型并行实现的执行时间比现有的单 GPU 实现长`4.02/3.75-1=7%`。 因此,我们可以得出结论,在 GPU 之间来回复制张量大约有 7的开销。 有待改进的地方,因为我们知道两个 GPU 之一在整个执行过程中处于空闲状态。 一种选择是将每个批次进一步划分为拆分流水线,以便当一个拆分到达第二子网时,可以将下一个拆分馈入第一子网。 这样,两个连续的拆分可以在两个 GPU 上同时运行。
结果表明,模型并行实现的执行时间比现有的单 GPU 实现长`4.02/3.75-1=7%`。 因此,我们可以得出结论,在 GPU 之间来回复制张量大约有 7% 的开销。 有待改进的地方,因为我们知道两个 GPU 之一在整个执行过程中处于空闲状态。 一种选择是将每个批次进一步划分为拆分流水线,以便当一个拆分到达第二子网时,可以将下一个拆分馈入第一子网。 这样,两个连续的拆分可以在两个 GPU 上同时运行。
## 通过流水线输入加快速度] [docs / modern-java-zh /
......@@ -219,7 +219,7 @@ plot([mp_mean, rn_mean, pp_mean],
![](img/48d2e67f025b05eeb9259e249566add3.png)
实验结果表明,对并行 ResNet50 进行建模的流水线输入可大致加快`3.75/2.51-1=49%`的速度,加快训练过程。 距离理想的 100加速仍然相去甚远。 由于我们在管道并行实现中引入了新参数`split_sizes`,因此尚不清楚新参数如何影响整体训练时间。 直观地讲,使用较小的`split_size`会导致许多小的 CUDA 内核启动,而使用较大的`split_size`会导致在第一次和最后一次拆分期间出现较长的空闲时间。 两者都不是最优的。 对于此特定实验,可能会有最佳的`split_size`配置。 让我们尝试通过使用几个不同的`split_size`值进行实验来找到它。
实验结果表明,对并行 ResNet50 进行建模的流水线输入可大致加快`3.75/2.51-1=49%`的速度,加快训练过程。 距离理想的 100% 加速仍然相去甚远。 由于我们在管道并行实现中引入了新参数`split_sizes`,因此尚不清楚新参数如何影响整体训练时间。 直观地讲,使用较小的`split_size`会导致许多小的 CUDA 内核启动,而使用较大的`split_size`会导致在第一次和最后一次拆分期间出现较长的空闲时间。 两者都不是最优的。 对于此特定实验,可能会有最佳的`split_size`配置。 让我们尝试通过使用几个不同的`split_size`值进行实验来找到它。
```py
means = []
......
......@@ -21,8 +21,8 @@
| 房屋特色 | 房子的价格 | 房地产 | 在输出层中带有线性整流单元的标准神经网络 |
| 广告和用户信息点击广告? | 是(1)或否(0) | 在线广告 | 具有二进制分类的标准神经网络 |
| 图像对象 | 从 100 个不同的对象进行分类,即(1,2,.....,100) | 照片标签 | 卷积神经网络(由于图像,即空间数据) |
| 音讯 | 文字笔录 | 语音识别 | 递归神经网络(因为两个输入输出都是顺序数据) |
| 英语 | 中文 | 机器翻译 | 递归神经网络(因为输入是顺序数据) |
| 音讯 | 文字笔录 | 语音识别 | 循环神经网络(因为两个输入输出都是顺序数据) |
| 英语 | 中文 | 机器翻译 | 循环神经网络(因为输入是顺序数据) |
| 图像,雷达信息 | 其他汽车的位置 | 自动驾驶 | 定制的混合/复杂神经网络 |
在本章的后续部分中,我们将详细介绍前面提到的神经网络,但是首先我们必须了解,根据问题陈述的目的使用了不同类型的神经网络。
......@@ -57,7 +57,7 @@
* **通用深度学习**:密集连接的层或完全连接的网络
* **序列模型**递归神经网络,长期短期记忆网络,门控递归单元等
* **序列模型**循环神经网络,长期短期记忆网络,门控递归单元等
* **空间数据模型**(例如,图像):卷积神经网络,生成对抗网络
......@@ -439,11 +439,11 @@ Xavier 初始化是神经网络中权重的初始化,是遵循高斯分布的
设置好此结构后,我们必须重复执行这些优化步骤(更新![](img/1ac8a61d-f0cd-4875-bb19-8e24af95ab5b.png)和![](img/1dae3d1b-e4bc-4a91-b6f7-c05238e0f6f5.png)),以进行多次迭代以训练我们的神经网络。
这将我们带到了神经网络基础的结尾,它构成了任何浅或深的神经网络的基本构建块。 我们的下一个前沿将是了解一些著名的深度神经网络架构,例如**递归神经网络****RNNs**)和**卷积神经网络****CNN**)。 除此之外,我们还将介绍基准的深度神经网络体系结构,例如 AlexNet,VGG-net 和 Inception。
这将我们带到了神经网络基础的结尾,它构成了任何浅或深的神经网络的基本构建块。 我们的下一个前沿将是了解一些著名的深度神经网络架构,例如**循环神经网络****RNNs**)和**卷积神经网络****CNN**)。 除此之外,我们还将介绍基准的深度神经网络体系结构,例如 AlexNet,VGG-net 和 Inception。
# 递归神经网络
# 循环神经网络
递归神经网络,缩写为 RNN,用于顺序数据的情况下,无论是作为输入,输出还是两者。 RNN 之所以如此有效,是因为它们的体系结构可以汇总来自过去数据集的学习,并将其与新数据一起使用以增强学习。 这样,它可以捕获事件的顺序,这在前馈神经网络或统计时间序列分析的早期方法中是不可能的。
循环神经网络,缩写为 RNN,用于顺序数据的情况下,无论是作为输入,输出还是两者。 RNN 之所以如此有效,是因为它们的体系结构可以汇总来自过去数据集的学习,并将其与新数据一起使用以增强学习。 这样,它可以捕获事件的顺序,这在前馈神经网络或统计时间序列分析的早期方法中是不可能的。
考虑时间序列数据,例如股票市场,音频或视频数据集,其中事件的顺序非常重要。 因此,在这种情况下,除了从整个数据中进行集体学习之外,从时间上遇到的数据中学习的顺序也很重要。 这将有助于捕捉潜在趋势。
......@@ -459,7 +459,7 @@ Xavier 初始化是神经网络中权重的初始化,是遵循高斯分布的
为了回想起更远的地方,将需要更深的神经网络。 取而代之的是,我们将使用一个汇总过去的模型,并将该信息以及新信息提供给分类器。
因此,在递归神经网络中的任何时间步长 t 处,都会发生以下计算:
因此,在循环神经网络中的任何时间步长 t 处,都会发生以下计算:
* ![](img/574a41ce-1848-4111-ba71-d166d62d5cff.png)
......@@ -485,7 +485,7 @@ Xavier 初始化是神经网络中权重的初始化,是遵循高斯分布的
![](img/93dd25ec-59c7-4c71-82b3-ce6a8f7fe21d.png)
一旦完成计算直到最后一个时间步,我们的前向传播任务就完成了。 下一个任务是通过反向传播来训练我们的递归神经网络,以使总损失最小化。 一个这样的序列的总损耗是所有时间步长上损耗的总和,也就是说,如果给定的`X`值序列及其对应的`Y`值输出序列,则损耗 是(谁)给的:
一旦完成计算直到最后一个时间步,我们的前向传播任务就完成了。 下一个任务是通过反向传播来训练我们的循环神经网络,以使总损失最小化。 一个这样的序列的总损耗是所有时间步长上损耗的总和,也就是说,如果给定的`X`值序列及其对应的`Y`值输出序列,则损耗 是(谁)给的:
![](img/db611e16-6507-40be-a626-26d9096b2a64.png)
......@@ -529,7 +529,7 @@ LSTM 是一项突破,因为人们可以通过将 RNN 合并为单元单元来
# 卷积神经网络
卷积神经网络或卷积神经网络是在计算机视觉中提供成功结果的深神经网络。 它们的灵感来自动物视皮层中神经元的组织和信号处理,也就是说,单个皮层神经元会对其相关小区域(视野)中的刺激做出反应,称为**感受野** ,并且不同神经元的这些感受野完全重叠,覆盖了整个视野。
卷积神经网络或卷积神经网络是在计算机视觉中提供成功结果的深神经网络。 它们的灵感来自动物视皮层中神经元的组织和信号处理,也就是说,单个皮层神经元会对其相关小区域(视野)中的刺激做出反应,称为**感受野** ,并且不同神经元的这些感受野完全重叠,覆盖了整个视野。
当输入空间中的输入包含相同类型的信息时,我们将共享权重并针对这些输入共同训练这些权重。 对于空间数据(例如图像),这种权重共享会导致 CNN。 同样,对于顺序数据(例如文本),我们目睹了 RNN 中的这种权重共享。
......@@ -578,7 +578,7 @@ LeNet-5 是一个七级卷积神经网络,由 Yann LeCunn,Yoshua Bengio,Le
# AlexNet 模型
AlexNet 是 LeNet 的一种改进,由 SuperVision 小组设计,该小组由 Alex Krizhevsky,Geoffrey Hinton 和 Ilya Sutskever 组成。 在 2012 年 ImageNet 大规模视觉识别挑战赛中,AlexNet 的前 5 位错误率达到 15.3,比第二名高出 10 个百分点,创造了历史记录。
AlexNet 是 LeNet 的一种改进,由 SuperVision 小组设计,该小组由 Alex Krizhevsky,Geoffrey Hinton 和 Ilya Sutskever 组成。 在 2012 年 ImageNet 大规模视觉识别挑战赛中,AlexNet 的前 5 位错误率达到 15.3%,比第二名高出 10 个百分点,创造了历史记录。
该架构使用五个卷积层,三个最大池层和最后三个完全连接的层,如下图所示。 该模型总共训练了 6000 万个参数,训练了 120 万张图像,在两个 NVIDIA GTX 580 3GB GPU 上花费了大约五到六天的时间。 下图显示了 AlexNet 模型:
......@@ -995,7 +995,7 @@ Google DeepMind 是一家英国人工智能公司,成立于 2010 年 9 月,
* 2016 年 7 月,Google DeepMind 与 Moorfields 眼科医院宣布合作,使用眼部扫描技术研究导致失明的疾病的早期征兆
* 2016 年 8 月,Google DeepMind 宣布与伦敦大学学院医院合作研究和开发一种算法,以自动区分头部和颈部的健康组织和癌性组织
* Google DeepMind AI 将 Google 的数据中心散热费用降低了 40
* Google DeepMind AI 将 Google 的数据中心散热费用降低了 40%
# AlphaGo 程序
......@@ -1011,7 +1011,7 @@ Libratus 是由卡内基梅隆大学的 Tuomas Sandholm 教授带领的团队设
# 概要
在本章中,我们涵盖了构建模块,例如包括逻辑回归的浅层和深神经网络,单隐藏层神经网络,RNN,LSTM,CNN 及其其他变体。 针对这些主题,我们还介绍了多个激活函数,正向和反向传播的工作方式以及与深度神经网络训练相关的问题,例如消失和爆炸梯度。
在本章中,我们涵盖了构建模块,例如包括逻辑回归的浅层和深神经网络,单隐藏层神经网络,RNN,LSTM,CNN 及其其他变体。 针对这些主题,我们还介绍了多个激活函数,正向和反向传播的工作方式以及与深度神经网络训练相关的问题,例如消失和爆炸梯度。
然后,我们涵盖了强化学习中非常基本的术语,我们将在接下来的章节中对其进行详细探讨。 这些是最优标准,即价值函数和政策。 我们还了解了一些强化学习算法,例如 Q 学习和 A3C 算法。 然后,我们在 TensorFlow 框架中介绍了一些基本计算,这是 OpenAI Gym 的简介,还讨论了强化学习领域的一些有影响力的先驱者和研究突破。
......
......@@ -564,7 +564,7 @@ HFFG
Q 学习和 Q 网络都需要付出一定的稳定性。 在某些情况下,如果给定的 Q 值超参数集未收敛,但具有相同的超参数,则有时会出现收敛。 这是由于这些学习方法的不稳定。 为了解决这个问题,如果状态空间较小,则应定义更好的初始策略(此处为给定状态的最大 Q 值)。 此外,超参数,尤其是学习率,折扣因子和ε值,起着重要的作用。 因此,必须正确初始化这些值。
由于增加了状态空间,因此与 Q 学习相比,Q 网络具有更大的灵活性。 Q 网络中的深神经网络可能会导致更好的学习和性能。 就使用 Deep Q 网络玩 Atari 而言,有许多调整,我们将在接下来的章节中进行讨论。
由于增加了状态空间,因此与 Q 学习相比,Q 网络具有更大的灵活性。 Q 网络中的深神经网络可能会导致更好的学习和性能。 就使用 Deep Q 网络玩 Atari 而言,有许多调整,我们将在接下来的章节中进行讨论。
# 概要
......
......@@ -153,7 +153,7 @@ Silver et。 等
* 使用学习到的快速推广策略![](img/a453b581-4415-4d30-81e6-96e93018c288.png)进行推广,直到游戏结束,并使用函数`r`计算获胜者
* `d`:更新动作值`Q`,以跟踪该动作下方子树中所有评估值 r(·)和![](img/e9c40645-7e2f-403d-b976-413405948161.png)(·)的平均值。
如前所述,对一个政策网络进行了 3000 万个游戏职位的培训。 在不使用树搜索的情况下,AlphaGo 赢得了与 Pachi(Go 最强的 AI 程序)对战的 85的比赛,其中 Pachi 依靠基于 Monte Carlo Tree Search 的 100,000 次模拟。 价值网络接受了 3000 万个游戏位置的培训,并学习了预测获胜概率的模型。 策略网络输出充当树搜索的指南。 对于给定的游戏状态,策略网络为每个可能的移动提供了概率。 这有助于减少树搜索期间的候选动作。
如前所述,对一个政策网络进行了 3000 万个游戏职位的培训。 在不使用树搜索的情况下,AlphaGo 赢得了与 Pachi(Go 最强的 AI 程序)对战的 85% 的比赛,其中 Pachi 依靠基于 Monte Carlo Tree Search 的 100,000 次模拟。 价值网络接受了 3000 万个游戏位置的培训,并学习了预测获胜概率的模型。 策略网络输出充当树搜索的指南。 对于给定的游戏状态,策略网络为每个可能的移动提供了概率。 这有助于减少树搜索期间的候选动作。
# 能耗分析– Lee Sedol 与 AlphaGo
......
......@@ -72,7 +72,7 @@
* **特工车辆正在接近距离**:负面奖励
* **特工车辆加速**:随着速度增加,正奖励减少,超过速度限制则负奖励
整合**递归神经网络****RNN**)来整合时间序列信息将使汽车能够处理部分可观察的场景。 此外,使用注意力模型来关注相关信息还可以降低计算复杂度。 如前所述,AI 的下一个,当然是最大的里程碑之一是创建端到端自动驾驶汽车。
整合**循环神经网络****RNN**)来整合时间序列信息将使汽车能够处理部分可观察的场景。 此外,使用注意力模型来关注相关信息还可以降低计算复杂度。 如前所述,AI 的下一个,当然是最大的里程碑之一是创建端到端自动驾驶汽车。
# 创建自动驾驶代理
......@@ -81,11 +81,11 @@
![](img/a439e6b9-b14f-40fb-84e3-2d8ef4bf84ca.png)
* 识别周围环境的组成部分,其中包括人行道,人,交通信号灯,任何建筑,道路边界,其他车辆等。 对于 AI,由于使用**卷积神经网络****CNN**)和**生成对抗网络****GAN**)。 CNN 和 GAN 的成功可用于自动驾驶环境要素的识别过程。
* **预测**环境的未来状态。 识别当前环境状态的环境的当前组成部分很重要,但是将其用作输入并预测未来环境状态对于计划下一步行动也很有必要。 解决此问题的基本方法之一是创建环境图。 此外,我们可以合并深度神经网络,例如递归神经网络的变体,例如**长短时记忆网络****LSTM**)或**门控循环单元**[ **GRU**),以整合和整合过去时间步长以及当前时间步长和预测未来中的数据。 正如我们在[第 1 章](../Text/01.html)*深度学习–体系结构和框架*中讨论的那样,由于长期依赖以及 LSTM 单元如何解决该问题,围绕梯度消失的问题仍然存在 RNN 的情况。 RNN 是集成时间序列数据的最新技术,它在 [DeepTracking](https://arxiv.org/pdf/1602.00991.pdf)中显示了对象跟踪方面的改进。
* **预测**环境的未来状态。 识别当前环境状态的环境的当前组成部分很重要,但是将其用作输入并预测未来环境状态对于计划下一步行动也很有必要。 解决此问题的基本方法之一是创建环境图。 此外,我们可以合并深度神经网络,例如循环神经网络的变体,例如**长短时记忆网络****LSTM**)或**门控循环单元**[ **GRU**),以整合和整合过去时间步长以及当前时间步长和预测未来中的数据。 正如我们在[第 1 章](../Text/01.html)*深度学习–体系结构和框架*中讨论的那样,由于长期依赖以及 LSTM 单元如何解决该问题,围绕梯度消失的问题仍然存在 RNN 的情况。 RNN 是集成时间序列数据的最新技术,它在 [DeepTracking](https://arxiv.org/pdf/1602.00991.pdf)中显示了对象跟踪方面的改进。
* **规划**是整个过程中最难的部分。 该任务包括将识别和预测的结果集成在一起,以计划将来的动作序列以及下一个驾驶动作集(向左或向右转向,加速等等),以使导航安全且成功。 这是一项艰巨的任务,因为整合和规划需要处理不可避免的情况才能安全到达目的地。 强化学习最适合此类控制计划任务。 我们已经了解了如何成功地部署强化学习来控制 50 场 Atari 游戏中的计划任务,以及 Google DeepMind 提供的最先进的 AlphaGo Zero。 在这些情况下,我们目睹了深度学习在进行表示学习的同时进行强化学习的规划。
由于使用了多种类型的传感器,所有这些信息的集成对于自动驾驶至关重要。 由于数据维数的差异,很难整合来自不同来源的感官输入。 例如,摄像机输入为高维,而 LIDAR 输入为低维。 提取相关信息并忽略不相关信息无疑会提高性能和准确性。 它降低了计算和存储能力的利用率。 因此,为了获取相关信息,注意模型适用于此目的,因为使用注意力机制的递归神经网络强化学习已成功应用于图像,从而仅关注相关部分。
由于使用了多种类型的传感器,所有这些信息的集成对于自动驾驶至关重要。 由于数据维数的差异,很难整合来自不同来源的感官输入。 例如,摄像机输入为高维,而 LIDAR 输入为低维。 提取相关信息并忽略不相关信息无疑会提高性能和准确性。 它降低了计算和存储能力的利用率。 因此,为了获取相关信息,注意模型适用于此目的,因为使用注意力机制的循环神经网络强化学习已成功应用于图像,从而仅关注相关部分。
# 为什么要加强学习?
......@@ -111,7 +111,7 @@
![](img/c0d1b6ca-7308-4b36-b494-851bef3b4473.png)
[El Sallab 等人(2017)对自动驾驶深神经网络进行端到端培训](https://arxiv.org/pdf/1704.02532.pdf)
[El Sallab 等人(2017)对自动驾驶深神经网络进行端到端培训](https://arxiv.org/pdf/1704.02532.pdf)
让我们详细讨论前面的体系结构。 在这种情况下,输入是多个时间步长上环境状态的汇总。
......
......@@ -83,7 +83,7 @@
投资组合权重(我们将在后面讨论)实际上是由强化学习驱动的投资组合管理代理的市场行为。 将购买目标权重增加的资产,而目标权重减小的资产将被出售。 因此,最后交易期间的投资组合权重也作为 EIIE 的输入。 因此,每个期间的投资组合权重存储在**投资组合向量存储器****PVM**)中。
EIIE 通过**在线随机批处理学习****OSBL**)进行训练,其中强化学习框架的奖励函数是该时期的平均对数回报。 由于奖励功能是动态的,因此,随着训练是通过梯度上升进行的,EIIE 也在不断发展。 如前所述,EIIE 由一个神经网络组成,因此,对于当前框架,使用不同类型的神经网络测试了三种不同类型的 EIIE,即**卷积神经网络****CNN**),**递归神经网络****RNN**)和**长短期记忆 neworks****LSTM**),这是 RNN 单元。 这种类型的框架可以轻松扩展到不同的市场,而不仅限于一个。
EIIE 通过**在线随机批处理学习****OSBL**)进行训练,其中强化学习框架的奖励函数是该时期的平均对数回报。 由于奖励功能是动态的,因此,随着训练是通过梯度上升进行的,EIIE 也在不断发展。 如前所述,EIIE 由一个神经网络组成,因此,对于当前框架,使用不同类型的神经网络测试了三种不同类型的 EIIE,即**卷积神经网络****CNN**),**循环神经网络****RNN**)和**长短期记忆 neworks****LSTM**),这是 RNN 单元。 这种类型的框架可以轻松扩展到不同的市场,而不仅限于一个。
该提议框架的测试平台是一个名为 Poloniex 的加密货币交易市场。 实验之前,通过在一定时间间隔内的交易量排名来选择硬币。 实验在 30 分钟的交易时间内进行,并将 EIIE 的性能与前面提到的在线投资组合选择方法进行了比较。 EIIE 能够击败所有这些方法。
......
......@@ -161,7 +161,7 @@ YOLO 还可以预测训练中所有班级每个盒子的班级得分。 因此
# 培训细节
通过![](img/ecd06177-5874-44de-8f0c-ad4445961487.png)-贪婪方法学习了一个深层 Q 网络,该网络以![](img/752a5ee5-41c4-479c-be21-15ce4c8a1575.png) = 1(完全 100%探索)开始,并以 0.1 的步长直到= 0.1(仅 10%探索,90%开发)减少。 在探索过程中,选择随机动作是因为通过更好的探索,可以避免局部最小值,并且还可以揭示通往目标状态的未知优化路径。 而且,为了帮助代理学习终端动作,每当当前区域具有 *IoU > ![](img/bc6d054b-8cf7-439a-b014-651b9148bc8b.png)* 时,代理便被迫采取该动作,这反过来又加速了学习过程。
通过![](img/ecd06177-5874-44de-8f0c-ad4445961487.png)-贪婪方法学习了一个深层 Q 网络,该网络以![](img/752a5ee5-41c4-479c-be21-15ce4c8a1575.png) = 1(完全 100% 探索)开始,并以 0.1 的步长直到= 0.1(仅 10% 探索,90% 开发)减少。 在探索过程中,选择随机动作是因为通过更好的探索,可以避免局部最小值,并且还可以揭示通往目标状态的未知优化路径。 而且,为了帮助代理学习终端动作,每当当前区域具有 *IoU > ![](img/bc6d054b-8cf7-439a-b014-651b9148bc8b.png)* 时,代理便被迫采取该动作,这反过来又加速了学习过程。
我们在训练时发现的一个事实是,我们不应强加要首先看图像的哪个对象。 在每个时间步长,代理都将专注于当前区域中与地面真实性重叠程度最高的对象。 这样,目标对象有可能在自顶向下的探索过程中发生变化。
......
......@@ -165,7 +165,7 @@ Paulus 等人(2017)在[《用于抽象摘要的深度强化模型》](https:
为了解决这个问题,熊等人。 等 发表了他们的研究 *DCN +:问答的混合目标和深度残差协作,*提出了使用混合目标函数的方法,该函数是交叉熵损失和自我批判策略学习的组合。 这个混合目标使用从单词重叠中获得的奖励来解决现有模型中评估与优化之间的脱节问题。
提出的新框架对于需要捕获长期依存关系的长问题表现更好,能够获得 75.1%的精确匹配准确度和 83.1%的 F1 分数的强大结果,而集成模型获得 78.9%的精确匹配准确度和 86.0 %F1 分数。
提出的新框架对于需要捕获长期依存关系的长问题表现更好,能够获得 75.1% 的精确匹配准确度和 83.1% 的 F1 分数的强大结果,而集成模型获得 78.9% 的精确匹配准确度和 86.0 % F1 分数。
因此,混合目标的方法提供了两个好处:
......
......@@ -214,7 +214,7 @@ ROUGE 还可以通过将机器生成的输出(自动摘要或翻译)与一
![](img/5c613f75-cc17-4c3b-8614-342a3c32ac48.png)
因此,ROUGE-2 <sub class="calibre209">精度</sub>显示该机器生成的二元语法的 67与人类生成的参考重叠。
因此,ROUGE-2 <sub class="calibre209">精度</sub>显示该机器生成的二元语法的 67% 与人类生成的参考重叠。
本附录涵盖了 NLP 中顺序模型中 ROUGE 评分的基本概述。 有关 ROUGE-N,ROUGE-L 和 ROUGE-S 的更多详细信息,请浏览[《ROUGE:自动摘要评估包》](http://www.aclweb.org/anthology/W04-1013),作者为 CY Lin。
......
Markdown is supported
0% .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑!
想要评论请 注册