2021-01-18 14:21:32

new/dl-pt-workshop/1.md

@@ -248,9 +248,9 @@ PyTorch 已被许多研究人员和人工智能开发人员采用，这使其成
 
 像任何其他库一样，PyTorch 具有用于开发不同功能的各种模块，库和包。 在本节中，将解释构建深度神经网络的三个最常用元素以及语法的简单示例。
 
-### PyTorch autograd 库
+### PyTorch `autograd`库
 
-`autograd`库由称为自动分化的技术组成。 其目的是通过数值计算函数的导数。 这对于我们将在下一章中学习的称为反向传播的概念至关重要，该概念是在训练神经网络时执行的。
+`autograd`库由称为自动微分的技术组成。 其目的是通过数值计算函数的导数。 这对于我们将在下一章中学习的称为反向传播的概念至关重要，该概念是在训练神经网络时执行的。
 
 元素的导数（也称为梯度）是指该元素在给定时间步长中的变化率。 在深度学习中，梯度是指维数和大小，其中必须在训练步骤中更新神经网络的参数，以最小化损失函数。 在下一章中将进一步探讨该概念。
 
@@ -289,7 +289,7 @@ print(b.grad.data)
 AttributeError: 'NoneType' object has no attribute 'data'
 ```
 
-### PyTorch nn 模块
+### PyTorch `nn`模块
 
 考虑到已经解决了棘手的部分（梯度的计算），仅`autograd`库可用于构建简单的神经网络。 但是，这种方法可能很麻烦，因此引入了`nn`模块。
 
@@ -314,7 +314,7 @@ loss_funct = nn.MSELoss()
 
 首先，导入模块。 然后，定义模型架构。 `input_units`表示输入数据包含的要素数量，`hidden_​​units`表示隐藏层的节点数量， `output_units`表示 输出层的节点。
 
-从前面的代码中可以看出，网络的架构包含一个隐藏层，其后是 ReLU 激活函数和一个输出层，然后是一个 S 型激活函数，从而使其成为两层网络。
+从前面的代码中可以看出，网络的架构包含一个隐藏层，其后是 ReLU 激活函数和一个输出层，然后是一个 Sigmoid激活函数，从而使其成为两层网络。
 
 最后，损失函数定义为**均方误差**（**MSE**）。
 
@@ -543,7 +543,7 @@ for i in range(100):
 
     注意
 
-    要切片 pandas DataFrame，请使用 pandas 的`iloc`方法。 要了解有关此方法的更多信息，请访问[这里](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.iloc.html)。
+    要切片 pandas `DataFrame`，请使用 pandas 的`iloc`方法。 要了解有关此方法的更多信息，请访问[这里](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.iloc.html)。
 
 4.  定义模型的架构，并将其存储在名为`model`的变量中。 记住要创建一个单层模型。
 5.  定义要使用的损失函数。 在这种情况下，请使用 MSE 损失功能。

new/dl-pt-workshop/2.md

@@ -44,9 +44,9 @@
 
 图 2.1：感知器图
 
-在这里，`X`1，`X`2，`X`3 和`X`4 代表感知器的不同输入，并且可能存在 其中任何数量。 圆是感知器，在该处处理输入以达到输出。
+在这里，`X1`，`X2`，`X3`和`X4`代表感知器的不同输入，并且可能存在 其中任何数量。 圆是感知器，在该处处理输入以达到输出。
 
-Rosenblatt 还介绍了权重的概念（`w`1，`w`2，…，`w`n），这些数字表示每个输入的重要性。 输出可以是 0 或 1，并且取决于输入的加权总和是高于还是低于给定阈值（由开发人员设置的数值限制或由数据问题的约束设置），该阈值可以设置为 感知器的参数，如下所示：
+Rosenblatt 还介绍了权重的概念（`w1`，`w2`，...，`wn`），这些数字表示每个输入的重要性。 输出可以是 0 或 1，并且取决于输入的加权总和是高于还是低于给定阈值（由开发人员设置的数值限制或由数据问题的约束设置），该阈值可以设置为 感知器的参数，如下所示：
 
 ![Figure 2.2: Equation for the output of perceptrons ](img/B15778_02_02.jpg)
 
@@ -58,11 +58,11 @@ Rosenblatt 还介绍了权重的概念（`w`1，`w`2，…，`w`n），这些数
 
 下个星期五在您的镇上有一个音乐节，但是您生病了，想决定是否要去（0 表示您不参加，1 表示您要参加）。 您的决定取决于三个因素：
 
-*   会好天气吗？ （`X`1）
-*   你要和谁一起去吗？ （`X`2）
-*   音乐是您喜欢的吗？ （`X`3）
+*   会好天气吗？ （`X1`）
+*   你要和谁一起去吗？ （`X2`）
+*   音乐是您喜欢的吗？ （`X3`）
 
-对于前面的因素，如果问题的答案为是，则将使用 1，如果答案为否，则将使用 0。 此外，由于您病得很重，因此与天气相关的因素非常重要，因此您决定赋予该因素比其他两个因素大两倍的权重。 因此，您决定因素的权重将为 4（`w`1），2（`w`2）和 2（`w`3）。 现在，考虑阈值 5：
+对于前面的因素，如果问题的答案为是，则将使用 1，如果答案为否，则将使用 0。 此外，由于您病得很重，因此与天气相关的因素非常重要，因此您决定赋予该因素比其他两个因素大两倍的权重。 因此，您决定因素的权重将为 4（`w1`），2（`w2`）和 2（`w3`）。 现在，考虑阈值 5：
 
 1.  考虑到下周五的天气不好，但是您要和某人一起去，并且您喜欢音乐节上的音乐，请根据提供的信息来计算感知器的输出：
 
@@ -124,19 +124,19 @@ Rosenblatt 还介绍了权重的概念（`w`1，`w`2，…，`w`n），这些数
 
 激活函数的目的是将非线性引入模型。 有不同的激活函数可供选择，当今最常用的激活函数列表如下：
 
-*   **Sigmoid**：这是 S 形，它基本上将值转换为 0 到 1 之间的简单概率，其中通过 S 形函数获得的大多数输出​​将接近 0 和 1 的极限。
+*   **Sigmoid**：这是 Sigmoid，它基本上将值转换为 0 到 1 之间的简单概率，其中通过 Sigmoid函数获得的大多数输出​​将接近 0 和 1 的极限。
 
 ![Figure 2.7: Sigmoid activation function ](img/B15778_02_07.jpg)
 
 图 2.7：乙状结肠激活函数
 
-下图显示了 S 型激活函数的图形表示：
+下图显示了 Sigmoid激活函数的图形表示：
 
 ![Figure 2.8: Graphical representation of the sigmoid activation function ](img/B15778_02_08.jpg)
 
-图 2.8：S 型激活函数的图形表示
+图 2.8：Sigmoid激活函数的图形表示
 
-*   **Softmax**：类似于 S 形函数，它计算`n`个事件的事件概率分布，这意味着其输出不是二进制的。 简而言之，此函数将计算输出与其他类别相比是目标类别之一的概率：
+*   **Softmax**：类似于 Sigmoid函数，它计算`n`个事件的事件概率分布，这意味着其输出不是二进制的。 简而言之，此函数将计算输出与其他类别相比是目标类别之一的概率：
 
 ![Figure 2.9: Softmax activation function ](img/B15778_02_09.jpg)
 
@@ -144,7 +144,7 @@ Rosenblatt 还介绍了权重的概念（`w`1，`w`2，…，`w`n），这些数
 
 考虑到其输出是概率，因此通常在分类网络的输出层中找到此激活函数。
 
-*   **Tanh**：此函数表示双曲正弦和双曲余弦之间的关系，结果介于-1 和 1 之间。此激活函数的主要优点是可以更轻松地处理负值：
+*   **Tanh**：此函数表示双曲正弦和双曲余弦之间的关系，结果介于 -1 和 1 之间。此激活函数的主要优点是可以更轻松地处理负值：
 
 ![Figure 2.10: Tanh activation function ](img/B15778_02_10.jpg)
 
@@ -294,7 +294,7 @@ CNN 创建的模型使用神经元的子组来识别图像的不同方面。 这
 
 注意
 
-在使用 CNN 时可能已经听说过的 padding 和 stride 的概念，将在本书的后续章节中进行解释。
+在使用 CNN 时可能已经听说过的填充和跨步的概念，将在本书的后续章节中进行解释。
 
 1.  **卷积层**。在这些层中，图像（用像素矩阵表示）和过滤器之间进行卷积计算。这种计算产生一个特征图作为输出，最终作为下一层的输入。
 
@@ -332,7 +332,7 @@ CNN 创建的模型使用神经元的子组来识别图像的不同方面。 这
 
     图 2.22：最大池化操作
 
-    在上图中，通过使用 3 x 3 max pooling 过滤器，可以实现右侧的结果。 在此，黄色部分（左上角）的最大数量为 4，而橙色部分（右上角）的最大数量为 5。
+    在上图中，通过使用`3 x 3`最大池化过滤器，可以实现右侧的结果。 在此，黄色部分（左上角）的最大数量为 4，而橙色部分（右上角）的最大数量为 5。
 
     **平均池化**：类似地，平均池操作采用矩阵的各个子部分，并将符合规则的数字作为输出，在这种情况下，该数字是所讨论的子部分中所有数字的平均值：
 
@@ -340,7 +340,7 @@ CNN 创建的模型使用神经元的子组来识别图像的不同方面。 这
 
     图 2.23：平均池化操作
 
-    在这里，使用 3 x 3 滤镜，我们得到 2.9，这是黄色部分（左上角）中所有数字的平均值，而 3.2 是橙色部分（右上角）中所有数字的平均值。 。
+    在这里，使用`3 x 3`滤镜，我们得到 2.9，这是黄色部分（左上角）中所有数字的平均值，而 3.2 是橙色部分（右上角）中所有数字的平均值。 。
 
 3.  **全连接层**：最后，考虑到如果网络仅能够检测一组功能而不具有将其分类为类标签的能力，则该网络将无用，最后 CNN 使用全连接层采取前一层检测到的特征（称为特征图），并输出属于类别标签的那组特征的概率，用于进行最终预测。
 
@@ -360,7 +360,7 @@ CNN 创建的模型使用神经元的子组来识别图像的不同方面。 这
 
 简而言之，这些网络中包含循环，即使在处理后续的一组信息时，这些循环也可以使信息在其内存中保留更长的时间。 这意味着 RNN 中的感知器不仅将输出传递到下一个感知器，而且还保留了一些信息给自己，这对于分析下一信息很有用。 这种内存保留功能使他们可以非常准确地预测下一步。
 
-与其他网络类似，RNN 的学习过程尝试映射输入（x）和输出（y）之间的关系，不同之处在于这些模型还考虑了先前输入的全部或部分历史。
+与其他网络类似，RNN 的学习过程尝试映射输入（`x`）和输出（`y`）之间的关系，不同之处在于这些模型还考虑了先前输入的全部或部分历史。
 
 RNN 允许以输入序列，输出序列或什至同时以两种形式处理数据序列，如下图所示：
 
@@ -446,7 +446,7 @@ EDA 流程很有用，因为它有助于开发人员发现对于定义操作过
     data = data.drop(columns=["date"])
     ```
 
