Skip to content

A
apachecn-dl-zh

冰.封万里 / apachecn-dl-zh
与 Fork 源项目一致

Fork自 OpenDocCN / apachecn-dl-zh

通知 1
Star 0
Fork 0
A
apachecn-dl-zh

体验新版 GitCode，发现更多精彩内容 >>

提交 27bb5cf1 编写于 作者: W wizardforcel
浏览文件
操作

2021-01-16 23:27:21

上级 689075c9
隐藏空白更改
内联 并排
Showing with 139 addition and 139 deletion
new/dl-pt-workshop/2.md
浏览文件 @ 27bb5cf1
......@@ -403,7 +403,7 @@ EDA 流程很有用，因为它有助于开发人员发现对于定义操作过
1. **数据量**：这既指实例数，也指特征数。 前者对于确定是否有必要甚至有可能使用神经网络甚至是深度神经网络解决数据问题至关重要，因为考虑到此类模型需要大量数据才能达到较高的准确率。 另一方面，后者对于确定是否提前开发某些特征选择方法以减少特征数量，简化模型并消除任何冗余信息是否有用是有用的。
2. **目标特征**：对于受监督的模型，需要标记数据。 考虑到这一点，选择目标特征（我们希望通过构建模型来实现的目标）以评估特征是否具有许多缺失值或离群值非常重要。 此外，这有助于确定开发目标，该目标应与可用数据一致。
3. **噪音数据/异常值**：噪音数据是指明显不正确的值，例如200岁的人。 另一方面，离群值所指的值虽然可能是正确的，但与平均值相差甚远，例如，一个10岁的大学生。
3. **噪音数据/异常值**：噪音数据是指明显不正确的值，例如 200 岁的人。 另一方面，离群值所指的值虽然可能是正确的，但与平均值相差甚远，例如，一个 10 岁的大学生。
没有检测异常值的确切科学方法，但是有一些通常被接受的方法。 假设数据集呈正态分布，那么最受欢迎的数据集之一就是确定离平均值约 3-6 标准差的任何值。
......@@ -437,7 +437,7 @@ EDA 流程很有用，因为它有助于开发人员发现对于定义操作过
import pandas as pd
```
3. 使用熊猫读取CSV文件，其中包含我们从UC Irvine机器学习存储库站点下载的数据集。
3. 使用熊猫读取 CSV 文件，其中包含我们从 UC Irvine 机器学习存储库站点下载的数据集。
接下来，删除名为`date`的列，因为我们不想在以下练习中考虑它：
......@@ -565,7 +565,7 @@ EDA 流程很有用，因为它有助于开发人员发现对于定义操作过
前面的代码片段获取数据并使用切片将特征与目标分离。
2. 通过使用规范化方法重新缩放特征数据。 显示结果DataFrame的标题（即前五个实例）以验证结果：
2. 通过使用规范化方法重新缩放特征数据。 显示结果 DataFrame 的标题（即前五个实例）以验证结果：
```py
X = (X - X.min()) / (X.max() - X.min())
......@@ -660,7 +660,7 @@ EDA 流程很有用，因为它有助于开发人员发现对于定义操作过
(3947, 27) (3947,)
```
6. 从scikit-learn的`model_selection`模块导入`train_test_split()`函数：
6. 从 scikit-learn 的`model_selection`模块导入`train_test_split()`函数：
```py
from sklearn.model_selection import train_test_split
......@@ -800,7 +800,7 @@ PyTorch 的构建考虑了该领域许多开发人员的意见，其优点是可
使用与上一练习相同的 Jupyter 笔记本。
1. 从PyTorch导入名为`torch`的PyTorch库，以及`nn`模块。
1. 从 PyTorch 导入名为`torch`的 PyTorch 库，以及`nn`模块。
```py
import torch
......@@ -822,7 +822,7 @@ PyTorch 的构建考虑了该领域许多开发人员的意见，其优点是可
y_test = torch.tensor(y_test.values).float()
```
3. 使用`sequential()`容器定义网络体系结构。 确保创建四层网络。 考虑到我们正在处理回归问题，请在前三层使用ReLU激活函数，而在最后一层不使用激活函数。
3. 使用`sequential()`容器定义网络体系结构。 确保创建四层网络。 考虑到我们正在处理回归问题，请在前三层使用 ReLU 激活函数，而在最后一层不使用激活函数。
每层的单位数应为 100、50、25 和 1：
......@@ -842,13 +842,13 @@ PyTorch 的构建考虑了该领域许多开发人员的意见，其优点是可
loss_function = torch.nn.MSELoss()
```
5. 将优化器算法定义为Adam优化器：
5. 将优化器算法定义为 Adam 优化器：
```py
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
```
6. 使用`for`循环在训练数据上训练1,000个迭代步骤来训练网络：
6. 使用`for`循环在训练数据上训练 1,000 个迭代步骤来训练网络：
```py
for i in range(1000):
......
new/dl-pt-workshop/3.md
浏览文件 @ 27bb5cf1
......@@ -192,7 +192,7 @@ print("rows:",data.shape[0]," columns:", data.shape[1])
这意味着，鉴于异常值对每个特征的参与度太低，因此不需要采取进一步的措施，因此它们不太可能对最终模型产生影响。
* **检查类不平衡**：当目标要素中的类标签未均等表示时，发生类不平衡； 例如，一个数据集包含90％的未拖欠下次付款的客户，而10％的客户未拖欠下一次付款，则被认为是不平衡的。
* **检查类不平衡**：当目标要素中的类标签未均等表示时，发生类不平衡； 例如，一个数据集包含 90％的未拖欠下次付款的客户，而 10％的客户未拖欠下一次付款，则被认为是不平衡的。
有几种处理类不平衡的方法，其中一些方法在这里说明：
......@@ -321,7 +321,7 @@ final_data.to_csv("dccc_prepared.csv", index=False)
考虑到所有这些，将解释以下一组惯例和经验法则，以帮助决策过程定义 ANN 的初始架构：
* **输入层**：这很简单； 只有一个输入层，其单位数量取决于训练数据的形状。 具体来说，输入层中的单位数应等于输入数据包含的要素数。
* **隐藏层**：隐藏层的数量可能有所不同。 ANN可以有一个隐藏层，也可以没有，也可以没有。 要选择正确的号码，请考虑以下几点：
* **隐藏层**：隐藏层的数量可能有所不同。 ANN 可以有一个隐藏层，也可以没有，也可以没有。 要选择正确的号码，请考虑以下几点：
数据问题越简单，所需的隐藏层就越少。 请记住，线性可分离的简单数据问题应该只有一个隐藏层。 另一方面，可以并且应该使用许多隐藏层（没有限制）解决更复杂的数据问题。
......@@ -378,7 +378,7 @@ class Classifier(torch.nn.Module):
使用前面解释的理论，我们将使用定制模块的语法定义模型的架构：
1. 打开Jupyter 笔记本并导入所需的库：
1. 打开 Jupyter 笔记本并导入所需的库：
```py
import torch
......@@ -394,7 +394,7 @@ class Classifier(torch.nn.Module):
D_o = 2
```
3. 使用PyTorch的自定义模块，创建一个名为`Classifier`的类并定义模型的体系结构，使其具有两个线性层-第一个层是 **ReLU** 激活函数，第二层是 **Softmax** 激活功能：
3. 使用 PyTorch 的自定义模块，创建一个名为`Classifier`的类并定义模型的体系结构，使其具有两个线性层-第一个层是 **ReLU** 激活函数，第二层是 **Softmax** 激活功能：
```py
class Classifier(torch.nn.Module):
......@@ -603,7 +603,7 @@ batch_size = 100
3. 从训练集误差`A)`中减去贝叶斯误差。 保存差异，将用于进一步分析。
4. 从验证集错误`B)`中减去训练集错误，并保存差值。
5. 取步骤3和步骤4中计算出的差值，并使用以下一组规则。
5. 取步骤 3 和步骤 4 中计算出的差值，并使用以下一组规则。
如果在“步骤 3”中计算出的差大于在“步骤 4”中计算出的差，则该模型不适合，也称为遭受高偏差。
......@@ -639,7 +639,7 @@ batch_size = 100
该练习不需要进行任何编码，而是需要对先前活动的结果进行分析。
1. 假设贝叶斯误差为0.15，执行误差分析并诊断模型：
1. 假设贝叶斯误差为 0.15，执行误差分析并诊断模型：
```py
Bayes error (BE) = 0.15
......@@ -674,7 +674,7 @@ batch_size = 100
1. 导入与上一个活动相同的库。
2. 加载数据并从目标拆分要素。 接下来，使用 60:20:20 的分割比例将数据分割为三个子集（训练，验证和测试）。 最后，将验证和测试集转换为 PyTorch 张量，就像在上一个活动中一样。
3. 考虑到该模型存在较高的偏差，因此重点应放在通过向每个层添加其他层或单元来增加时期数或网络规模。 目的应该是将测试范围内的准确度近似为80％。
3. 考虑到该模型存在较高的偏差，因此重点应放在通过向每个层添加其他层或单元来增加时期数或网络规模。 目的应该是将测试范围内的准确度近似为 80％。
注意
......@@ -791,7 +791,7 @@ prediction = traced_script(input)
import final_model
```
2. 初始化Flask应用程序：
2. 初始化 Flask 应用程序：
```py
app = flask.Flask(__name__)
......@@ -811,13 +811,13 @@ prediction = traced_script(input)
model = load_model_checkpoint("checkpoint.pth
```
4. 定义可访问API的路径，以及可用于向API发送信息以执行操作的方法。 该语法称为装饰器，应位于函数之前：
4. 定义可访问 API 的路径，以及可用于向 API 发送信息以执行操作的方法。 该语法称为装饰器，应位于函数之前：
```py
@app.route('/prediction', methods=['POST'])
```
5. 定义一个执行所需动作的函数。在这种情况下，该函数将获取发送到API的信息，并将其反馈给之前加载的模型，以执行预测。一旦获得预测，该函数应返回一个响应，该响应将作为API请求的结果显示。
5. 定义一个执行所需动作的函数。在这种情况下，该函数将获取发送到 API 的信息，并将其反馈给之前加载的模型，以执行预测。一旦获得预测，该函数应返回一个响应，该响应将作为 API 请求的结果显示。
```py
def prediction():
......@@ -830,7 +830,7 @@ prediction = traced_script(input)
    return {"status":"ok", "result":int(top_class_test[0][0])}
```
6. 运行Flask应用。以下命令可以开始使用Web API。
6. 运行 Flask 应用。以下命令可以开始使用 Web API。
```py
app.run(debug=True, use_reloader=False)
......@@ -842,21 +842,21 @@ prediction = traced_script(input)
使用 Flask，我们将创建一个 Web API，该 Web API 会在调用时接收一些数据，并返回一段显示在浏览器中的文本。 请按照以下步骤完成此练习：
1. 在Jupyter 笔记本中，导入所需的库。
1. 在 Jupyter 笔记本中，导入所需的库。
```py
import flask
from flask import request
```
2. 初始化Flask应用。
2. 初始化 Flask 应用。
```py
app = flask.Flask(__name__)
app.config["DEBUG"] = True
```
3. 定义API的路由，使其为`/<name>`。将方法设置为`GET`。接下来，定义一个函数，该函数接收一个参数(`name`)并返回一个字符串，该字符串包含一个`h1`标签，其中有`HELLO`字样，后面是函数接收的参数。
3. 定义 API 的路由，使其为`/<name>`。将方法设置为`GET`。接下来，定义一个函数，该函数接收一个参数(`name`)并返回一个字符串，该字符串包含一个`h1`标签，其中有`HELLO`字样，后面是函数接收的参数。
```py
@app.route('/<name>', methods=['GET'])
......@@ -864,7 +864,7 @@ prediction = traced_script(input)
    return "<h1>HELLO {}</h1>".format(name.upper())
```
4. 运行Flask应用。
4. 运行 Flask 应用。
```py
app.run(debug=True, use_reloader=False)
......
new/dl-pt-workshop/4.md
浏览文件 @ 27bb5cf1
......@@ -235,7 +235,7 @@ CNN 可以执行不同的任务，这些任务适用于所有监督学习问题
Output depth = 1
```
2. 计算从卷积层派生的矩阵的输出形状，该卷积层的输入形状为`32 x 32 x 3`，10个形状为`5 x 5 x 3`的滤波器，填充为2：
2. 计算从卷积层派生的矩阵的输出形状，该卷积层的输入形状为`32 x 32 x 3`，10 个形状为`5 x 5 x 3`的滤波器，填充为 2：
```py
Output height = 32 - 5 + (2 * 2) + 1 = 32
......@@ -243,7 +243,7 @@ CNN 可以执行不同的任务，这些任务适用于所有监督学习问题
Output depth = 10
```
3. 计算从卷积层派生的矩阵的输出形状，该卷积层的输入形状为`128 x 128 x 1`，五个形状为`5 x 5 x 1`的滤波器，步幅为3：
3. 计算从卷积层派生的矩阵的输出形状，该卷积层的输入形状为`128 x 128 x 1`，五个形状为`5 x 5 x 1`的滤波器，步幅为 3：
```py
Output height = (128 - 5)/ 3 + 1 = 42
......@@ -251,7 +251,7 @@ CNN 可以执行不同的任务，这些任务适用于所有监督学习问题
Output depth = 5
```
4. 计算从卷积层派生的矩阵的输出形状，该卷积层的输入形状为`64 x 64 x 1`，形状为`8 x 8 x 1`的滤波器，填充为3，步幅为3：
4. 计算从卷积层派生的矩阵的输出形状，该卷积层的输入形状为`64 x 64 x 1`，形状为`8 x 8 x 1`的滤波器，填充为 3，步幅为 3：
```py
Output height = ((64 - 8 + (2 * 3)) / 3) +1 = 21.6 ≈ 21
......@@ -328,7 +328,7 @@ class CNN_network(nn.Module):
1. 卷积层，具有 16 个大小为 3 的滤镜，步幅和填充为 1。
2. 池层还具有大小为 2 的过滤器以及大小为 2 的步幅。
3. 卷积层，具有八个大小为 7 的滤镜，跨度为 1，填充为 3。
4. 池化层，其过滤器的大小为2，步幅也为2。
4. 池化层，其过滤器的大小为 2，步幅也为 2。
经过每一层后，矩阵的输出大小如下：
......@@ -570,7 +570,7 @@ test_loader = torch.utils.data.DataLoader(test_data, \
7. 定义训练模型所需的所有参数。 将纪元数设置为 50。
8. 训练您的网络，并确保保存训练和验证集的损失和准确率值。
9. 绘制两组的损失和准确率。
10. 在测试集上检查模型的准确度--它应该在72%左右。
10. 在测试集上检查模型的准确度--它应该在 72%左右。
注意
......@@ -674,7 +674,7 @@ test_data = datasets.CIFAR10('data', train=False, download=True, \
对于测试集，请勿添加任何其他转换。
3. 训练模型100个纪元。由此得到的训练集和验证集的损失和准确度图应与这里所示的相似。
3. 训练模型 100 个纪元。由此得到的训练集和验证集的损失和准确度图应与这里所示的相似。
![Figure 4.18: Resulting plot showing the loss of the sets ](img/B15778_04_18.jpg)
......@@ -760,7 +760,7 @@ class CNN(nn.Module):
1. 复制上一个活动中的笔记本。
2. 将批量归一化添加到每个卷积层以及第一个 FC 层。
3. 训练模型100个纪元。由此得到的训练集和验证集的损失和准确度图应该与这里的图相似。
3. 训练模型 100 个纪元。由此得到的训练集和验证集的损失和准确度图应该与这里的图相似。
![Figure 4.21: Resulting plot showing the loss of the sets ](img/B15778_04_21.jpg)
......@@ -770,7 +770,7 @@ class CNN(nn.Module):
图 4.22：结果图显示了集合的丢失
4. 计算结果模型在测试集上的准确度--它应该是78%左右。
4. 计算结果模型在测试集上的准确度--它应该是 78%左右。
注意
......
new/dl-pt-workshop/5.md
浏览文件 @ 27bb5cf1
......@@ -39,7 +39,7 @@
以下是解决样式转换问题时要遵循的步骤的简要说明：
1. **馈入输入**：内容和样式图像都将馈入模型，并且它们必须具有相同的形状。 这里的常见做法是调整样式图像的大小，以使其与内容图像具有相同的形状。
2. **加载模型**：牛津大学的VGG创建了一个模型架构，该模型在样式转换问题上表现出色，被称为VGG网络。 他们还将模型的参数提供给任何人，以便可以缩短或跳过模型的训练过程（这就是预训练模型的目的）。
2. **加载模型**：牛津大学的 VGG 创建了一个模型架构，该模型在样式转换问题上表现出色，被称为 VGG 网络。 他们还将模型的参数提供给任何人，以便可以缩短或跳过模型的训练过程（这就是预训练模型的目的）。
注意
......@@ -171,7 +171,7 @@ transforms.Compose([transforms.Normalize((-0.5/0.25, \
    return image
```
4. 调用该函数以加载内容和样式图像。 将狗图像用作内容图像，将Matisse图像用作样式图像，这两者都可以在本书的GitHub存储库中找到：
4. 调用该函数以加载内容和样式图像。 将狗图像用作内容图像，将 Matisse 图像用作样式图像，这两者都可以在本书的 GitHub 存储库中找到：
```py
content_img = image_loader("images/dog.jpg")
......@@ -187,7 +187,7 @@ transforms.Compose([transforms.Normalize((-0.5/0.25, \
前面的代码片段将保存图像的变量分配给 GPU，以便使用这些变量的所有操作都由 GPU 处理。
5. 调用该函数以加载内容和样式图像。 将狗图像用作内容图像，将Matisse图像用作样式图像，这两者都可以在本书的GitHub存储库中找到：...
5. 调用该函数以加载内容和样式图像。 将狗图像用作内容图像，将 Matisse 图像用作样式图像，这两者都可以在本书的 GitHub 存储库中找到：...
```py
unloader = transforms.Compose([\
......@@ -286,7 +286,7 @@ for param in model.parameters():
使用与上一练习相同的笔记本，本练习旨在加载预先训练的模型，该模型将在后续练习中使用我们先前加载的图像执行样式转换任务。
1. 打开上一个练习中的笔记本。
2. 从PyTorch加载VGG-19预训练模型：
2. 从 PyTorch 加载 VGG-19 预训练模型：
```py
model = models.vgg19(pretrained=True).feature
......@@ -597,7 +597,7 @@ style_features = features_extractor(style_img, model, \
        plt.show()
```
6. 绘制内容和目标图像来比较结果。这可以通过使用`tensor2image`函数来实现，我们在之前的练习中创建了这个函数，以便将张量转换为可以使用`matplotlib`打印的PIL图像。
6. 绘制内容和目标图像来比较结果。这可以通过使用`tensor2image`函数来实现，我们在之前的练习中创建了这个函数，以便将张量转换为可以使用`matplotlib`打印的 PIL 图像。
```py
fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(20, 10))
......@@ -642,7 +642,7 @@ style_features = features_extractor(style_img, model, \
7. 创建一个字典，将相关层（键）的索引映射到名称（值）。 然后，创建一个函数以提取相关层的特征图。 使用它们提取两个输入图像的特征。
8. 计算样式特征的克矩阵。 另外，创建初始目标图像。
9. 设置不同样式层的权重以及内容和样式损失的权重。
10. 运行模型500次迭代。在开始训练模型之前，定义Adam优化算法，以0.001作为学习率。
10. 运行模型 500 次迭代。在开始训练模型之前，定义 Adam 优化算法，以 0.001 作为学习率。
注意
......
new/dl-pt-workshop/6.md
浏览文件 @ 27bb5cf1
......@@ -32,7 +32,7 @@
这是通过使用 RNN 可以执行的不同任务的一些简要说明：
* **NLP**。这指的是机器代表人类语言的能力。这可能是深度学习中探索最多的领域之一，也无疑是利用RNN时首选的数据问题。其思路是以文本作为输入数据来训练网络，如诗词和书籍等，目的是创建一个能够生成此类文本的模型。
* **NLP**。这指的是机器代表人类语言的能力。这可能是深度学习中探索最多的领域之一，也无疑是利用 RNN 时首选的数据问题。其思路是以文本作为输入数据来训练网络，如诗词和书籍等，目的是创建一个能够生成此类文本的模型。
NLP 通常用于创建聊天机器人（虚拟助手）。 通过从以前的人类对话中学习，NLP 模型能够帮助一个人解决常见问题或疑问。 因此，他们的句子表达能力仅限于他们在训练过程中所学到的内容，这意味着他们只能回答所学的内容。
......@@ -42,7 +42,7 @@
图 6.1：Facebook 的 Messenger 聊天机器人
* **语音识别**。与NLP类似，语音识别试图理解和表示人类语言。然而，这里的区别在于，前者（NLP）是以文本的形式进行训练并产生输出，而后者（语音识别）则使用音频片段。随着这一领域的发展，以及大公司的兴趣，这些模型能够理解不同的语言，甚至不同的口音和发音。
* **语音识别**。与 NLP 类似，语音识别试图理解和表示人类语言。然而，这里的区别在于，前者（NLP）是以文本的形式进行训练并产生输出，而后者（语音识别）则使用音频片段。随着这一领域的发展，以及大公司的兴趣，这些模型能够理解不同的语言，甚至不同的口音和发音。
语音识别设备的一个流行示例是 Alexa –来自亚马逊的语音激活虚拟助手模型：
......@@ -50,7 +50,7 @@
图 6.2：亚马逊的 Alexa
* **机器翻译**。这是指机器有效翻译人类语言的能力。据此，输入是源语言（如西班牙语），输出是目标语言（如英语）。NLP与机器翻译的主要区别在于，在后者中，输出是在将整个输入输入输入到模型后建立的。
* **机器翻译**。这是指机器有效翻译人类语言的能力。据此，输入是源语言（如西班牙语），输出是目标语言（如英语）。NLP 与机器翻译的主要区别在于，在后者中，输出是在将整个输入输入输入到模型后建立的。
随着全球化的兴起和当今休闲旅行的普及，人们需要使用多种语言。 因此，出现了能够在不同语言之间进行翻译的设备。 该领域的最新成果之一是 Google 的 Pixel Buds，它可以实时执行翻译：
......@@ -58,7 +58,7 @@
图 6.3：Google 的像素芽
* **时间序列预测**。RNN的一个不太流行的应用是根据历史数据预测未来的数据点序列。由于RNN能够保留内部记忆，使时间序列分析能够考虑过去的不同时间段来进行未来的预测或一系列预测，因此RNN特别擅长这项任务。
* **时间序列预测**。RNN 的一个不太流行的应用是根据历史数据预测未来的数据点序列。由于 RNN 能够保留内部记忆，使时间序列分析能够考虑过去的不同时间段来进行未来的预测或一系列预测，因此 RNN 特别擅长这项任务。
这通常用于预测未来的收入或需求，这有助于公司为不同的情况做好准备。 下图显示了每月销售额的预测：
......@@ -140,7 +140,7 @@
import torch
```
2. 创建一个`10×5`大小的Pandas DataFrame，里面充满了从0到100的随机数。命名五列如下：`["Week1", "Week2", "Week3", "Week4", "Week5"]`。
2. 创建一个`10×5`大小的 Pandas DataFrame，里面充满了从 0 到 100 的随机数。命名五列如下：`["Week1", "Week2", "Week3", "Week4", "Week5"]`。
确保将随机种子设置为`0`，以便能够重现本书中显示的结果：
......@@ -456,7 +456,7 @@ onehot = onehot_flat.reshape((batch.shape[0],\
在本练习中，您将预处理文本片段，然后将其转换为一键式矩阵。 请按照以下步骤完成此练习：
1. 导入NumPy。
1. 导入 NumPy。
```py
import numpy as np
......@@ -491,7 +491,7 @@ onehot = onehot_flat.reshape((batch.shape[0],\
    encoded.append(indexer[c])
```
5. 将编码变量转换为NumPy数组，并对其进行重塑，使句子被分成两个大小相同的序列。
5. 将编码变量转换为 NumPy 数组，并对其进行重塑，使句子被分成两个大小相同的序列。
```py
encoded = np.array(encoded).reshape(2,-1)
......@@ -688,13 +688,13 @@ while starter[-1] != "." and counter < 50:
6. 创建一个定义网络架构的类。 该类应包含一个用于初始化 LSTM 层状态的附加函数。
7. 请确定要从数据集中创建的批量数量，请记住每个批量应包含 100 个序列，每个批量的长度应为 50。接下来，将编码数据拆分为 100 个序列。
8. 使用 256 作为隐藏单位数（总共两个循环层）实例化模型。
9. 定义损失函数和优化算法。使用Adam优化器和交叉熵损失。训练网络20个纪元。
9. 定义损失函数和优化算法。使用 Adam 优化器和交叉熵损失。训练网络 20 个纪元。
注意
根据您的资源，训练过程将花费很长时间，这就是为什么建议仅运行 20 个纪元的原因。 但是，本书的 GitHub 存储库中提供了可以在 GPU 上运行的代码的等效版本。 这将使您运行更多的时代并获得出色的性能。
10. 在每一个时代，数据必须被划分为50个序列长度的批次。这意味着每个时代将有100个序列，每个序列的长度为50。
10. 在每一个时代，数据必须被划分为 50 个序列长度的批次。这意味着每个时代将有 100 个序列，每个序列的长度为 50。
注意
......@@ -758,7 +758,7 @@ NLP 是**人工智能**（**AI**）的子字段，它通过使计算机能够理
与其他任何数据问题一样，您需要将数据加载到代码中，同时要记住对不同的数据类型使用不同的方法。 除了将整个单词集转换为小写字母之外，数据还经过一些基本的转换，可让您将数据输入网络。 最常见的转换如下：
* **消除标点符号**。在为NLP目的逐字处理文本数据时，删除任何标点符号。这样做是为了避免把同一个词当作两个独立的词，因为其中一个词后面有句号、逗号或任何其他特殊字符。一旦实现了这一点，就可以定义一个包含输入文本词汇的列表（也就是整个词集）。
* **消除标点符号**。在为 NLP 目的逐字处理文本数据时，删除任何标点符号。这样做是为了避免把同一个词当作两个独立的词，因为其中一个词后面有句号、逗号或任何其他特殊字符。一旦实现了这一点，就可以定义一个包含输入文本词汇的列表（也就是整个词集）。
这可以通过使用`string`模块的`punctuation`预初始化的字符串来完成，该字符串提供了可用于在文本序列中标识它们的标点符号列表，如 以下代码段：
......
new/dl-pt-workshop/7.md
浏览文件 @ 27bb5cf1
......@@ -6,7 +6,7 @@
### 解决方案
1. 导入所需的库，包括pandas，用于导入CSV文件。
1. 导入所需的库，包括 pandas，用于导入 CSV 文件。
```py
import pandas as pd
......@@ -15,13 +15,13 @@
import matplotlib.pyplot as plt
```
2. 读取包含数据集的CSV文件。
2. 读取包含数据集的 CSV 文件。
```py
data = pd.read_csv("SomervilleHappinessSurvey2015.csv")
```
3. 将输入特征与目标分开。注意，目标位于CSV文件的第一列。将值转换为张量，确保值转换为浮点数。
3. 将输入特征与目标分开。注意，目标位于 CSV 文件的第一列。将值转换为张量，确保值转换为浮点数。
```py
x = torch.tensor(data.iloc[:,1:].values).float()
......@@ -35,7 +35,7 @@
                      nn.Sigmoid())
```
5. 定义要使用的损失函数。使用MSE损失函数。
5. 定义要使用的损失函数。使用 MSE 损失函数。
```py
loss_function = torch.nn.MSELoss()
......@@ -47,7 +47,7 @@
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
```
7. 运行优化100次迭代。每迭代10次，打印并保存损失值。
7. 运行优化 100 次迭代。每迭代 10 次，打印并保存损失值。
```py
losses = []
......@@ -97,7 +97,7 @@
import pandas as pd
```
2. 使用pandas，加载`.csv`文件。
2. 使用 pandas，加载`.csv`文件。
```py
data = pd.read_csv("YearPredictionMSD.csv", nrows=50000)
......@@ -225,7 +225,7 @@
将 torch.nn 导入为 nn
2. 将我们在上一个活动中创建的所有三组数据的特征从目标中分割出来。将DataFrames转换为张量。
2. 将我们在上一个活动中创建的所有三组数据的特征从目标中分割出来。将 DataFrames 转换为张量。
x_train = torch.tensor（x_train.values）.float（）
......@@ -261,7 +261,7 @@
优化程序= torch.optim.Adam（model.parameters（），lr = 0.01）
5. 使用`for`循环来训练网络，迭代步数为3000步。
5. 使用`for`循环来训练网络，迭代步数为 3000 步。
对于我的范围（3000）：
......@@ -343,7 +343,7 @@
y =数据[“下个月的默认付款”]
4. 使用scikit-learn的`train_test_split`函数，将数据集分割成训练集、验证集和测试集。使用60:20:20的分割比例。将`random_state`设置为0。
4. 使用 scikit-learn 的`train_test_split`函数，将数据集分割成训练集、验证集和测试集。使用 60:20:20 的分割比例。将`random_state`设置为 0。
X_new，X_test，\
......@@ -609,7 +609,7 @@
y_test_torch =火炬张量（y_test.values）
3. 考虑到该模型存在较高的偏差，重点应放在增加纪元的数量上，或通过在每层中增加额外的层或单位来增加网络的规模。目标应该是将验证集的准确度近似到80%。
3. 考虑到该模型存在较高的偏差，重点应放在增加纪元的数量上，或通过在每层中增加额外的层或单位来增加网络的规模。目标应该是将验证集的准确度近似到 80%。
之后，将显示性能最佳的模型，该模型是在几次微调尝试之后实现的。 首先，定义模型架构和正向传递，如以下代码片段所示：
......@@ -828,7 +828,7 @@
图 3.19：final_model.py 的屏幕截图
3. 在Jupyter 笔记本中，保存表现最好的模型。请务必保存与输入单位相关的信息，以及模型的参数。将其命名为`checkpoint.pth`。
3. 在 Jupyter 笔记本中，保存表现最好的模型。请务必保存与输入单位相关的信息，以及模型的参数。将其命名为`checkpoint.pth`。
检查点= {“输入”：X_train.shape [1]，\
......@@ -837,7 +837,7 @@
torch.save（检查点，“ checkpoint.pth”）
4. 打开一个新的 Jupyter Notebook。
5. 导入PyTorch，以及我们在“步骤 2”中创建的Python文件。
5. 导入 PyTorch，以及我们在“步骤 2”中创建的 Python 文件。
进口火炬
......@@ -879,7 +879,7 @@
通过打印`top_class_test`，我们可以获得模型的预测，在这种情况下，该预测等于`1`（是）。
8. 使用JIT模块转换模型。
8. 使用 JIT 模块转换模型。
traced_script = torch.jit.trace（模型，例如\
......@@ -895,7 +895,7 @@
通过打印`top_class_test_2`，我们从模型的跟踪脚本表示中获得了预测，该预测再次等于`1`（是）。
10. 打开一个新的Jupyter 笔记本，并导入所需的库来使用Flask创建一个API，以及加载保存的模型的库。
10. 打开一个新的 Jupyter 笔记本，并导入所需的库来使用 Flask 创建一个 API，以及加载保存的模型的库。
进口烧瓶
......@@ -905,7 +905,7 @@
导入 final_model
11. 初始化Flask应用。
11. 初始化 Flask 应用。
app = flask.Flask（__ name__）
......@@ -925,7 +925,7 @@
模型= load_model_checkpoint（“ checkpoint.pth”）
13. 定义API的路由为`/prediction`，并将方法设置为`POST`。然后，定义接收`POST`数据的函数，并将其反馈给模型进行预测。
13. 定义 API 的路由为`/prediction`，并将方法设置为`POST`。然后，定义接收`POST`数据的函数，并将其反馈给模型进行预测。
@ app.route（'/ prediction'，methods = ['POST']）
......@@ -945,7 +945,7 @@
return {“ status”：“ ok”，“ result”：int（top_class_test [0] [0]）}
14. 运行Flask应用。
14. 运行 Flask 应用。
app.run（debug = True，use_reloader = False）
......@@ -997,7 +997,7 @@
(0.5, 0.5, 0.5))])
3. 设置批量大小为100张图像，并从 **CIFAR10** 数据集下载训练和测试数据。
3. 设置批量大小为 100 张图像，并从 **CIFAR10** 数据集下载训练和测试数据。
batch_size = 100
......@@ -1509,7 +1509,7 @@
(0.5, 0.5, 0.5))])}
3. 训练模型100个纪元。
3. 训练模型 100 个纪元。
如果您的计算机具有可用的 GPU，请确保使用代码的 GPU 版本来训练模型。
......@@ -1597,7 +1597,7 @@
返回 x
3. 训练模型100个纪元。
3. 训练模型 100 个纪元。
如果您的计算机具有可用的 GPU，请确保使用代码的 GPU 版本来训练模型。 训练和验证集的损失和准确率的结果图应类似于此处所示：
......@@ -1763,7 +1763,7 @@
plt.show()
6. 加载VGG-19模型。
6. 加载 VGG-19 模型。
模型= models.vgg19（pretrained = True）。功能
......@@ -1851,7 +1851,7 @@
Beta = 1e5
10. 运行模型500次迭代。在开始训练模型之前，定义Adam优化算法，以`0.001`作为学习率。
10. 运行模型 500 次迭代。在开始训练模型之前，定义 Adam 优化算法，以`0.001`作为学习率。
注意
......@@ -1975,7 +1975,7 @@
从火炬进口 nn，乐观
2. 加载数据集，然后对其进行切片，使其包含所有的行，但只包含索引1到52的列。
2. 加载数据集，然后对其进行切片，使其包含所有的行，但只包含索引 1 到 52 的列。
数据= pd.read_csv（“ Sales_Transactions_Dataset_Weekly.csv”）
......@@ -2077,7 +2077,7 @@
)
7. 定义一个损失函数，一个优化算法，以及训练网络的周期数。使用MSE损失函数、Adam优化器和10,000个纪元来完成这一任务。
7. 定义一个损失函数，一个优化算法，以及训练网络的周期数。使用 MSE 损失函数、Adam 优化器和 10,000 个纪元来完成这一任务。
loss_function = nn.MSELoss（）
......@@ -2207,7 +2207,7 @@
导入功能为 F 的 torch.nn。
2. 打开并将《爱丽丝梦游仙境》中的文字读入笔记本。打印前50个字符的摘要和文本文件的总长度。
2. 打开并将《爱丽丝梦游仙境》中的文字读入笔记本。打印前 50 个字符的摘要和文本文件的总长度。
使用 open（'alice.txt' ，'r'，encoding ='latin1'）作为 f：
......@@ -2229,7 +2229,7 @@
长度：145178
4. 将数据集的每个字母编码为其配对的整数。打印前50个编码字符和数据集编码版本的总长度。
4. 将数据集的每个字母编码为其配对的整数。打印前 50 个编码字符和数据集编码版本的总长度。
indexed_data = []
......@@ -2267,7 +2267,7 @@
此函数采用二维矩阵并将其展平。 接下来，它创建一个平坦矩阵的形状和包含字母的字典长度的零填充矩阵（在“步骤 3”中创建）。 接下来，它用一个字符填充对应于批量中每个字符的字母。 最后，它对矩阵进行整形以使其为三维。
6. 创建一个定义网络架构的类。这个类应该包含一个额外的函数，用于初始化LSTM层的状态。
6. 创建一个定义网络架构的类。这个类应该包含一个额外的函数，用于初始化 LSTM 层的状态。
LSTM（nn.Module）类：
......@@ -2315,7 +2315,7 @@
此类包含`__init__`方法（其中定义了网络的架构），`forward`方法（用于确定通过层的数据流）以及`init_state`用零初始化隐藏状态和单元状态的方法。
7. 确定要从数据集中创建的批次数量，记住每个批次应该包含100个序列，每个序列的长度为50个。接下来，将编码后的数据分成100个序列。
7. 确定要从数据集中创建的批次数量，记住每个批次应该包含 100 个序列，每个序列的长度为 50 个。接下来，将编码后的数据分成 100 个序列。
＃每批序列​​数
......@@ -2353,7 +2353,7 @@
模型= LSTM（len（chars），256，2）.to（“ cuda”）
9. 定义损失函数和优化算法。使用Adam优化器和交叉熵损失来完成。训练网络`20`周期。
9. 定义损失函数和优化算法。使用 Adam 优化器和交叉熵损失来完成。训练网络`20`周期。
loss_function = nn.CrossEntropyLoss（）
......@@ -2365,7 +2365,7 @@
时代= 500
10. 在每个时代，数据必须被划分为序列长度为50的批次。这意味着每个时代将有100个批次，每个批次的序列长度为50。
10. 在每个时代，数据必须被划分为序列长度为 50 的批次。这意味着每个时代将有 100 个批次，每个批次的序列长度为 50。
损失= []
......@@ -2613,7 +2613,7 @@
导入功能为 F 的 torch.nn。
2. 加载包含亚马逊1,000条产品评论的数据集，这些评论与`0`(负面评论)或`1`(正面评论)的标签配对。将数据分离成两个变量--一个包含评论，另一个包含标签。
2. 加载包含亚马逊 1,000 条产品评论的数据集，这些评论与`0`(负面评论)或`1`(正面评论)的标签配对。将数据分离成两个变量--一个包含评论，另一个包含标签。
数据= pd.read_csv（“ amazon_cells_labelled.txt”，sep =“ \ t”，\
......@@ -2689,7 +2689,7 @@
该类包含用于定义网络架构的`__init__`方法和用于确定数据流经不同层的方式的`forward`方法。
7. 使用64个嵌入维度和128个神经元为三个LSTM层实例化模型。
7. 使用 64 个嵌入维度和 128 个神经元为三个 LSTM 层实例化模型。
模型= LSTM（仅（词汇），64、128、3）
......@@ -2707,7 +2707,7 @@
)
8. 定义损失函数，优化算法，以及训练的纪元数。例如，您可以使用二进制交叉熵损失作为损失函数，Adam优化器，并训练10个周期。
8. 定义损失函数，优化算法，以及训练的纪元数。例如，您可以使用二进制交叉熵损失作为损失函数，Adam 优化器，并训练 10 个周期。
loss_function = nn.BCELoss（）
......
new/handson-nlp-pt-1x/2.md
浏览文件 @ 27bb5cf1
......@@ -40,7 +40,7 @@
这表明 PyTorch 中的张量被保存为它们自己的数据类型（与 NumPy 中的数组保存方式相同）。
2. 我们可以使用标准的Python运算符来执行乘法等基本操作。
2. 我们可以使用标准的 Python 运算符来执行乘法等基本操作。
x = torch.tensor（[1。，2.]）
......@@ -188,7 +188,7 @@ PyTorch 与其他深度学习框架之间的另一个主要区别是语法。 Py
请注意，我们将输入重塑为`[1, 1, 28, 28]`，每个张量为 1,000 张图像 由 28x28 像素组成。
2. 接下来，我们将我们的训练数据和训练标签转换为PyTorch 张量，以便它们可以被输入到神经网络中。
2. 接下来，我们将我们的训练数据和训练标签转换为 PyTorch 张量，以便它们可以被输入到神经网络中。
X =火炬张量（train.astype（float））
......@@ -282,7 +282,7 @@ opt = optim.Adam（model.parameters（），lr = 0.001）
最后，我们实际上可以开始训练我们的网络了：
1. 首先，创建一个循环，为我们训练的每一个纪元运行一次。在这里，我们将在 50 个 epoch 中运行我们的训练循环。我们首先将输入的图像张量和输出的标签张量转化为PyTorch变量。一个**变量**是一个PyTorch对象，它包含一个`backward()`方法，我们可以使用该方法通过我们的网络进行反向传播。
1. 首先，创建一个循环，为我们训练的每一个纪元运行一次。在这里，我们将在 50 个 epoch 中运行我们的训练循环。我们首先将输入的图像张量和输出的标签张量转化为 PyTorch 变量。一个**变量**是一个 PyTorch 对象，它包含一个`backward()`方法，我们可以使用该方法通过我们的网络进行反向传播。
对于范围（50）中的时代：
......@@ -456,7 +456,7 @@ preds = len（预测标签）
输入的长度为`corpus_size`，这只是我们的语料库中唯一词的总数。 这是因为对模型的每个输入都是一个词袋表示，由每个句子中的单词计数组成，如果给定单词​​未出现在我们的句子中，则计数为 0。 我们的输出大小为 2，这是我们可以预测的语言数量。 我们的最终预测将包括我们的句子是英语的概率与我们的句子是西班牙文的概率，而我们的最终预测是概率最高的那个。
4. 接下来，我们定义一些实用函数。我们首先定义`make_bow_vector`，它将句子转化为一个词袋的表示。我们首先创建一个由所有零组成的向量。然后，我们对它们进行循环，对于句子中的每一个词，我们将该词在词袋向量中的索引数增加1。最后，我们使用`.view()`对这个向量进行重塑，以便进入我们的分类器。
4. 接下来，我们定义一些实用函数。我们首先定义`make_bow_vector`，它将句子转化为一个词袋的表示。我们首先创建一个由所有零组成的向量。然后，我们对它们进行循环，对于句子中的每一个词，我们将该词在词袋向量中的索引数增加 1。最后，我们使用`.view()`对这个向量进行重塑，以便进入我们的分类器。
def make_bow_vector（句子，word_index）：
......@@ -474,7 +474,7 @@ preds = len（预测标签）
返回 torch.LongTensor（[label_index [label]]）
6. 现在我们可以创建一个模型的实例，准备进行训练。我们还将我们的损失函数定义为负对数似然，因为我们使用的是对数softmax函数，然后定义我们的优化器，以便使用标准的**随机梯度下降**（**SGD**）。
6. 现在我们可以创建一个模型的实例，准备进行训练。我们还将我们的损失函数定义为负对数似然，因为我们使用的是对数 softmax 函数，然后定义我们的优化器，以便使用标准的**随机梯度下降**（**SGD**）。
模型= BagofWordsClassifier（语言，语料库大小）
......@@ -523,7 +523,7 @@ print（'Epoch：'，str（epoch + 1），'，Loss：'+ str（loss.item（））
在这里，我们可以看到，随着模型的学习，我们的损失随着时间而减少。 尽管本例中的训练集很小，但是我们仍然可以证明我们的模型学到了一些有用的东西，如下所示：
1. 我们根据未接受模型训练的测试数据中的几句话来评估模型。 在这里，我们首先设置`torch.no_grad()`，这将停用 **autograd** 引擎，因为由于我们不再训练模型，因此不再需要计算梯度。 接下来，我们将测试句子转换为词袋向量，并将其输入模型以获取预测。
2. 然后我们只需打印出句子、句子的真实标签，再打印出预测的概率。注意，我们将预测值从对数概率转化回概率。我们为每个预测得到两个概率，但如果我们参考标签索引，我们可以看到第一个概率（索引0）对应的是西班牙语，而另一个概率对应的是英语。
2. 然后我们只需打印出句子、句子的真实标签，再打印出预测的概率。注意，我们将预测值从对数概率转化回概率。我们为每个预测得到两个概率，但如果我们参考标签索引，我们可以看到第一个概率（索引 0）对应的是西班牙语，而另一个概率对应的是英语。
def make_predictions（data）：
......
new/handson-nlp-pt-1x/3.md
浏览文件 @ 27bb5cf1
......@@ -39,7 +39,7 @@
我们可以通过检查单个 GLoVe 向量来验证这是正确的：
1. 我们首先创建一个简单的函数来从文本文件中加载我们的GLoVe向量。这只是建立一个字典，其中索引是语料库中的每个词，值是嵌入向量。
1. 我们首先创建一个简单的函数来从文本文件中加载我们的 GLoVe 向量。这只是建立一个字典，其中索引是语料库中的每个词，值是嵌入向量。
def loadGlove（path）：
......@@ -75,7 +75,7 @@
![](img/Formula_03_001.jpg)
3. 我们可以使用 **Sklearn** 中的`cosine_similarity()`函数在Python中轻松计算。我们可以看到，**猫**和**狗**有相似的向量，因为它们都是动物。
3. 我们可以使用 **Sklearn** 中的`cosine_similarity()`函数在 Python 中轻松计算。我们可以看到，**猫**和**狗**有相似的向量，因为它们都是动物。
余弦相似度（手套['cat']。reshape（1，-1），手套['dog']。reshape（1，-1））
......@@ -226,7 +226,7 @@ X = ["is", "a", "learning", "framework"]; y = "deep"
接下来，我们在 PyTorch 中定义 **CBOW** 模型。 我们定义嵌入层，以便它接受语料库长度的向量，并输出单个嵌入。 我们将线性层定义为一个全连接层，该层将嵌入并输出`64`的向量。 我们将最后一层定义为与文本语料库相同长度的分类层。
6. 我们通过获取和求和所有输入语境词的嵌入来定义我们的前向过程，然后通过ReLU激活函数的全连接层，最后进入分类层。然后通过ReLU激活函数的全连接层，最后进入分类层，分类层预测语料库中哪个词与上下文词的求和嵌入对应最多。
6. 我们通过获取和求和所有输入语境词的嵌入来定义我们的前向过程，然后通过 ReLU 激活函数的全连接层，最后进入分类层。然后通过 ReLU 激活函数的全连接层，最后进入分类层，分类层预测语料库中哪个词与上下文词的求和嵌入对应最多。
CBOW 类（torch.nn.Module）：
......@@ -274,7 +274,7 @@ X = ["is", "a", "learning", "framework"]; y = "deep"
优化程序= torch.optim.SGD（model.parameters（），lr = 0.01）
9. 然后，我们创建一个辅助函数，将我们的输入语境词，得到每一个语境词的词索引，并将其转换为一个长度为4的张量，形成我们神经网络的输入。
9. 然后，我们创建一个辅助函数，将我们的输入语境词，得到每一个语境词的词索引，并将其转换为一个长度为 4 的张量，形成我们神经网络的输入。
def make_sentence_vector（sentence，word_dict）：
......@@ -290,7 +290,7 @@ X = ["is", "a", "learning", "framework"]; y = "deep"
图 3.11 –张量值
10. 现在，我们训练我们的网络。我们循环通过100个周期，对于每一个通道，我们循环通过我们所有的上下文词，也就是目标词对。对于这些对，我们使用`make_sentence_vector()`加载上下文句子，并使用我们当前的模型状态来获得预测。我们根据我们的实际目标评估这些预测，以获得我们的损失。我们反推计算梯度，并通过我们的优化器来更新权重。最后，我们将该时代的所有损失相加并打印出来。在这里，我们可以看到，我们的损失正在减少，这表明我们的模型正在学习。
10. 现在，我们训练我们的网络。我们循环通过 100 个周期，对于每一个通道，我们循环通过我们所有的上下文词，也就是目标词对。对于这些对，我们使用`make_sentence_vector()`加载上下文句子，并使用我们当前的模型状态来获得预测。我们根据我们的实际目标评估这些预测，以获得我们的损失。我们反推计算梯度，并通过我们的优化器来更新权重。最后，我们将该时代的所有损失相加并打印出来。在这里，我们可以看到，我们的损失正在减少，这表明我们的模型正在学习。
对于范围（100）中的时代：
......@@ -354,7 +354,7 @@ X = ["is", "a", "learning", "framework"]; y = "deep"
图 3.13 –预测值
12. 现在我们已经有了一个训练好的模型，我们能够使用`get_word_embedding()`函数，以便返回我们语料库中任何单词的20维单词嵌入。如果我们在另一个NLP任务中需要我们的嵌入，我们实际上可以从整个嵌入层中提取权重，并将其用于我们的新模型中。
12. 现在我们已经有了一个训练好的模型，我们能够使用`get_word_embedding()`函数，以便返回我们语料库中任何单词的 20 维单词嵌入。如果我们在另一个 NLP 任务中需要我们的嵌入，我们实际上可以从整个嵌入层中提取权重，并将其用于我们的新模型中。
打印（model.get_word_emdedding（'leap'））
......@@ -442,7 +442,7 @@ My favourite language is ___
接下来，我们将学习 NLP 的分词化，这是一种预处理文本的方式，可以输入到模型中。 标记化将我们的句子分成较小的部分。 这可能涉及将一个句子拆分成单个单词，或者将整个文档分解成单个句子。 这是 NLP 必不可少的预处理步骤，可以在 Python 中相当简单地完成：
1. 我们先接收一个基本的句子，用NLTK中的**分词器**把这个句子分割成各个词。
1. 我们先接收一个基本的句子，用 NLTK 中的**分词器**把这个句子分割成各个词。
text ='这是一个句子。'
......@@ -490,7 +490,7 @@ My favourite language is ___
图 3.21 –将多个句子分解为单词
5. 在标记化的过程中，还有一个可选的步骤，那就是去除停顿词。歇后语是非常常见的词，对句子的整体意思没有帮助。这些词包括`a`、`I`和`or`等。我们可以使用下面的代码从NLTK中打印出一个完整的列表。
5. 在标记化的过程中，还有一个可选的步骤，那就是去除停顿词。歇后语是非常常见的词，对句子的整体意思没有帮助。这些词包括`a`、`I`和`or`等。我们可以使用下面的代码从 NLTK 中打印出一个完整的列表。
stop_words = stopwords.words（'english'）
......@@ -648,7 +648,7 @@ This is a small giraffe
在这里，我们将使用 NLTK 数据集中的 Emma 语料对数据集实施 TF-IDF。 该数据集由 Jane Austen 的书《Emma》中的句子组成，我们希望为这些句子中的每一个计算一个嵌入式向量表示：
1. 我们首先导入我们的数据集，并循环处理每一个句子，删除所有标点符号和非字母数字字符（如星号）。我们选择在我们的数据集中留下停顿词，以展示TF-IDF如何处理这些词，因为这些词出现在许多文档中，因此具有非常低的IDF。我们在语料库中创建了一个解析句子的列表和一组不同的词。
1. 我们首先导入我们的数据集，并循环处理每一个句子，删除所有标点符号和非字母数字字符（如星号）。我们选择在我们的数据集中留下停顿词，以展示 TF-IDF 如何处理这些词，因为这些词出现在许多文档中，因此具有非常低的 IDF。我们在语料库中创建了一个解析句子的列表和一组不同的词。
艾玛= nltk.corpus.gutenberg.sents（'austen-emma.txt'）
......@@ -668,7 +668,7 @@ This is a small giraffe
emma_word_set =设置（emma_word_set）
2. 接下来，我们创建一个函数，将返回给定文档中某个词的术语频率。我们以文档的长度来给出我们的词数，并计算这个词在文档中的出现次数，然后再返回比率。在这里，我们可以看到`ago`这个词在句子中出现了一次，而这个句子的长度是41个字，我们得到的词频是0.024。
2. 接下来，我们创建一个函数，将返回给定文档中某个词的术语频率。我们以文档的长度来给出我们的词数，并计算这个词在文档中的出现次数，然后再返回比率。在这里，我们可以看到`ago`这个词在句子中出现了一次，而这个句子的长度是 41 个字，我们得到的词频是 0.024。
def TermFreq（文档，单词）：
......@@ -708,7 +708,7 @@ This is a small giraffe
df_dict ['ago']
4. 在这里，我们可以看到，`ago`这个词在我们的文档中出现了32次。使用这个词典，我们可以非常容易地计算出我们的反文档频率，方法是用文档频率除以文档总数，然后取这个值的对数。请注意，当这个词在语料库中没有出现时，我们如何在文档频率上加一，以避免除以零的错误。
4. 在这里，我们可以看到，`ago`这个词在我们的文档中出现了 32 次。使用这个词典，我们可以非常容易地计算出我们的反文档频率，方法是用文档频率除以文档总数，然后取这个值的对数。请注意，当这个词在语料库中没有出现时，我们如何在文档频率上加一，以避免除以零的错误。
def InverseDocumentFrequency（word）：
......@@ -726,7 +726,7 @@ This is a small giraffe
InverseDocumentFrequency（'ago'）
5. 最后，我们只需将词频和逆文档频率结合起来，就可以得到每个词/文档对的TF-IDF权重。
5. 最后，我们只需将词频和逆文档频率结合起来，就可以得到每个词/文档对的 TF-IDF 权重。
def TFIDF（doc，word）：
......@@ -752,7 +752,7 @@ This is a small giraffe
接下来，我们可以显示这些 TF-IDF 加权如何应用于嵌入：
1. 我们首先加载我们预先计算的GLoVe嵌入，以提供我们语料库中单词的初始嵌入表示。
1. 我们首先加载我们预先计算的 GLoVe 嵌入，以提供我们语料库中单词的初始嵌入表示。
def loadGlove（path）：
......@@ -774,7 +774,7 @@ This is a small giraffe
手套= loadGlove（'glove.6B.50d.txt'）
2. 然后，我们计算文档中所有单个嵌入的非加权平均数，以获得句子整体的向量表示。我们简单地循环浏览文档中的所有单词，从GLoVe字典中提取嵌入物，然后计算所有这些向量的平均值。
2. 然后，我们计算文档中所有单个嵌入的非加权平均数，以获得句子整体的向量表示。我们简单地循环浏览文档中的所有单词，从 GLoVe 字典中提取嵌入物，然后计算所有这些向量的平均值。
嵌入= []
......@@ -792,7 +792,7 @@ This is a small giraffe
图 3.31 –均值嵌入
3. 我们重复这个过程来计算我们的TF-IDF加权文档向量，但这次，我们在求平均之前，先将我们的向量乘以它们的TF-IDF加权。
3. 我们重复这个过程来计算我们的 TF-IDF 加权文档向量，但这次，我们在求平均之前，先将我们的向量乘以它们的 TF-IDF 加权。
嵌入= []
......@@ -812,7 +812,7 @@ This is a small giraffe
图 3.32 – TF-IDF 嵌入
4. 然后，我们可以将TF-IDF加权嵌入与我们的平均嵌入进行比较，看看它们的相似度。我们可以使用余弦相似度来实现，如下。
4. 然后，我们可以将 TF-IDF 加权嵌入与我们的平均嵌入进行比较，看看它们的相似度。我们可以使用余弦相似度来实现，如下。
余弦相似度（均值嵌入，tfidf_weighted_embedding）
......
new/handson-nlp-pt-1x/4.md
浏览文件 @ 27bb5cf1
......@@ -226,11 +226,11 @@ Cat -> Cats' (Plural possessive)
**Porter 词干提取器**是具有大量逻辑规则的算法，可用于返回单词的词干。 在继续讨论该算法之前，我们将首先展示如何使用 NLTK 在 Python 中实现 Porter 词干提取器。
1. 首先，我们创建一个Porter 词干提取器的实例。
1. 首先，我们创建一个 Porter 词干提取器的实例。
搬运工= PorterStemmer（）
2. 然后，我们只需在单个单词上调用这个词干提取器的实例，并打印结果。在这里，我们可以看到Porter 词干提取器返回的词干的一个例子。
2. 然后，我们只需在单个单词上调用这个词干提取器的实例，并打印结果。在这里，我们可以看到 Porter 词干提取器返回的词干的一个例子。
word_list = [“ see”，“ saw”，“ cat”，“ cats”，“ stem”，“ stemming”，“ lemma”，“ lemmatization”，“ known”，“ knowing”，“ time”，“ timing” ，“足球”，“足球运动员”]
......
new/handson-nlp-pt-1x/5.md
浏览文件 @ 27bb5cf1
......@@ -683,7 +683,7 @@ mkdir 模型
在`app.py`文件中，我们可以开始构建我们的 API：
1. 我们首先进行所有的导入，并创建一个`predict`路由。这样我们就可以用`predict`参数来调用我们的API，以便在API中运行`predict()`方法。
1. 我们首先进行所有的导入，并创建一个`predict`路由。这样我们就可以用`predict`参数来调用我们的 API，以便在 API 中运行`predict()`方法。
进口烧瓶
......@@ -711,7 +711,7 @@ mkdir 模型
@ app.route（'/ predict'，Methods = ['GET']）
2. 接下来，我们在`app.py`文件中定义·predict()方法。这在很大程度上是我们模型文件的翻版，所以为了避免代码重复，建议你查看本章“技术需求”部分链接的GitHub仓库中完成的·app.py文件。你会发现有几行额外的内容。首先，在`preprocess_review()`函数中，我们会看到以下几行。
2. 接下来，我们在`app.py`文件中定义·predict()方法。这在很大程度上是我们模型文件的翻版，所以为了避免代码重复，建议你查看本章“技术需求”部分链接的 GitHub 仓库中完成的·app.py 文件。你会发现有几行额外的内容。首先，在`preprocess_review()`函数中，我们会看到以下几行。
使用 open（'models / word_to_int_dict.json'）作为句柄：
......@@ -725,7 +725,7 @@ mkdir 模型
model.load_state_dict（torch.load（“ models / model_nlp.pkl”））
4. 我们还必须定义我们API的输入和输出。我们希望我们的模型能够从API中获取输入，并将其传递给我们的`precess_review()`函数。我们使用`request.get_json()`来完成。
4. 我们还必须定义我们 API 的输入和输出。我们希望我们的模型能够从 API 中获取输入，并将其传递给我们的`precess_review()`函数。我们使用`request.get_json()`来完成。
request_json = request.get_json（）
......@@ -733,7 +733,7 @@ mkdir 模型
单词= np.array（[preprocess_review（review = i）]）
5. 为了定义我们的输出，我们返回一个JSON响应，由我们模型的输出和响应代码`200`组成，这就是我们预测函数返回的内容。
5. 为了定义我们的输出，我们返回一个 JSON 响应，由我们模型的输出和响应代码`200`组成，这就是我们预测函数返回的内容。
输出= model（x）[0] .item（）
......@@ -741,7 +741,7 @@ mkdir 模型
返回响应，200
6. 随着我们的应用程序主体的完成，我们还必须添加两件额外的事情来使我们的API运行。首先，我们必须在`wsgi.py`文件中添加以下内容。
6. 随着我们的应用程序主体的完成，我们还必须添加两件额外的事情来使我们的 API 运行。首先，我们必须在`wsgi.py`文件中添加以下内容。
从应用程序导入应用程序作为应用程序
......@@ -749,7 +749,7 @@ mkdir 模型
application.run()
7. 最后，在我们的Procfile中添加以下内容。
7. 最后，在我们的 Procfile 中添加以下内容。
网址：gunicorn app：app --preload
......
new/handson-nlp-pt-1x/6.md
浏览文件 @ 27bb5cf1
......@@ -137,7 +137,7 @@ CNN 背后的基本概念是卷积。 **卷积**本质上是一个滑动窗口
按着这些次序：
1. 我们首先从TorchText导入数据和数据集函数。
1. 我们首先从 TorchText 导入数据和数据集函数。
从 torchtext 导入数据
......@@ -245,7 +245,7 @@ batch_size = 64，
现在我们已经加载了数据，现在可以创建模型了。 我们将使用以下步骤进行操作：
1. 我们希望建立我们CNN的结构。我们像往常一样，首先将我们的模型定义为一个继承自`nn.Module`的类。
1. 我们希望建立我们 CNN 的结构。我们像往常一样，首先将我们的模型定义为一个继承自`nn.Module`的类。
CNN（nn.Module）类：
......
new/handson-nlp-pt-1x/7.md
浏览文件 @ 27bb5cf1
......@@ -113,7 +113,7 @@
我们将从提取数据并对其进行预处理开始。 我们将再次使用`spacy`，其中包含内置词汇表，可用于标记数据：
1. 我们首先将`spacy`分词器加载到Python中。我们需要为每一种语言做一次，因为我们将为这个任务构建两个完全独立的词汇表。
1. 我们首先将`spacy`分词器加载到 Python 中。我们需要为每一种语言做一次，因为我们将为这个任务构建两个完全独立的词汇表。
spacy_german = spacy.load（‘de’）
......@@ -183,7 +183,7 @@
图 7.12 –训练数据示例
6. 现在，我们可以检查我们每个数据集的大小。在这里，我们可以看到，我们的训练数据集由29,000个例子组成，而我们的每个验证和测试集分别由1,014个和1,000个例子组成。在过去，我们对训练和验证数据使用了 80%/20% 的分割。然而，在这样的情况下，当我们的输入和输出字段非常稀疏，而我们的训练集规模有限时，在可用的数据上进行训练往往是有益的。
6. 现在，我们可以检查我们每个数据集的大小。在这里，我们可以看到，我们的训练数据集由 29,000 个例子组成，而我们的每个验证和测试集分别由 1,014 个和 1,000 个例子组成。在过去，我们对训练和验证数据使用了 80%/20% 的分割。然而，在这样的情况下，当我们的输入和输出字段非常稀疏，而我们的训练集规模有限时，在可用的数据上进行训练往往是有益的。
print（“训练数据集大小：“ + str（len（train_data。示例）））
......@@ -197,7 +197,7 @@
图 7.13 –数据样本长度
7. 现在，我们可以建立我们的词汇表并检查它们的大小。我们的词汇表应该包括在我们的数据集中找到的每一个独特的单词。我们可以看到，我们的德语词汇量比英语词汇量大得多。我们的词汇量明显小于每种语言的每个词汇的真实大小（英语词典中的每个单词）。因此，由于我们的模型只能准确地翻译它以前见过的单词，所以我们的模型不太可能很好地泛化到英语中所有可能的句子。这就是为什么要准确地训练这样的模型，需要极其庞大的NLP数据集（比如谷歌能够获得的数据集）。
7. 现在，我们可以建立我们的词汇表并检查它们的大小。我们的词汇表应该包括在我们的数据集中找到的每一个独特的单词。我们可以看到，我们的德语词汇量比英语词汇量大得多。我们的词汇量明显小于每种语言的每个词汇的真实大小（英语词典中的每个单词）。因此，由于我们的模型只能准确地翻译它以前见过的单词，所以我们的模型不太可能很好地泛化到英语中所有可能的句子。这就是为什么要准确地训练这样的模型，需要极其庞大的 NLP 数据集（比如谷歌能够获得的数据集）。
SOURCE.build_vocab（train_data，min_freq = 2）
......@@ -213,7 +213,7 @@
图 7.14 –数据集的词汇量
8. 最后，我们可以从我们的数据集创建我们的数据迭代器。就像我们之前所做的那样，我们指定使用支持CUDA的GPU（如果我们的系统中可用的话），并指定我们的批次大小。
8. 最后，我们可以从我们的数据集创建我们的数据迭代器。就像我们之前所做的那样，我们指定使用支持 CUDA 的 GPU（如果我们的系统中可用的话），并指定我们的批次大小。
device = torch.device（如果 torch.cuda.is_available（）则为“ cuda”，否则为“ cpu”）
......@@ -233,7 +233,7 @@
现在，我们准备开始构建我们的编码器：
1. 首先，我们通过继承我们的`nn.Module`类来初始化我们的模型，就像我们之前所有的模型一样。我们用几个参数进行初始化，这些参数我们将在后面定义，以及我们LSTM层中隐藏层的维数和LSTM层的数量。
1. 首先，我们通过继承我们的`nn.Module`类来初始化我们的模型，就像我们之前所有的模型一样。我们用几个参数进行初始化，这些参数我们将在后面定义，以及我们 LSTM 层中隐藏层的维数和 LSTM 层的数量。
编码器类（nn.Module）：
......@@ -249,13 +249,13 @@
self.embedding = nn.Embedding（input_dims，emb_dims）
3. 接下来，我们定义我们实际的LSTM层。这从嵌入层中获取我们的嵌入句子，保持一个定义长度的隐藏状态，并由若干层组成（我们稍后将定义为2）。我们还实现了**丢弃**来对我们的网络进行正则化。
3. 接下来，我们定义我们实际的 LSTM 层。这从嵌入层中获取我们的嵌入句子，保持一个定义长度的隐藏状态，并由若干层组成（我们稍后将定义为 2）。我们还实现了**丢弃**来对我们的网络进行正则化。
self.rnn = nn.LSTM（emb_dims，hid_dims，n_layers，辍学=辍学）
self.dropout = nn.Dropout（辍学）
4. 然后，我们在编码器内定义前向传递。我们将嵌入应用到我们的输入句子，并应用丢弃。然后，我们将这些嵌入通过我们的LSTM层，它输出我们的最终隐藏状态。这将被我们的解码器用来形成我们的翻译句子。
4. 然后，我们在编码器内定义前向传递。我们将嵌入应用到我们的输入句子，并应用丢弃。然后，我们将这些嵌入通过我们的 LSTM 层，它输出我们的最终隐藏状态。这将被我们的解码器用来形成我们的翻译句子。
def forward（self，src）：
......@@ -422,7 +422,7 @@ pred = self.fc_out（output.squeeze（0））
我们的模型将以在模型的所有部分中权重为 0 的初始化。 尽管理论上该模型应该能够在没有（零）权重的情况下进行学习，但事实表明，使用随机权重进行初始化可以帮助模型更快地学习。 让我们开始吧：
1. 在这里，我们将用来自正态分布的随机样本的权重来初始化我们的模型，数值在 -0.1 到0.1之间。
1. 在这里，我们将用来自正态分布的随机样本的权重来初始化我们的模型，数值在 -0.1 到 0.1 之间。
def initialize_weights（m）：
......
new/handson-nlp-pt-1x/8.md
浏览文件 @ 27bb5cf1
......@@ -137,7 +137,7 @@ corpus_name = "movie_corpus"
过去，我们的语料库由几个词典组成，这些词典由我们的语料库中的唯一单词以及在单词和索引之间的查找组成。 但是，我们可以通过创建一个包含所有必需元素的词汇表类，以一种更为优雅的方式来实现此目的：
1. 我们先创建`Vocabulary`类。我们用空字典--`word2index`和`word2count`来初始化这个类。我们还用填充标记的占位符以及**句子开始**（**SOS**）和**句子结束**（**EOS**）标记初始化了`index2word`字典。我们也会对词汇中的单词数量进行统计（首先是3个，因为我们的语料库已经包含了上述三个标记）。这些是一个空词汇的默认值，但是，当我们读入数据时，它们会被填充。
1. 我们先创建`Vocabulary`类。我们用空字典--`word2index`和`word2count`来初始化这个类。我们还用填充标记的占位符以及**句子开始**（**SOS**）和**句子结束**（**EOS**）标记初始化了`index2word`字典。我们也会对词汇中的单词数量进行统计（首先是 3 个，因为我们的语料库已经包含了上述三个标记）。这些是一个空词汇的默认值，但是，当我们读入数据时，它们会被填充。
PAD_token = 0
......@@ -161,7 +161,7 @@ corpus_name = "movie_corpus"
self.num_words = 3
2. 接下来，我们创建我们将用来填充词汇的函数。`addWord`接收一个单词作为输入。如果这是个新词，还没有在我们的词汇中，我们就把这个词添加到我们的索引中，把这个词的计数设为1，并把我们词汇中的总词数递增1。如果这个词已经在我们的词汇中，我们只需将这个词的数量增加1。
2. 接下来，我们创建我们将用来填充词汇的函数。`addWord`接收一个单词作为输入。如果这是个新词，还没有在我们的词汇中，我们就把这个词添加到我们的索引中，把这个词的计数设为 1，并把我们词汇中的总词数递增 1。如果这个词已经在我们的词汇中，我们只需将这个词的数量增加 1。
def addWord（self，w）：
......@@ -237,7 +237,7 @@ corpus_name = "movie_corpus"
我们将通过以下步骤开始加载数据：
1. 读取我们的数据的第一步是执行任何必要的步骤来清理数据，使其更易于人类阅读。我们首先将数据从Unicode转换为ASCII格式。我们可以很容易地使用一个函数来完成这个工作。
1. 读取我们的数据的第一步是执行任何必要的步骤来清理数据，使其更易于人类阅读。我们首先将数据从 Unicode 转换为 ASCII 格式。我们可以很容易地使用一个函数来完成这个工作。
def unicodeToAscii（s）：
......@@ -409,7 +409,7 @@ corpus_name = "movie_corpus"
我们知道我们的模型不会将原始文本作为输入，而是将句子的张量表示作为输入。 我们也不会一一处理句子，而是分批量。 为此，我们需要将输入和输出语句都转换为张量，其中张量的宽度表示我们希望在其上训练的批量的大小：
1. 我们首先创建几个辅助函数，用来将我们的词对转化为时序。我们首先创建一个`indexFromSentence`函数，它从词汇中抓取句子中每个单词的索引，并在句尾附加一个EOS标记。
1. 我们首先创建几个辅助函数，用来将我们的词对转化为时序。我们首先创建一个`indexFromSentence`函数，它从词汇中抓取句子中每个单词的索引，并在句尾附加一个 EOS 标记。
def indexFromSentence（voc，句子）：
......@@ -441,7 +441,7 @@ corpus_name = "movie_corpus"
返回垫张量，长度
4. 在我们的网络中，我们的padded tokens一般应该被忽略。我们不想在这些填充的标记上训练我们的模型，所以我们创建一个布尔掩码来忽略这些标记。为此，我们使用`getMask`函数，将其应用到我们的输出张量上。如果输出由一个词组成，则返回`1`，如果由一个填充标记组成，则返回`0`。
4. 在我们的网络中，我们的 padded tokens 一般应该被忽略。我们不想在这些填充的标记上训练我们的模型，所以我们创建一个布尔掩码来忽略这些标记。为此，我们使用`getMask`函数，将其应用到我们的输出张量上。如果输出由一个词组成，则返回`1`，如果由一个填充标记组成，则返回`0`。
def getMask（l，value = PAD_token）：
......@@ -561,7 +561,7 @@ corpus_name = "movie_corpus"
c）事实证明，GRU 在学习小型数据集方面比 LSTM 更有效。 由于我们的训练数据的规模相对于我们要学习的任务的复杂性而言较小，因此我们应该选择使用 GRU。
2. 现在我们定义我们的GRU，考虑到输入的大小，层数，以及是否应该实现丢弃。
2. 现在我们定义我们的 GRU，考虑到输入的大小，层数，以及是否应该实现丢弃。
self.gru = nn.GRU（hidden_​​size，hidden_​​size，n_layers，
......@@ -577,7 +577,7 @@ corpus_name = "movie_corpus"
我们在输入句子中保持两个隐藏状态以及每一步的输出。
3. 接下来，我们需要为我们的编码器创建一个正向传递。我们首先将输入句子嵌入，然后使用`pack_padded_sequence`函数对我们的嵌入进行处理。这个函数对我们的填充序列进行 "打包"，使我们所有的输入都具有相同的长度。然后，我们将打包后的序列通过GRU传递出去，进行前向传递。
3. 接下来，我们需要为我们的编码器创建一个正向传递。我们首先将输入句子嵌入，然后使用`pack_padded_sequence`函数对我们的嵌入进行处理。这个函数对我们的填充序列进行 "打包"，使我们所有的输入都具有相同的长度。然后，我们将打包后的序列通过 GRU 传递出去，进行前向传递。
def forward（自我，input_seq，input_lengths，hidden = None）：
......@@ -589,7 +589,7 @@ corpus_name = "movie_corpus"
输出，隐藏= self.gru（打包，隐藏）
4. 在这之后，我们解包我们的填充并对GRU输出进行求和。然后，我们可以返回这个加和后的输出，以及我们最终的隐藏状态，来完成我们的前向传递。
4. 在这之后，我们解包我们的填充并对 GRU 输出进行求和。然后，我们可以返回这个加和后的输出，以及我们最终的隐藏状态，来完成我们的前向传递。
输出，_ = nn.utils.rnn.pad_packed_sequence（输出）
......@@ -621,7 +621,7 @@ corpus_name = "movie_corpus"
返回 torch.sum（隐藏* encoder_output，dim = 2）
3. 然后，我们在前传内使用这个函数。首先，根据`dot_score`方法计算注意力权重/能量，然后对结果进行转置，并返回软max变换后的概率分数。
3. 然后，我们在前传内使用这个函数。首先，根据`dot_score`方法计算注意力权重/能量，然后对结果进行转置，并返回软 max 变换后的概率分数。
def forward（自身，隐藏，encoder_outputs）：
......@@ -657,7 +657,7 @@ corpus_name = "movie_corpus"
self.dropout =辍学
2. 然后我们在这个模块中创建我们的层。我们将创建一个嵌入层和一个相应的丢弃层。我们再次为我们的解码器使用GRU；但是，这次我们不需要使我们的GRU层成为双向的，因为我们将依次对编码器的输出进行解码。我们还将创建两个线性层--一个是用于计算我们的输出的常规层，另一个是可用于连接的层。这个层的宽度是常规隐藏层的两倍，因为它将用于两个连通向量，每个向量的长度为`hidden_size`。我们还初始化了上一节中的注意力模块的一个实例，以便能够在我们的`Decoder`类中使用它。
2. 然后我们在这个模块中创建我们的层。我们将创建一个嵌入层和一个相应的丢弃层。我们再次为我们的解码器使用 GRU；但是，这次我们不需要使我们的 GRU 层成为双向的，因为我们将依次对编码器的输出进行解码。我们还将创建两个线性层--一个是用于计算我们的输出的常规层，另一个是可用于连接的层。这个层的宽度是常规隐藏层的两倍，因为它将用于两个连通向量，每个向量的长度为`hidden_size`。我们还初始化了上一节中的注意力模块的一个实例，以便能够在我们的`Decoder`类中使用它。
self.embeddding =嵌入
......@@ -671,7 +671,7 @@ corpus_name = "movie_corpus"
self.attn = Attn（hidden_​​size）
3. 在定义了所有的层之后，我们需要为解码器创建一个前向通道。请注意前向通证将如何一步一步（单词）地使用。我们首先得到当前输入词的嵌入，然后通过GRU层进行前向通证，得到我们的输出和隐藏状态。
3. 在定义了所有的层之后，我们需要为解码器创建一个前向通道。请注意前向通证将如何一步一步（单词）地使用。我们首先得到当前输入词的嵌入，然后通过 GRU 层进行前向通证，得到我们的输出和隐藏状态。
def forward（自我，input_step，last_hidden，encoder_outputs）：
......@@ -681,7 +681,7 @@ corpus_name = "movie_corpus"
rnn_output，隐藏= self.gru（嵌入，last_hidden）
4. 接下来，我们使用注意力模块从GRU输出中获取注意力权重。然后将这些权重与编码器输出相乘，从而有效地得到我们的注意力权重和编码器输出的加权和。
4. 接下来，我们使用注意力模块从 GRU 输出中获取注意力权重。然后将这些权重与编码器输出相乘，从而有效地得到我们的注意力权重和编码器输出的加权和。
attn_weights = self.attn（rnn_output，编码器输出）
......@@ -689,7 +689,7 @@ corpus_name = "movie_corpus"
1))
5. 然后，我们将加权上下文向量与GRU的输出相连接，并应用`tanh`函数得到最终的连接输出。
5. 然后，我们将加权上下文向量与 GRU 的输出相连接，并应用`tanh`函数得到最终的连接输出。
rnn_output = rnn_output.squeeze（0）
......@@ -727,7 +727,7 @@ corpus_name = "movie_corpus"
回波损耗，TotalN.item（）
2. 对于我们的大部分训练，我们需要两个主要函数--一个函数`train()`，它对我们的单批训练数据进行训练，另一个函数`trainIters()`，它遍历我们的整个数据集，并对每个单独的批次调用`train()`。我们先定义`train()`，以便对单批数据进行训练。创建`train()`函数，然后让梯度为0，定义设备选项，并初始化变量。
2. 对于我们的大部分训练，我们需要两个主要函数--一个函数`train()`，它对我们的单批训练数据进行训练，另一个函数`trainIters()`，它遍历我们的整个数据集，并对每个单独的批次调用`train()`。我们先定义`train()`，以便对单批数据进行训练。创建`train()`函数，然后让梯度为 0，定义设备选项，并初始化变量。
def train（输入变量，长度，目标变量，\
......@@ -977,7 +977,7 @@ corpus_name = "movie_corpus"
coder_hidden = encoder_hidden [：decoder.n_layers]
3. 然后，用SOS令牌创建解码器输入，并初始化附加解码词的令牌（初始化为单个零值）。
3. 然后，用 SOS 令牌创建解码器输入，并初始化附加解码词的令牌（初始化为单个零值）。
coder_input = torch.ones（1，1，device = device，dtype = torch.long）* SOS_token
......@@ -1063,7 +1063,7 @@ corpus_name = "movie_corpus"
voc，input_sentence）
9. 最后，我们将这些输出词进行格式化，忽略EOS和填充标记，然后再打印聊天机器人的响应。因为这是一个`while`循环，这让我们可以无限期地继续与聊天机器人对话。
9. 最后，我们将这些输出词进行格式化，忽略 EOS 和填充标记，然后再打印聊天机器人的响应。因为这是一个`while`循环，这让我们可以无限期地继续与聊天机器人对话。
output_words [：] = [x 表示 output_words 中的 x，如果\
......@@ -1139,7 +1139,7 @@ corpus_name = "movie_corpus"
coder.load_state_dict（decoder_sd）
5. 最后但并非最不重要的是，我们为我们的每个模型指定一个要训练的设备。请记住，如果你想使用GPU训练，这是至关重要的一步。
5. 最后但并非最不重要的是，我们为我们的每个模型指定一个要训练的设备。请记住，如果你想使用 GPU 训练，这是至关重要的一步。
编码器= encoder.to（设备）
......@@ -1181,7 +1181,7 @@ corpus_name = "movie_corpus"
coder.train（）
8. 接下来，我们为编码器和解码器创建优化器。我们将这些优化器初始化为Adam优化器，但其他优化器也同样适用。用不同的优化器进行实验可能会产生不同级别的模型性能。如果你之前已经训练过一个模型，如果需要的话，你也可以加载优化器的状态。
8. 接下来，我们为编码器和解码器创建优化器。我们将这些优化器初始化为 Adam 优化器，但其他优化器也同样适用。用不同的优化器进行实验可能会产生不同级别的模型性能。如果你之前已经训练过一个模型，如果需要的话，你也可以加载优化器的状态。
print（'建筑优化器...'）
......@@ -1203,7 +1203,7 @@ corpus_name = "movie_corpus"
coder_optimizer_sd）
9. 运行训练前的最后一步是确保CUDA被配置为被调用，如果你想使用GPU训练。要做到这一点，我们只需简单地循环编码器和解码器的优化器状态，并在所有状态中启用CUDA。
9. 运行训练前的最后一步是确保 CUDA 被配置为被调用，如果你想使用 GPU 训练。要做到这一点，我们只需简单地循环编码器和解码器的优化器状态，并在所有状态中启用 CUDA。
对于 encoder_optimizer.state.values（）中的状态：
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或