-    最后，打印 DataFrame 的头部：
+    最后，打印`DataFrame`的头部：
 
     ```py
     data.head()
@@ -510,7 +510,7 @@ EDA 流程很有用，因为它有助于开发人员发现对于定义操作过
 
     请注意，只要将变量放在笔记本中单元格的末尾，Jupyter 笔记本便可以打印变量的值，而无需使用打印功能。 在任何其他编程平台或任何其他情况下，请确保使用打印功能。
 
-    例如，打印包含异常值的结果字典的等效方法（也是最佳实践）将使用 print 语句，如下所示：`print(outliers)`。 这样，在不同的编程平台上运行时，代码将具有相同的输出。
+    例如，打印包含异常值的结果字典的等效方法（也是最佳实践）将使用`print`语句，如下所示：`print(outliers)`。 这样，在不同的编程平台上运行时，代码将具有相同的输出。
 
 ![Figure 2.28: Outlier participation in each feature ](img/B15778_02_28.jpg)
 
@@ -565,7 +565,7 @@ EDA 流程很有用，因为它有助于开发人员发现对于定义操作过
 
     前面的代码片段获取数据并使用切片将特征与目标分离。
 
-2.  通过使用规范化方法重新缩放特征数据。 显示结果 DataFrame 的标题（即前五个实例）以验证结果：
+2.  通过使用规范化方法重新缩放特征数据。 显示结果`DataFrame`的标题（即前五个实例）以验证结果：
 
     ```py
     X = (X - X.min()) / (X.max() - X.min())
@@ -597,7 +597,7 @@ EDA 流程很有用，因为它有助于开发人员发现对于定义操作过
 
 *   **测试集**：该集对模型没有影响，这就是为什么它用于对看不见的数据进行模型的最终评估的原因，这成为模型在模型上的性能如何的指南 未来的数据集。
 
-考虑到每个数据问题都是不同的，并且开发深度学习解决方案通常需要反复试验的方法，因此没有理想的科学方法可以将数据分为上述三组。 尽管如此，众所周知，对于较大的数据集（数十万个实例），每个集合的分割比例应为 98：1：1，因为对于训练集使用尽可能多的数据至关重要。 对于较小的数据集，常规拆分比率为 60:20:20。
+考虑到每个数据问题都是不同的，并且开发深度学习解决方案通常需要反复试验的方法，因此没有理想的科学方法可以将数据分为上述三组。 尽管如此，众所周知，对于较大的数据集（数十万个实例），每个集合的分割比例应为 98:1:1，因为对于训练集使用尽可能多的数据至关重要。 对于较小的数据集，常规拆分比率为 60:20:20。
 
 ## 练习 2.04：拆分数据集
 
@@ -686,13 +686,13 @@ EDA 流程很有用，因为它有助于开发人员发现对于定义操作过
 
     代码的第一行执行初始拆分。 该函数将以下内容作为参数：
 
-    `X_shuffle`，`Y_shuffle`：要拆分的数据集，即要素数据集，以及目标数据集（也称为 X 和 Y）
+    `X_shuffle`，`Y_shuffle`：要拆分的数据集，即要素数据集，以及目标数据集（也称为`X`和`Y`）
 
     `test_size`：测试集中要包含的实例的百分比
 
     `random_state`：用于确保结果的可重复性
 
-    此行代码的结果是将每个数据集（X 和 Y）分为两个子集。
+    此行代码的结果是将每个数据集（`X`和`Y`）分为两个子集。
 
     要创建其他集（验证集），我们将执行第二次拆分。 前面代码的第二行负责确定要用于第二个拆分的`test_size`，以便测试集和验证集具有相同的形状。
 
@@ -899,7 +899,7 @@ PyTorch 的构建考虑了该领域许多开发人员的意见，其优点是可
 
 您已经成功创建并训练了一个深度神经网络来解决回归问题。
 
-## 练习 2.02：开发回归问题的深入学习 ning 解决方案
+## 练习 2.02：开发回归问题的深度学习解决方案
 
 在本活动中，我们将创建并训练一个神经网络来解决我们在上一活动中提到的回归问题。 让我们看一下场景。
 
@@ -910,7 +910,7 @@ PyTorch 的构建考虑了该领域许多开发人员的意见，其优点是可
 使用与上一活动相同的 Jupyter 笔记本。
 
 1.  导入所需的库。
-2.  从目标中为我们在上一个活动中创建的所有三组数据拆分功能。 将 DataFrame 转换为张量。
+2.  从目标中为我们在上一个活动中创建的所有三组数据拆分功能。 将`DataFrame`转换为张量。
 3.  定义网络的架构。 随意尝试层数和每层单位数的不同组合。
 4.  定义损失函数和优化器算法。
 5.  使用循环对训练网络进行 3,000 个迭代步骤。
@@ -918,7 +918,9 @@ PyTorch 的构建考虑了该领域许多开发人员的意见，其优点是可
 
 您的输出应类似于以下内容：
 
-基本事实：1995.0 预测：1998.0279541015625
+```py
+Ground truth: 1995.0 Prediction: 1998.0279541015625
+```
 
 注意
 

new/dl-pt-workshop/3.md

@@ -279,7 +279,7 @@ print("rows:",data.shape[0]," columns:", data.shape[1])
 
 考虑到**婚姻**和**教育**都是顺序特征，这意味着它们遵循顺序或等级； 选择重新缩放方法时，请确保保持顺序。
 
-为了便于为即将进行的活动使用准备好的数据集，将特征（`X`）和目标（`y`）矩阵连接到一个 Pandas DataFrame 中， 使用以下代码将其保存到 CSV 文件中：
+为了便于为即将进行的活动使用准备好的数据集，将特征（`X`）和目标（`y`）矩阵连接到一个 Pandas `DataFrame`中， 使用以下代码将其保存到 CSV 文件中：
 
 ```py
 final_data = pd.concat([X, y], axis=1)

new/dl-pt-workshop/6.md

@@ -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`，以便能够重现本书中显示的结果：
 

new/handson-1shot-learn-py/3.md

@@ -249,7 +249,7 @@ import matplotlib.pyplot as plt
 
     *   两层前馈网络
     *   使用 Xavier 方法进行权重初始化
-    *   S 型非线性
+    *   Sigmoid非线性
 
 ```py
 class Controller(nn.Module):

new/handson-1shot-learn-py/4.md

@@ -123,13 +123,13 @@ LSTM 在各种门的帮助下存储信息历史记录，如上图所示。 我
 
 ![](img/da2cd6b1-bca0-456b-8064-23bdb90ef26c.png)
 
-本质上，`i[t]`被定义为具有当前梯度，当前损耗和先前学习率 <sub>![](img/991684d7-83b0-429c-91ef-5d41500f2726.png)</sub> 的组合的 S 型函数。
+本质上，`i[t]`被定义为具有当前梯度，当前损耗和先前学习率 <sub>![](img/991684d7-83b0-429c-91ef-5d41500f2726.png)</sub> 的组合的 Sigmoid函数。
 
 对于 <sub>![](img/f76a02ea-f996-4c81-a08f-8bf2e6bd97c1.png)</sub> ，应为 1，但为避免梯度缩小的问题，其定义如下：
 
 ![](img/1d551c2d-de09-4a7b-8657-0c310ee85bbb.png)
 
-本质上，`f[t]`被定义为具有当前梯度，当前损耗和遗忘门的 S 型函数。
+本质上，`f[t]`被定义为具有当前梯度，当前损耗和遗忘门的 Sigmoid函数。
 
 您可能想知道为什么他们使用 LSTM 电池的这种特定选择？ 如果仔细观察，会根据当前梯度和当前损耗选择`i[t]`和`f[t]`。 故意这样做是为了使元学习器能够*控制学习率*，以便在更少的时间内训练基础学习器。
 

new/handson-nlp-pt-1x/5.md

@@ -31,7 +31,7 @@ RNN 由循环层组成。 尽管它们在许多方面类似于标准前馈神经
 
 图 5.2 –时间步序
 
-该层用于`n`时间步长的输入。 我们的隐藏状态在状态`h`0 中初始化，然后使用我们的第一个输入`x`1 来计算下一个隐藏状态`h`1。 还学习了两组权重矩阵：矩阵`U`和矩阵`W`，矩阵`U`了解隐藏状态如何在时间步之间变化，矩阵`W`隐藏状态。
+该层用于`n`时间步长的输入。 我们的隐藏状态在状态`h`0 中初始化，然后使用我们的第一个输入`x1`来计算下一个隐藏状态`h`1。 还学习了两组权重矩阵：矩阵`U`和矩阵`W`，矩阵`U`了解隐藏状态如何在时间步之间变化，矩阵`W`隐藏状态。
 
 我们还将 *tanh* 激活函数应用于所得产品，将隐藏状态的值保持在-1 和 1 之间。用于计算任何隐藏状态的公式`h[t]`变为 以下：
 
@@ -117,7 +117,7 @@ LSTM 与 RNN 的结构非常相似。 虽然 LSTM 的各个步骤之间存在一
 
 图 5.7 –遗忘门
 
-遗忘门本质上是学习要忘记序列中的哪些元素。 先前的隐藏状态`h[t-1]`和最新的输入步骤`x`1 被串联在一起，并通过了在遗忘门和 S 形函数上获得的权重矩阵 将值压缩为 0 到 1 之间的值。将得到的矩阵`f[t]`逐点乘以上一步`c[t-1]`单元状态。 这有效地将掩码应用于先前的小区状态，使得仅来自先前的小区状态的相关信息被提出。
+遗忘门本质上是学习要忘记序列中的哪些元素。 先前的隐藏状态`h[t-1]`和最新的输入步骤`x1`被串联在一起，并通过了在遗忘门和 Sigmoid函数上获得的权重矩阵 将值压缩为 0 到 1 之间的值。将得到的矩阵`f[t]`逐点乘以上一步`c[t-1]`单元状态。 这有效地将掩码应用于先前的小区状态，使得仅来自先前的小区状态的相关信息被提出。
 
 接下来，我们将查看**输入门**：
 
@@ -125,7 +125,7 @@ LSTM 与 RNN 的结构非常相似。 虽然 LSTM 的各个步骤之间存在一
 
 图 5.8 –输入门
 
-输入门再次采用串联的先前隐藏状态`h`t-1 和当前序列输入`x`t，并将其通过具有学习参数的 S 型函数，从而输出 另一个矩阵`i`t 由 0 到 1 之间的值组成。串联的隐藏状态和序列输入也通过 tanh 函数，该函数将输出压缩在-1 和 1 之间。 通过`i`t 矩阵。 这意味着生成`i`t 所需的学习参数可以有效地了解应从当前时间步长将哪些元素保留在我们的细胞状态中。 然后将其添加到当前单元状态以获得最终单元状态，该状态将继续进行到下一个时间步骤。
+输入门再次采用串联的先前隐藏状态`h`t-1 和当前序列输入`x`t，并将其通过具有学习参数的 Sigmoid函数，从而输出 另一个矩阵`i`t 由 0 到 1 之间的值组成。串联的隐藏状态和序列输入也通过 tanh 函数，该函数将输出压缩在-1 和 1 之间。 通过`i`t 矩阵。 这意味着生成`i`t 所需的学习参数可以有效地了解应从当前时间步长将哪些元素保留在我们的细胞状态中。 然后将其添加到当前单元状态以获得最终单元状态，该状态将继续进行到下一个时间步骤。
 
 最后，我们有是 LSTM 单元的最后一个元素-**输出门**：
 
@@ -133,7 +133,7 @@ LSTM 与 RNN 的结构非常相似。 虽然 LSTM 的各个步骤之间存在一
 
 图 5.9 –输出门
 
-输出门计算 LSTM 单元的最终输出-单元状态和隐藏状态，并继续进行下一步。 单元状态`c`t 与前两个步骤相同，是遗忘门和输入门的乘积。 通过获取串联的先前隐藏状态`h`t-1 和当前时间步输入`x`t，可以计算出最终隐藏状态`h`t ，并通过具有一些学习参数的 S 型函数来获得输出门输出`o`t。 最终单元状态`c`t 通过 tanh 函数并乘以输出门输出`o`t，以计算最终隐藏状态`h`t。 这意味着在输出门上学习到的参数可以有效地控制将先前隐藏状态和当前输出中的哪些元素与最终单元状态进行组合，以作为新的隐藏状态延续到下一个时间步长。
+输出门计算 LSTM 单元的最终输出-单元状态和隐藏状态，并继续进行下一步。 单元状态`c`t 与前两个步骤相同，是遗忘门和输入门的乘积。 通过获取串联的先前隐藏状态`h`t-1 和当前时间步输入`x`t，可以计算出最终隐藏状态`h`t ，并通过具有一些学习参数的 Sigmoid函数来获得输出门输出`o`t。 最终单元状态`c`t 通过 tanh 函数并乘以输出门输出`o`t，以计算最终隐藏状态`h`t。 这意味着在输出门上学习到的参数可以有效地控制将先前隐藏状态和当前输出中的哪些元素与最终单元状态进行组合，以作为新的隐藏状态延续到下一个时间步长。
 
 在我们的前向遍历中，我们简单地遍历模型，初始化我们的隐藏状态和单元状态，并在每个时间步使用 LSTM 单元对其进行更新，直到剩下最终的隐藏状态为止，该状态将输出到神经元的下一层 网络。 通过在 LSTM 的所有层中进行反向传播，我们可以计算相对于网络损耗的梯度，因此我们知道通过梯度下降来更新参数的方向。 我们得到几种矩阵或参数-一种用于输入门，一种用于输出门，以及一种用于遗忘门。
 
@@ -307,7 +307,7 @@ class SentimentLSTM(nn.Module):
         self.n_hidden = n_hidden
 ```
 
-然后，我们定义网络的每个层。 首先，我们定义嵌入层，该层的词汇量为字长，嵌入向量的大小为`n_embed`超参数。 我们的 LSTM 层是使用嵌入层的输出向量大小，模型的隐藏状态的长度以及 LSTM 层将具有的层数来定义的。 我们还添加了一个参数来指定可以对 LSTM 进行批量数据训练，并添加一个参数以允许我们通过辍学实现网络正则化。 我们用概率`drop_p`（将在模型创建时指定的超参数）定义另外一个辍学层，以及对最终全连接层和输出/预测节点的定义（具有 S 型激活函数） ：
+然后，我们定义网络的每个层。 首先，我们定义嵌入层，该层的词汇量为字长，嵌入向量的大小为`n_embed`超参数。 我们的 LSTM 层是使用嵌入层的输出向量大小，模型的隐藏状态的长度以及 LSTM 层将具有的层数来定义的。 我们还添加了一个参数来指定可以对 LSTM 进行批量数据训练，并添加一个参数以允许我们通过辍学实现网络正则化。 我们用概率`drop_p`（将在模型创建时指定的超参数）定义另外一个辍学层，以及对最终全连接层和输出/预测节点的定义（具有 Sigmoid激活函数） ：
 
 ```py
 self.embedding = nn.Embedding(n_vocab, n_embed)

new/pt-ai-fund/1.md

@@ -480,7 +480,7 @@ tensor([[4., 4., 4.],
 4.然后，我们将定义`y`，它比上一个示例稍微复杂一些：
 
 ```py
-y = (2`x`2+3)
+y = (2 * x * 2 + 3)
 y
 ```
 

new/pt-ai-fund/6.md

@@ -195,7 +195,7 @@ def forward(self, input):
 
 # 这个怎么运作...
 
-在本食谱中，我们定义了一个分类器； 使用`nn.Sequential()`定义卷积，激活和批量规范化单元的数组； 并且还定义了最后一个全连接层，该层采用平坦的张量并给出通过 S 形层的单个输出。 由于只有两个类，因此我们最后使用了 S 形层。 输入是尺寸为`1 x 28 x 28`的图像张量，并经过第一卷积单元以给出尺寸为`32 x 14 x 14`的输出张量。 第二个卷积层使它成为`64 x 7 x 7`张量，然后从那里变成`128 x 4 x 4`。 之后，我们将拉平并使张量穿过全连接层。
+在本食谱中，我们定义了一个分类器； 使用`nn.Sequential()`定义卷积，激活和批量规范化单元的数组； 并且还定义了最后一个全连接层，该层采用平坦的张量并给出通过 Sigmoid层的单个输出。 由于只有两个类，因此我们最后使用了 Sigmoid层。 输入是尺寸为`1 x 28 x 28`的图像张量，并经过第一卷积单元以给出尺寸为`32 x 14 x 14`的输出张量。 第二个卷积层使它成为`64 x 7 x 7`张量，然后从那里变成`128 x 4 x 4`。 之后，我们将拉平并使张量穿过全连接层。
 
 # 也可以看看
 

new/pt-dl-handson/2.md

@@ -236,7 +236,7 @@ for epoch in range(epochs):
 
 图 2.6：网络架构
 
-第一层由批量输入矩阵，权重和偏差之间的矩阵乘法和加法组成。 此时，`a2`张量应具有一个`grad_fn`，这应该是矩阵加法的后向操作。 但是，由于我们还没有进行反向传递，因此`.grad`应该返回`None`和`.data`，并且将一如既往地返回张量，以及矩阵乘法和偏差加法的结果。 神经元活动由 S 形激活函数定义，它以`h2`（代表第二层中的隐藏单位）的输出形式提供给我们。 第二层采用相同的结构：矩阵乘法，偏差加法和 S 形。 最后得到`hyp`，它具有预期的结果：
+第一层由批量输入矩阵，权重和偏差之间的矩阵乘法和加法组成。 此时，`a2`张量应具有一个`grad_fn`，这应该是矩阵加法的后向操作。 但是，由于我们还没有进行反向传递，因此`.grad`应该返回`None`和`.data`，并且将一如既往地返回张量，以及矩阵乘法和偏差加法的结果。 神经元活动由 Sigmoid激活函数定义，它以`h2`（代表第二层中的隐藏单位）的输出形式提供给我们。 第二层采用相同的结构：矩阵乘法，偏差加法和 Sigmoid。 最后得到`hyp`，它具有预期的结果：
 
 ```py
 print(a2.grad, a2.grad_fn, a2)
@@ -245,7 +245,7 @@ print(a2.grad, a2.grad_fn, a2)
 
 ###### 注意
 
-**Softmax**：让 S 型曲面吐出分类问题的预测是很不寻常的，但是我们将其保留下来，因为这样会使我们的模型易于理解，因为它重复了第一层。 通常，分类问题由 softmax 层和交叉熵损失处理，这会增加一类相对于另一类的概率。 由于所有类别的概率加在一起，因此增加一个类别的概率会降低其他类别的概率，这是一个不错的功能。 在以后的章节中将对此进行更多介绍。
+**Softmax**：让 Sigmoid曲面吐出分类问题的预测是很不寻常的，但是我们将其保留下来，因为这样会使我们的模型易于理解，因为它重复了第一层。 通常，分类问题由 softmax 层和交叉熵损失处理，这会增加一类相对于另一类的概率。 由于所有类别的概率加在一起，因此增加一个类别的概率会降低其他类别的概率，这是一个不错的功能。 在以后的章节中将对此进行更多介绍。
 
 ##### 查找错误
 
@@ -482,7 +482,7 @@ net = nn.Sequential(
 
 ### 功能模块
 
-`nn.functional`模块附带我们需要将网络节点连接在一起的操作。 在我们的模型中，我们使用`functional`模块中的 S 形作为非线性激活。 `functional`模块具有更多功能，例如您正在执行的所有数学函数都指向`functional`模块。 在下面的示例中，乘法运算符从`functional`模块调用`mul`运算符：
+`nn.functional`模块附带我们需要将网络节点连接在一起的操作。 在我们的模型中，我们使用`functional`模块中的 Sigmoid作为非线性激活。 `functional`模块具有更多功能，例如您正在执行的所有数学函数都指向`functional`模块。 在下面的示例中，乘法运算符从`functional`模块调用`mul`运算符：
 
 ```py
 >>> a = torch.randn(1,2)
@@ -519,9 +519,9 @@ tensor([[1]], dtype=torch.uint8)
 
 图 2.10：乙状结肠激活
 
-尽管 sigmoid 对输入非线性作用，但它不会产生以零为中心的输出。 逐渐消失的梯度和计算上昂贵的取幂是 S 型曲线的其他缺点，由于这些原因，几乎所有深度学习从业人员如今都没有在任何用例中使用 S 型曲线。 找到合适的非线性是一个主要的研究领域，人们已经提出了更好的解决方案，例如 ReLU，Leaky ReLU 和 ELU。 在以后的章节中，我们将看到其中的大多数。
+尽管 sigmoid 对输入非线性作用，但它不会产生以零为中心的输出。 逐渐消失的梯度和计算上昂贵的取幂是 Sigmoid曲线的其他缺点，由于这些原因，几乎所有深度学习从业人员如今都没有在任何用例中使用 Sigmoid曲线。 找到合适的非线性是一个主要的研究领域，人们已经提出了更好的解决方案，例如 ReLU，Leaky ReLU 和 ELU。 在以后的章节中，我们将看到其中的大多数。
 
-在`FizBuzNet`的`forward`函数内部，我们有两个线性层和两个非线性激活层。 通常，`forward`函数的输出返回是代表概率分布的对数，其中正确的类获得较高的值，但是在我们的模型中，我们从 S 型返回输出。
+在`FizBuzNet`的`forward`函数内部，我们有两个线性层和两个非线性激活层。 通常，`forward`函数的输出返回是代表概率分布的对数，其中正确的类获得较高的值，但是在我们的模型中，我们从 Sigmoid返回输出。
 
 ### 损失功能
 

new/pt-dl-handson/5.md

@@ -370,7 +370,7 @@ LSTM 网络由 Sepp Hochreiter 于 1991 年引入，并于 1997 年发布。LSTM
 
 LSTM 主要由遗忘门，更新门和单元状态组成，这使得 LSTM 与常规 RNN 单元不同。 该架构经过精心设计，可以执行特定任务。 遗忘门使用输入向量和先前状态的隐藏状态来确定例如应忘记的内容，更新门使用当前输入和先前的隐藏状态来确定应添加到信息存储库中的内容。
 
-这些决定基于 S 形层的输出，该层始终输出一个介于 0 到 1 范围内的值。 因此，“遗忘门”中的值 1 表示记住所有内容，而值 0 则表示忘记所有内容。 更新门同样适用。
+这些决定基于 Sigmoid层的输出，该层始终输出一个介于 0 到 1 范围内的值。 因此，“遗忘门”中的值 1 表示记住所有内容，而值 0 则表示忘记所有内容。 更新门同样适用。
 
 所有操作都将在并行流经网络的单元状态上执行，这与网络中的信息仅具有线性交互作用，因此允许数据无缝地向前和向后流动。
 

new/pt-dl-handson/6.md

@@ -165,7 +165,7 @@ for epoch in range(25):
 
 ##### 门控 PixelCNN
 
-DeepMind 在 PixelCNN 的一篇迭代论文中成功地使用了门控 PixelCNN ，该方法通过用 S 型和 tanh 构建的门代替 ReLU 激活函数。 PixelCNN [1]的介绍性论文提供了三种用于解决同一代网络的不同方法，其中具有 RNN 的模型优于其他两种。 DeepMind 仍引入了基于 CNN 的模型来显示与 PixelRNN 相比的速度增益。 但是，随着 PixelCNN 中门控激活的引入，作者能够将性能与 RNN 变体相匹配，从而获得更大的性能增益。 同一篇论文介绍了一种避免盲点并在生成时增加全局和局部条件的机制，这超出了本书的范围，因为对于 WaveNet 模型而言这不是必需的。
+DeepMind 在 PixelCNN 的一篇迭代论文中成功地使用了门控 PixelCNN ，该方法通过用 Sigmoid和 tanh 构建的门代替 ReLU 激活函数。 PixelCNN [1]的介绍性论文提供了三种用于解决同一代网络的不同方法，其中具有 RNN 的模型优于其他两种。 DeepMind 仍引入了基于 CNN 的模型来显示与 PixelRNN 相比的速度增益。 但是，随着 PixelCNN 中门控激活的引入，作者能够将性能与 RNN 变体相匹配，从而获得更大的性能增益。 同一篇论文介绍了一种避免盲点并在生成时增加全局和局部条件的机制，这超出了本书的范围，因为对于 WaveNet 模型而言这不是必需的。
 
 ### WaveNet
 
@@ -262,7 +262,7 @@ causalconv = torch.nn.Conv1d(
 							bias=False)
 ```
 
-WaveNet 的完整架构建立在膨胀卷积网络和卷积后门控激活的基础之上。 WaveNet 中的数据流从因果卷积运算开始，这是一种正常的一维卷积，然后传递到膨胀的卷积节点。 WaveNet 图片中的每个白色圆圈（“图 6.9”）是一个扩展的卷积节点。 然后，将正常卷积的数据点传递到膨胀的卷积节点，然后将其独立地通过 S 型门和 tanh 激活。 然后，两个运算的输出通过逐点乘法运算符和 1x1 卷积进行。 WaveNet 使用剩余连接和跳过连接来平滑数据流。 与主流程并行运行的剩余线程通过加法运算与 1x1 卷积的输出合并。
+WaveNet 的完整架构建立在膨胀卷积网络和卷积后门控激活的基础之上。 WaveNet 中的数据流从因果卷积运算开始，这是一种正常的一维卷积，然后传递到膨胀的卷积节点。 WaveNet 图片中的每个白色圆圈（“图 6.9”）是一个扩展的卷积节点。 然后，将正常卷积的数据点传递到膨胀的卷积节点，然后将其独立地通过 Sigmoid门和 tanh 激活。 然后，两个运算的输出通过逐点乘法运算符和 1x1 卷积进行。 WaveNet 使用剩余连接和跳过连接来平滑数据流。 与主流程并行运行的剩余线程通过加法运算与 1x1 卷积的输出合并。
 
 ![WaveNet](img/B09475_06_13.jpg)
 
@@ -292,7 +292,7 @@ class WaveNetModule(torch.nn.Module):
         return output.contiguous()
 ```
 
-前面的代码块中给出的程序是主要的父 WaveNet 模块，该模块使用所有子组件来创建图形。 `init`定义了三个主要成分，其中是第一个普通卷积，然后是`res_stack`（它是由所有膨胀卷积和 S 型正切门组成的残差连接块）。 然后，最后的`convdensnet`在 1x1 卷积的顶部进行。 `forward`引入一个求和节点，依次执行这些模块。 然后，将`convdensnet`创建的输出通过`contiguous()`移动到存储器的单个块。 这是其余网络所必需的。
+前面的代码块中给出的程序是主要的父 WaveNet 模块，该模块使用所有子组件来创建图形。 `init`定义了三个主要成分，其中是第一个普通卷积，然后是`res_stack`（它是由所有膨胀卷积和 Sigmoid正切门组成的残差连接块）。 然后，最后的`convdensnet`在 1x1 卷积的顶部进行。 `forward`引入一个求和节点，依次执行这些模块。 然后，将`convdensnet`创建的输出通过`contiguous()`移动到存储器的单个块。 这是其余网络所必需的。
 
 `ResidualStack`是需要更多说明的模块，它是 WaveNet 架构的核心。 `ResidualStack`是`ResidualBlock`的层的堆栈。 WaveNet 图片中的每个小圆圈都是一个残差块。 在正常卷积之后，数据到达`ResidualBlock`，如前所述。 `ResidualBlock`从膨胀的卷积开始，并且期望得到膨胀。 因此，`ResidualBlock`决定了架构中每个小圆节点的膨胀因子。 如前所述，膨胀卷积的输出然后通过类似于我们在 PixelCNN 中看到的门的门。
 
@@ -414,7 +414,7 @@ class DiscriminatorNet(torch.nn.Module):
 
 图 6.14：ReLU 和泄漏的 ReLU
 
-我们开发的的简单区分器具有三个连续层。 每个层都有一个线性层，泄漏的 ReLU 和一个夹在中间的漏失层，然后是一个线性层和一个 S 型门。 通常，概率预测网络使用 softmax 层作为最后一层； 像这样的简单 GAN 最适合 S 型曲面。
+我们开发的的简单区分器具有三个连续层。 每个层都有一个线性层，泄漏的 ReLU 和一个夹在中间的漏失层，然后是一个线性层和一个 Sigmoid门。 通常，概率预测网络使用 softmax 层作为最后一层； 像这样的简单 GAN 最适合 Sigmoid曲面。
 
 ```py
 def train_discriminator(optimizer, real_data, fake_data):
@@ -467,7 +467,7 @@ def noise(size):
 
 可以定义一个噪声生成函数，该函数可以生成随机样本（事实证明，这种采样在高斯分布而非随机分布下是有效的，但为简单起见，此处使用随机分布）。 如果 CUDA 可用，我们会将随机产生的噪声从 CPU 内存传输到 GPU 内存，并返回张量，其输出大小为`100`。 因此，生成网络期望输入噪声的特征数量为 100，而我们知道 MNIST 数据集中有 784 个数据点（28x28）。
 
-对于生成器，我们具有与判别器类似的结构，但是在最后一层具有 tanh 层，而不是 S 型。 进行此更改是为了与我们对 MNIST 数据进行的归一化同步，以将其转换为-1 到 1 的范围，以便判别器始终获得具有相同范围内数据点的数据集。 生成器中的三层中的每一层都将输入噪声上采样到 784 的输出大小，就像我们在判别器中下采样以进行分类一样。
+对于生成器，我们具有与判别器类似的结构，但是在最后一层具有 tanh 层，而不是 Sigmoid。 进行此更改是为了与我们对 MNIST 数据进行的归一化同步，以将其转换为-1 到 1 的范围，以便判别器始终获得具有相同范围内数据点的数据集。 生成器中的三层中的每一层都将输入噪声上采样到 784 的输出大小，就像我们在判别器中下采样以进行分类一样。
 
 ```py
 class GeneratorNet(torch.nn.Module):

new/pt-tut-17/45.md

@@ -113,7 +113,7 @@ Extension(
 
 ### 编写 C++  Op
 
-让我们开始以 C++ 实现 LLTM！ 我们需要向后传递的一项功能是 S 型导数。 这是一小段代码，用于讨论编写 C++ 扩展时可供我们使用的总体环境：
+让我们开始以 C++ 实现 LLTM！ 我们需要向后传递的一项功能是 Sigmoid导数。 这是一小段代码，用于讨论编写 C++ 扩展时可供我们使用的总体环境：
 
 ```py
 #include <torch/extension.h>

new/pt-tut-17/49.md

@@ -4,7 +4,7 @@
 
 `autograd`软件包对于在 PyTorch 中构建高度灵活和动态的神经网络至关重要。 PyTorch Python 前端中的大多数 autograd API 也可以在 C++ 前端中使用，从而可以轻松地将 autograd 代码从 Python 转换为 C++。
 
-在本教程中，我们将看几个在 PyTorch C++ 前端中进行 autograd 的示例。 请注意，本教程假定您已经对 Python 前端中的 autograd 有基本的了解。 如果不是这种情况，请先阅读 [Autograd：自动分化](https://pytorch.org/tutorials/beginner/blitz/autograd_tutorial.html)。
+在本教程中，我们将看几个在 PyTorch C++ 前端中进行 autograd 的示例。 请注意，本教程假定您已经对 Python 前端中的 autograd 有基本的了解。 如果不是这种情况，请先阅读 [Autograd：自动微分](https://pytorch.org/tutorials/beginner/blitz/autograd_tutorial.html)。
 
 ## 基本的 autograd 操作
 

new/rl-tf/00.md

@@ -47,7 +47,7 @@
 
 本书中使用了许多文本约定。
 
-`CodeInText`：指示文本，数据库表名称，文件夹名称，文件名，文件扩展名，路径名，虚拟 URL，用户输入和 Twitter 句柄中的代码字。 这是一个示例：“ `sigmoid(x)`和`relu(x)`分别指执行 S 型和 ReLU 激活计算的功能。”
+`CodeInText`：指示文本，数据库表名称，文件夹名称，文件名，文件扩展名，路径名，虚拟 URL，用户输入和 Twitter 句柄中的代码字。 这是一个示例：“ `sigmoid(x)`和`relu(x)`分别指执行 Sigmoid和 ReLU 激活计算的功能。”
 
 代码块设置如下：
 

new/rl-tf/01.md

@@ -98,23 +98,23 @@
 
 # 乙状结肠功能
 
-乙状结肠是一种平滑且连续可微的功能。 这导致非线性输出。 S 形函数在这里表示：
+乙状结肠是一种平滑且连续可微的功能。 这导致非线性输出。 Sigmoid函数在这里表示：
 
 ![](img/9241aa68-606b-4192-b3cc-ccb29f4ef110.png)
 
-请查看下图的 S 型函数观察结果。 该函数的范围是 0 到 1。观察函数的曲线，我们看到`x`值介于-3 和 3 之间时，梯度非常高，但超出此范围则变得平坦。 因此，可以说这些点附近的`x`的微小变化将使 S 型函数的值产生较大的变化。 因此，功能目标是将 S 型功能的值推向极限。
+请查看下图的 Sigmoid函数观察结果。 该函数的范围是 0 到 1。观察函数的曲线，我们看到`x`值介于-3 和 3 之间时，梯度非常高，但超出此范围则变得平坦。 因此，可以说这些点附近的`x`的微小变化将使 Sigmoid函数的值产生较大的变化。 因此，功能目标是将 Sigmoid功能的值推向极限。
 
 因此，它被用于分类问题：
 
 ![](img/ba07be70-2b01-4112-be20-9689a19ac370.png)
 
-查看下面的 S 型函数的梯度，我们观察到取决于`x`的平滑曲线。 由于梯度曲线是连续的，因此很容易反向传播误差并更新参数![](img/62159668-8474-4e17-be25-39d5adf63489.png)和![](img/aff45916-8e2d-4140-9b75-9ce9f0681b4e.png)：
+查看下面的 Sigmoid函数的梯度，我们观察到取决于`x`的平滑曲线。 由于梯度曲线是连续的，因此很容易反向传播误差并更新参数![](img/62159668-8474-4e17-be25-39d5adf63489.png)和![](img/aff45916-8e2d-4140-9b75-9ce9f0681b4e.png)：
 
 ![](img/d8011c52-5574-4521-a42d-e18893417c8d.png)
 
 乙状结肠得到广泛使用，但其缺点是该函数趋于+3 和-3 平坦。 因此，无论何时函数落在该区域中，梯度都趋于接近零，并且我们的神经网络学习停止。
 
-由于 S 形函数输出的值从 0 到 1，即全为正，因此它在原点周围是非对称的，并且所有输出信号都是正的，即具有相同的符号。 为了解决这个问题，已将 S 形函数缩放为 tanh 函数，我们将在下面进行研究。 而且，由于梯度导致的值很小，因此很容易遇到梯度消失的问题（我们将在本章稍后讨论）。
+由于 Sigmoid函数输出的值从 0 到 1，即全为正，因此它在原点周围是非对称的，并且所有输出信号都是正的，即具有相同的符号。 为了解决这个问题，已将 Sigmoid函数缩放为 tanh 函数，我们将在下面进行研究。 而且，由于梯度导致的值很小，因此很容易遇到梯度消失的问题（我们将在本章稍后讨论）。
 
 # tanh 功能
 
@@ -126,13 +126,13 @@ Tanh 是围绕原点对称的连续函数。 它的范围是-1 至 1。tanh 函
 
 ![](img/93d7dc16-99f6-48f9-b12f-39bb21a534d6.png)
 
-现在看下面的 tanh 函数的梯度曲线，我们发现它比 S 型函数陡峭。 tanh 函数还具有消失的梯度问题：
+现在看下面的 tanh 函数的梯度曲线，我们发现它比 Sigmoid函数陡峭。 tanh 函数还具有消失的梯度问题：
 
 ![](img/1472e114-eba7-4719-9668-48f28c2716b0.png)
 
 # softmax 函数
 
-softmax 函数主要用于处理分类问题，并且最好在输出层中使用，以输出输出类别的概率。 如前所述，在解决二进制逻辑回归时，我们看到 S 型函数只能处理两个类。 为了处理多类，我们需要一个可以为所有类生成值的函数，这些值遵循概率规则。 这个目标是通过 softmax 函数实现的，该函数将每个类别的输出缩小在 0 和 1 之间，然后将它们除以所有类别的输出总和：
+softmax 函数主要用于处理分类问题，并且最好在输出层中使用，以输出输出类别的概率。 如前所述，在解决二进制逻辑回归时，我们看到 Sigmoid函数只能处理两个类。 为了处理多类，我们需要一个可以为所有类生成值的函数，这些值遵循概率规则。 这个目标是通过 softmax 函数实现的，该函数将每个类别的输出缩小在 0 和 1 之间，然后将它们除以所有类别的输出总和：
 
 ![](img/38a1827e-ea6a-4f2d-8a42-0474cdd3ab8f.png)
 
@@ -194,7 +194,7 @@ Logistic 回归是一种分类器算法。 在这里，我们尝试预测输出
 
 对于任何神经网络的所有预测输出层而言，答案都是正确的，即预测输出应遵循概率分布。 正常来说，输出具有`N`个类别。 对于具有例如`d`维的输入数据，这将导致`N`个概率。 因此，此一个输入数据的`N`概率之和应为 1，并且这些概率中的每一个应在 0 到 1 之间（含 0 和 1）。
 
-一方面，在大多数情况下，`N`个不同类别的 S 形函数之和可能不为 1。 因此，在二进制的情况下，使用 S 形函数来获得一个类别的概率，即`p(y = 1 | x)`，而对于另一个类别，则是概率，即`p(y = 0 | x) = 1 - p(y = 1 | x)`。 另一方面，softmax 函数的输出是满足概率分布属性的值。 在图中，![](img/b10ccd66-8bc6-433c-9367-1d501eb4c414.png)指的是 S 型函数：
+一方面，在大多数情况下，`N`个不同类别的 Sigmoid函数之和可能不为 1。 因此，在二进制的情况下，使用 Sigmoid函数来获得一个类别的概率，即`p(y = 1 | x)`，而对于另一个类别，则是概率，即`p(y = 0 | x) = 1 - p(y = 1 | x)`。 另一方面，softmax 函数的输出是满足概率分布属性的值。 在图中，![](img/b10ccd66-8bc6-433c-9367-1d501eb4c414.png)指的是 Sigmoid函数：
 
 ![](img/b2853099-2f91-4eee-a8aa-958bd42e566f.png)
 
@@ -236,11 +236,11 @@ Logistic 回归是一种分类器算法。 在这里，我们尝试预测输出
 
 参考上图中的二进制逻辑回归：
 
-*   预测的输出，即![](img/46e0323f-698a-4145-a085-d03c1221d008.png)。 在此，S 形函数将![](img/182eba67-ac7b-4c57-93ef-6d771c9f9d95.png)的值缩小为 0 到 1。
+*   预测的输出，即![](img/46e0323f-698a-4145-a085-d03c1221d008.png)。 在此，Sigmoid函数将![](img/182eba67-ac7b-4c57-93ef-6d771c9f9d95.png)的值缩小为 0 到 1。
 
-*   这意味着，当![](img/c35a1710-98bc-4851-9e88-30e5636f5c72.png)时，它是 S 型函数，即![](img/288e6755-493a-4f96-bbb8-2e215db3d11b.png)。
+*   这意味着，当![](img/c35a1710-98bc-4851-9e88-30e5636f5c72.png)时，它是 Sigmoid函数，即![](img/288e6755-493a-4f96-bbb8-2e215db3d11b.png)。
 
-*   当![](img/0e16d4e3-033d-4627-9719-4f5e26bd0d00.png)时，它的 S 形函数即![](img/0cca4fa7-fa1b-4aae-be53-cf3cc9b032c7.png)。
+*   当![](img/0e16d4e3-033d-4627-9719-4f5e26bd0d00.png)时，它的 Sigmoid函数即![](img/0cca4fa7-fa1b-4aae-be53-cf3cc9b032c7.png)。
 
 一旦我们计算出![](img/ca330c46-9a8d-4f2e-95b7-b69222f6ee85.png)，即预测的输出，就完成了前向传播任务。 现在，我们将使用成本函数计算误差值，并尝试通过梯度下降来更改参数`W`和`b`的值，从而反向传播以最小化误差值。
 
@@ -635,7 +635,7 @@ Szegedy 等人从卷积开始深入研究（https://arxiv.org/pdf/1409.4842.pdf
 
 这两个可能的问题可以通过以下方法克服：
 
-*   减少使用 S 型和 tanh 激活函数
+*   减少使用 Sigmoid和 tanh 激活函数
 *   使用基于动量的随机梯度下降
 *   权重和偏差的正确初始化，例如 xavier 初始化
 *   正则化（将正则化丢失与数据丢失一起添加并最小化）

new/rl-tf/04.md

@@ -430,7 +430,7 @@ else:
     rmsprop_cache = {k: np.zeros_like(v) for k,v in model.iteritems()} #to store the value of rms prop formula
 ```
 
-*   **激活函数**：`sigmoid(x)`和`relu(x)`分别指执行 S 型和 ReLU 激活计算的函数。 我们将使用以下代码定义函数：
+*   **激活函数**：`sigmoid(x)`和`relu(x)`分别指执行 Sigmoid和 ReLU 激活计算的函数。 我们将使用以下代码定义函数：
 
 ```py
 #activation function

new/rl-tf/14.md

@@ -113,7 +113,7 @@ Paulus 等人（2017）在[《用于抽象摘要的深度强化模型》](https:
 
 ![](img/dad29271-c02b-4fb9-9cd5-e418dff4385a.png)
 
-在此，![](img/a1ddc448-c450-4632-ada7-26e0d98ebdcf.png)是 S 形激活函数。
+在此，![](img/a1ddc448-c450-4632-ada7-26e0d98ebdcf.png)是 Sigmoid激活函数。
 
 # 混合学习目标