2020-08-06 22:17:11

docs/dl-tf-2e-zh/ch05.md

@@ -42,7 +42,7 @@ n_hidden_1 = 256
 n_hidden_2 = 128
 ```
 
-最终尺寸对应于 28×28 = 784 像素。
+最终尺寸对应于`28×28 = 784`像素。
 
 我们需要为输入图像定义占位符变量。该张量的数据类型设置为`float`，因为`mnist`值的比例为[0,1]，形状设置为`[None, n_input]`。定义`None`参数意味着张量可以包含任意数量的图像：
 
@@ -93,7 +93,7 @@ encoder_in = tf.nn.sigmoid(tf.add\
 
 ![Implementing autoencoders with TensorFlow](img/B09698_05_32.jpg)
 
-这里，W 是权重张量，`encoder_h1`，b 是偏置张量，`encoder_b1`。通过这个操作，我们将初始图像编码为自编码器的有用输入。编码过程的第二步包括数据压缩。输入`encoder_in`张量表示的数据通过第二个矩阵乘法运算减小到较小的大小：
+这里，`W`是权重张量，`encoder_h1`，`b`是偏置张量，`encoder_b1`。通过这个操作，我们将初始图像编码为自编码器的有用输入。编码过程的第二步包括数据压缩。输入`encoder_in`张量表示的数据通过第二个矩阵乘法运算减小到较小的大小：
 
 ```py
 encoder_out = tf.nn.sigmoid(tf.add\
@@ -106,7 +106,7 @@ encoder_out = tf.nn.sigmoid(tf.add\
 
 ![Implementing autoencoders with TensorFlow](img/B09698_05_33.jpg)
 
-这里，W 代表权重张量`encoder_h2`，而 b 代表偏差张量，`encoder_b2`。请注意，我们使用 sigmoid 作为编码器阶段的激活函数。
+这里，`W`代表权重张量`encoder_h2`，而`b`代表偏差张量，`encoder_b2`。请注意，我们使用 sigmoid 作为编码器阶段的激活函数。
 
 解码器执行编码器的逆操作。它解压缩输入以获得相同大小的网络输入的输出。该过程的第一步是将大小为 128 的`encoder_out`张量转换为 256 大小的中间表示的张量：
 
@@ -121,7 +121,7 @@ decoder_in = tf.nn.sigmoid(tf.add\
 
 ![Implementing autoencoders with TensorFlow](img/B09698_05_34.jpg)
 
-这里，W 是权重张量，`decoder_h1`，大小 256×128，b 是偏置张量，`decoder_b1`，大小 256.最终解码操作是将数据从其中间表示（大小为 256）解压缩到最终表示（维度 784），这是原始数据的大小：
+这里，`W`是权重张量，`decoder_h1`，大小`256×128`，`b`是偏置张量，`decoder_b1`，大小 256。最终解码操作是将数据从其中间表示（大小为 256）解压缩到最终表示（维度 784），这是原始数据的大小：
 
 ```py
 decoder_out = tf.nn.sigmoid(tf.add\
@@ -316,7 +316,7 @@ x = tf.placeholder("float", [None, n_input])
 y = tf.placeholder("float", [None, n_output])
 ```
 
-为了减少过拟合，我们在编码和解码过程之前应用一个 dropout，因此我们必须定义一个占位符，以便在 dropout 期间保持神经元输出的概率：
+为了减少过拟合，我们在编码和解码过程之前应用一个丢弃，因此我们必须定义一个占位符，以便在丢弃期间保持神经元输出的概率：
 
 ```py
 dropout_keep_prob = tf.placeholder("float")
@@ -357,7 +357,7 @@ decode_in = tf.nn.sigmoid\
                   biases['b2']))
 ```
 
-过拟合的减少是通过 dropout 程序来完成的：
+过拟合的减少是通过丢弃程序来完成的：
 
 ```py
 decode_out = tf.nn.dropout(decode_in,\
@@ -526,7 +526,7 @@ Test label is 5
 
 ### 编码器
 
-编码器由三个卷积层组成。特征数量从输入数据 1 变为第一卷积层的 16;然后，第二层从 16 到 32;最后，从最后一个卷积层的 32 到 64。从卷积层移动到另一个层时，形状经历图像压缩：
+编码器由三个卷积层组成。特征数量从输入数据 1 变为第一卷积层的 16；然后，第二层从 16 到 32；最后，从最后一个卷积层的 32 到 64。从卷积层移动到另一个层时，形状经历图像压缩：
 
 ![Encoder](img/B09698_05_09.jpg)
 
@@ -576,7 +576,7 @@ x = tf.placeholder(tf.float32, [None, dim])
 y = tf.placeholder(tf.float32, [None, dim])
 ```
 
-然后我们定义`keepprob`变量，[用于配置在网络训练期间使用的 dropout 率](https://www.tensorflow.org/tutorials/layers#dropout)：
+然后我们定义`keepprob`变量，[用于配置在网络训练期间使用的丢弃率](https://www.tensorflow.org/tutorials/layers#dropout)：
 
 ```py
 keepprob = tf.placeholder(tf.float32)
@@ -631,7 +631,7 @@ biases = {
 def cae(_X, _W, _b, _keepprob):
 ```
 
-最初的 784 像素图像必须重新整形为 28×28 矩阵，随后由下一个卷积层处理：
+最初的 784 像素图像必须重新整形为`28×28`矩阵，随后由下一个卷积层处理：
 
 ```py
     _input_r = tf.reshape(_X, shape=[-1, 28, 28, 1])
@@ -648,13 +648,13 @@ def cae(_X, _W, _b, _keepprob):
                    _b['be1']))
 ```
 
-在移动到第二个卷积层之前，我们应用了 dropout 操作：
+在移动到第二个卷积层之前，我们应用了丢弃操作：
 
 ```py
     _ce1 = tf.nn.dropout(_ce1, _keepprob)
 ```
 
-在下面的两个编码层中，我们应用相同的卷积和 dropout 操作：
+在下面的两个编码层中，我们应用相同的卷积和丢弃操作：
 
 ```py
     _ce2 = tf.nn.sigmoid\
@@ -673,7 +673,7 @@ def cae(_X, _W, _b, _keepprob):
     _ce3 = tf.nn.dropout(_ce3, _keepprob)
 ```
 
-特征数量从 1（输入图像）增加到 64，而原始形状图像已减少到 28×28 到 7×7。在解码阶段，压缩（或编码）和重新成形的图像必须为尽可能与原始图像相似。为实现这一目标，我们在接下来的三个层中使用了`conv2d_transpose` TensorFlow 函数：
+特征数量从 1（输入图像）增加到 64，而原始形状图像已减少到`28×28`到`7×7`。在解码阶段，压缩（或编码）和重新成形的图像必须为尽可能与原始图像相似。为实现这一目标，我们在接下来的三个层中使用了`conv2d_transpose` TensorFlow 函数：
 
 ```py
 tf.nn.conv2d_transpose(value, filter, output_shape, strides, padding='SAME')
@@ -687,7 +687,7 @@ tf.nn.conv2d_transpose(value, filter, output_shape, strides, padding='SAME')
 *   `strides`：整数列表。输入张量的每个维度的滑动窗口的步幅。
 *   `padding`：一个有效的字符串或`SAME`。
 
-`conv2d_transpose`函数将返回与`value`参数类型相同的张量。第一个去卷积层`_cd3`具有卷积层`_ce3`作为输入。它返回`_cd3`张量，其形状为（1,7,7,32）：
+`conv2d_transpose`函数将返回与`value`参数类型相同的张量。第一个去卷积层`_cd3`具有卷积层`_ce3`作为输入。它返回`_cd3`张量，其形状为`(1,7,7,32)`：
 
 ```py
     _cd3 = tf.nn.sigmoid\
@@ -700,7 +700,7 @@ tf.nn.conv2d_transpose(value, filter, output_shape, strides, padding='SAME')
     _cd3 = tf.nn.dropout(_cd3, _keepprob)
 ```
 
-对于第二个去卷积层`_cd2`，我们将反卷积层`_cd3`作为输入传递。它返回`_cd2`张量，其形状为（1,14,14,16）：
+对于第二个去卷积层`_cd2`，我们将反卷积层`_cd3`作为输入传递。它返回`_cd2`张量，其形状为`(1,14,14,16)`：
 
 ```py
     _cd2 = tf.nn.sigmoid\
@@ -713,7 +713,7 @@ tf.nn.conv2d_transpose(value, filter, output_shape, strides, padding='SAME')
     _cd2 = tf.nn.dropout(_cd2, _keepprob)
 ```
 
-第三个也是最后一个反卷积层`_cd1`将`_cd2`层作为输入传递。它返回结果`_out`张量，其形状为（1,28,28,1），与输入图像相同：
+第三个也是最后一个反卷积层`_cd1`将`_cd2`层作为输入传递。它返回结果`_out`张量，其形状为`(1,28,28,1)`，与输入图像相同：
 
 ```py
     _cd1 = tf.nn.sigmoid\
@@ -891,7 +891,7 @@ Andrea Dal Pozzolo，Olivier Caelen，Reid A. Johnson 和 Gianluca Bontempi。
 
 该数据集包含 2013 年 9 月欧洲信用卡持有人在两天内进行的交易。共有 285,299 笔交易，只有 492 笔欺诈，这意味着数据集非常不平衡。正类（欺诈）占所有交易的 0.172%。
 
-数据集包含数字输入变量，这些变量是 PCA 转换的结果。遗憾的是，由于机密性问题，我们无法提供有关数据的原始特征和更多背景信息。有[28]特征，即`V1`，`V2`，... `V27`，它们是使用 PCA 获得的主要成分，除了`Time`和`Amount`特征。 `Class`特征是响应变量，在欺诈情况下取值`1`，否则取`0`。
+数据集包含数字输入变量，这些变量是 PCA 转换的结果。遗憾的是，由于机密性问题，我们无法提供有关数据的原始特征和更多背景信息。有 28 个特征，即`V1`，`V2`，... `V27`，它们是使用 PCA 获得的主要成分，除了`Time`和`Amount`特征。 `Class`特征是响应变量，在欺诈情况下取值`1`，否则取`0`。
 
 还有两个附加特征，`Time`和`Amount`。 `Time`列表示每笔交易与第一笔交易之间的时间（以秒为单位），而`Amount`列表示此交易中转账的金额。那么，让我们看一下输入数据（仅显示`V1`，`V2`，`V26`和`V27`），如图 16 所示：
 
@@ -946,7 +946,7 @@ $ pip3 install git+https://github.com/mwaskom/seaborn.git
 
 现在，[我假设您已经从上述 URL 下载了数据集](https://www.kaggle.com/hunk3749/credit-card/data)。下载附带一个名为`creditcard.csv`的 CSV 文件。
 
-接下来，让我们阅读数据集并创建一个 pandas DataFrame：
+接下来，让我们阅读数据集并创建一个 pandas `DataFrame`：
 
 ```py
 df = pd.read_csv('creditcard.csv')
@@ -1054,12 +1054,12 @@ Total test examples: 56962, total fraud cases: 75, equal to 0.13167 % of total c
 
 ## 归一化
 
-为了获得更好的预测准确率，我们可以考虑两种类型的标准化：z-score 和 min-max scaling：
+为了获得更好的预测准确率，我们可以考虑两种类型的标准化：z 得分和 min-max 缩放：
 
 *   Z 得分：这将每列归一化为零均值并将其标准化。这特别适用于激活函数，例如 tanh，其输出零两侧的值。其次，这将留下极端的价值，因此在正常化之后会有一些极端。在这种情况下，这可能对检测异常值很有用。
 *   最小 - 最大缩放：这确保所有值都在 0 和 1 之间，即正数。如果我们使用 sigmoid 作为输出激活，这是默认方法。
 
-我们使用验证集来决定数据标准化方法和激活函数。根据实验，我们发现当与 z-score 标准化一起使用时，tanh 的表现略好于 sigmoid。因此，我们选择了 tanh，然后是 z-score：
+我们使用验证集来决定数据标准化方法和激活函数。根据实验，我们发现当与 z 得分标准化一起使用时，tanh 的表现略好于 sigmoid。因此，我们选择了 tanh，然后是 z 得分：
 
 ```py
 cols_mean = []
@@ -1072,7 +1072,7 @@ for c in range(train_x.shape[1]):
     test_x[:, c] =  (test_x[:, c] - cols_mean[-1]) / cols_std[-1]
 ```
 
-## Autoencoder 作为无监督特征学习算法
+## 自编码器作为无监督特征学习算法
 
 在本小节中，我们将看到如何使用自编码器作为无监督的特征学习算法。首先，让我们初始化网络超参数：
 
@@ -1128,7 +1128,7 @@ def decoder(x):
     return layer_1
 ```
 
-之后，我们通过传递输入数据的 TensorFlow 占位符来构建模型。权重和偏差（NN 的 Ws 和 bs）包含我们将学习优化的网络的所有参数，如下所示：
+之后，我们通过传递输入数据的 TensorFlow 占位符来构建模型。权重和偏差（NN 的`W`和`b`）包含我们将学习优化的网络的所有参数，如下所示：
 
 ```py
 encoder_op = encoder(X)
@@ -1152,7 +1152,7 @@ batch_mse = tf.reduce_mean(tf.pow(y_true - y_pred, 2), 1)
 
 未观测值的均方误差（MSE）是[平方误差](https://en.wikipedia.org/wiki/Errors_and_residuals)或[偏差](https://en.wikipedia.org/wiki/Deviation_(statistics))的[平均值](https://en.wikipedia.org/wiki/Expected_value)。从统计学的角度来看，  它是估计量质量的度量（它总是非负的，接近于零的值更好）。
 
-如果`Y^`是 n 个预测的向量，并且 Y 是被预测变量的观测值的向量，则预测变量的样本内 MSE 计算如下：
+如果`Y^`是 n 个预测的向量，并且`Y`是被预测变量的观测值的向量，则预测变量的样本内 MSE 计算如下：
 
 ![Autoencoder as an unsupervised feature learning algorithm](img/B09698_05_36.jpg)
 
@@ -1309,7 +1309,7 @@ plt.show()
 
 图 20：非欺诈案件的 MSE 欺诈评分
 
-前面的屏幕截图是不可理解的，所以让我们将其缩放到（0,30）范围并再次绘制图形：
+前面的屏幕截图是不可理解的，所以让我们将其缩放到`(0, 30)`范围并再次绘制图形：
 
 ```py
 # Zoom into (0, 30) range
@@ -1322,7 +1322,7 @@ plt.show()
 
 ![Evaluating the model](img/B09698_05_21.jpg)
 
-图 21：非欺诈案件的 MSE 欺诈评分，放大到（0,30）范围
+图 21：非欺诈案件的 MSE 欺诈评分，放大到`(0, 30)`范围
 
 现在让我们只显示欺诈类：
 
@@ -1362,7 +1362,7 @@ Compared to the average percentage of fraud in test set: 0.132%
 
 在本章中，我们实现了一些称为自编码器的优化网络。自编码器基本上是数据压缩网络模型。它用于将给定输入编码为较小维度的表示，然后可以使用解码器从编码版本重建输入。我们实现的所有自编码器都包含编码和解码部分。
 
-我们还看到了如何通过在网络训练期间引入噪声和构建去噪自编码器来提高自编码器的表现。最后，我们应用[第 4 章](../Text/ch04.html "Chapter 4. Convolutional Neural Networks")中介绍的 CNN 概念，卷积神经网络上的 TensorFlow 和卷积自编码器的实现。
+我们还看到了如何通过在网络训练期间引入噪声和构建去噪自编码器来提高自编码器的表现。最后，我们应用第 4 章中介绍的 CNN 概念，卷积神经网络上的 TensorFlow 和卷积自编码器的实现。
 
 即使隐藏单元的数量很大，我们仍然可以通过在网络上施加其他约束来使用自编码器发现数据集的有趣和隐藏结构。换句话说，如果我们对隐藏单元施加稀疏约束，那么即使隐藏单元的数量很大，自编码器仍将在数据中发现有趣的结构。为了证明这一论点，我们看到了一个真实的例子，即信用卡欺诈分析，我们成功应用了自编码器。
 

docs/dl-tf-2e-zh/ch06.md

@@ -32,7 +32,7 @@
 
 ![RNN and the gradient vanishing-exploding problem](img/B09698_06_61.jpg)
 
-现在让 E 代表输出层的损失：`E = f(O[t])`。然后，上述三个方程告诉我们 E 取决于输出`O[t]`。输出`O[t]`相对于层的隐藏状态（`h[t]`）的变化而变化。当前时间步长（`h[t]`）的隐藏状态取决于先前时间步长（`h[t-1]`）的神经元状态。现在，下面的等式将清除这个概念。
+现在让`E`代表输出层的损失：`E = f(O[t])`。然后，上述三个方程告诉我们`E`取决于输出`O[t]`。输出`O[t]`相对于层的隐藏状态（`h[t]`）的变化而变化。当前时间步长（`h[t]`）的隐藏状态取决于先前时间步长（`h[t-1]`）的神经元状态。现在，下面的等式将清除这个概念。
 
 相对于为隐藏层选择的参数的损失变化率`= ∂E/∂θ`，这是一个可以表述如下的链规则：
 
@@ -62,7 +62,7 @@
 
 ![RNN and the gradient vanishing-exploding problem](img/B09698_06_72.jpg)
 
-在这些情况下，`θ`也随着时间步长而变化。上面的等式显示了当前状态相对于先前状态的依赖性。现在让我们解释这两个方程的解剖。假设您处于时间步长 5（t = 5），那么 k 的范围从 1 到 5（k = 1 到 5），这意味着您必须为以下内容计算 k）：
+在这些情况下，`θ`也随着时间步长而变化。上面的等式显示了当前状态相对于先前状态的依赖性。现在让我们解释这两个方程的解剖。假设您处于时间步长 5（`t = 5`），那么`k`的范围从 1 到 5（`k = 1`到 5），这意味着您必须为以下内容计算`k`）：
 
 ![RNN and the gradient vanishing-exploding problem](img/B09698_06_75.jpg)
 
@@ -80,7 +80,7 @@
 
 最近在深度学习的背景下重新发现了这种类型的神经网络，因为它没有消失梯度的问题，并且提供了出色的结果和表现。基于 LSTM 的网络是时间序列的预测和分类的理想选择，并且正在取代许多传统的深度学习方法。
 
-这个名称意味着短期模式不会被遗忘。 LSTM 网络由彼此链接的单元（LSTM 块）组成。每个 LSTM 块包含三种类型的门：输入门，输出门和遗忘门，它们分别实现对单元存储器的写入，读取和复位功能。这些门不是二元的，而是模拟的（通常由映射在[0,1]范围内的 Sigmoid 激活函数管理，其中 0 表示总抑制，1 表示总激活）。
+这个名称意味着短期模式不会被遗忘。 LSTM 网络由彼此链接的单元（LSTM 块）组成。每个 LSTM 块包含三种类型的门：输入门，输出门和遗忘门，它们分别实现对单元存储器的写入，读取和复位功能。这些门不是二元的，而是模拟的（通常由映射在`[0, 1]`范围内的 Sigmoid 激活函数管理，其中 0 表示总抑制，1 表示总激活）。
 
 如果你认为 LSTM 单元是一个黑盒子，它可以像基本单元一样使用，除了它会表现得更好；训练将更快地收敛，它将检测数据中的长期依赖性。在 TensorFlow 中，您只需使用`BasicLSTMCell`代替`BasicRNNCell`：
 
@@ -108,7 +108,7 @@ LSTM 单元管理两个状态向量，并且出于表现原因，它们默认保
 
 由于长期`c(t)`从左到右穿过网络，你可以看到它首先通过一个遗忘门，丢弃一些内存，然后它添加一些新的存储器通过加法运算（增加了输入门选择的存储器）。结果`c(t)`直接发送，没有任何进一步的变换
 
-因此，在每个时间步骤，都会丢弃一些内存并添加一些内存。此外，在加法运算之后，长期状态被复制并通过 tanh 函数，该函数产生[-1，+ 1]范围内的输出。
+因此，在每个时间步骤，都会丢弃一些内存并添加一些内存。此外，在加法运算之后，长期状态被复制并通过 tanh 函数，该函数产生`[-1, +1]`范围内的输出。
 
 然后输出门过滤结果。这会产生短期`h(t)`（等于此时间步的单元输出`y(t)`）。现在，让我们来看看新记忆的来源以及大门如何运作。首先，当前输入`x(t)`和之前的短路`h(t-1)`被馈送到四个不同的完全连接。这些门的存在允许 LSTM 单元无限期地记住信息：事实上，如果输入门低于激活阈值，单元格将保持先前的状态，如果启用当前状态，它将与输入值组合。顾名思义，遗忘门重置单元的当前状态（当其值被清除为 0 时），输出门决定是否必须执行单元的值。
 
@@ -604,7 +604,7 @@ y = tf.placeholder(tf.float32, [None, seq_size])
 
 下一个任务是构建 LSTM 网络。以下方法`LSTM_Model()`采用三个参数，如下所示：
 
-*   `x`：大小为[T，batch_size，input_size]的输入
+*   `x`：大小为`[T, batch_size, input_size]`的输入
 *   `W`：完全连接的输出层权重矩阵
 *   `b`：完全连接的输出层偏置向量
 
@@ -1018,10 +1018,10 @@ def __load_preprocessed(self):
 1.  准备正则表达式模式。
 2.  清洁每个样本。
 3.  恢复 HTML 字符。
-4.  删除@users 和 URL。
+4.  删除`@users`和 URL。
 5.  转换为小写。
 6.  删除标点符号。
-7.  用 C 替换 CC（C +）（连续出现两次以上的字符）
+7.  用`C`替换`C+`（连续出现两次以上的字符）
 8.  删除停用词。
 
 现在让我们以编程方式编写上述步骤。为此，我们有以下函数：
@@ -1135,7 +1135,7 @@ lstm_model = LSTM_RNN_Network(hidden_size=[hidden_size],
 *   `max_length`：输入张量的最大长度
 *   `n_classes`：分类类的数量
 *   `learning_rate`：RMSProp 算法的学习率
-*   `random_state`：dropout 的随机状态
+*   `random_state`：丢弃的随机状态
 
 构造函数的代码如下：
 
@@ -1157,7 +1157,7 @@ def __init__(self, hidden_size, vocab_size, embedding_size, max_length, n_classe
         self.merged = tf.summary.merge_all()
 ```
 
-下一个函数被称为`_input()`，它采用一个名为 param `max_length`的参数，它是输入张量的最大长度。然后它返回一个输入占位符，其形状为`[batch_size, max_length]`，用于 TensorFlow 计算：
+下一个函数被称为`_input()`，它采用一个名为`max_length`的参数，它是输入张量的最大长度。然后它返回一个输入占位符，其形状为`[batch_size, max_length]`，用于 TensorFlow 计算：
 
 ```py
     def __input(self, max_length):
@@ -1171,14 +1171,14 @@ def __seq_len(self):
     return tf.placeholder(tf.int32, [None], name='lengths')
 ```
 
-下一个函数称为`_target()`。它需要一个名为 param `n_classes`的参数，它包含分类类的数量。最后，它返回形状为`[batch_size, n_classes]`的目标占位符：
+下一个函数称为`_target()`。它需要一个名为`n_classes`的参数，它包含分类类的数量。最后，它返回形状为`[batch_size, n_classes]`的目标占位符：
 
 ```py
 def __target(self, n_classes):
     return tf.placeholder(tf.float32, [None, n_classes], name='target')
 ```
 
-`_dropout_keep_prob()`返回一个持有 dropout 的占位符保持概率以减少过拟合：
+`_dropout_keep_prob()`返回一个持有丢弃的占位符保持概率以减少过拟合：
 
 ```py
 def __dropout_keep_prob(self):
@@ -1188,10 +1188,10 @@ def __dropout_keep_prob(self):
 `_cell()`方法用于构建带有压差包装器的 LSTM 单元。它需要以下参数：
 
 *   `hidden_size`：它是 LSTM 单元中的单元数
-*   `dropout_keep_prob`：这表示持有 dropout 保持概率的张量
-*   `seed`：它是一个可选值，可确保 dropout 包装器的随机状态计算的可重现性。
+*   `dropout_keep_prob`：这表示持有丢弃保持概率的张量
+*   `seed`：它是一个可选值，可确保丢弃包装器的随机状态计算的可重现性。
 
-最后，它返回一个带有 dropout 包装器的 LSTM 单元：
+最后，它返回一个带有丢弃包装器的 LSTM 单元：
 
 ```py
 def __cell(self, hidden_size, dropout_keep_prob, seed=None):
@@ -1217,9 +1217,9 @@ def __word_embeddings(self, x, vocab_size, embedding_size, seed=None):
 *   `hidden_size`：这是 LSTM 单元中的单元数
 *   `x`：这是带形状的输入
 *   `seq_len`：这是具有形状的序列长度张量
-*   `dropout_keep_prob`：这是持有 dropout 保持概率的张量
+*   `dropout_keep_prob`：这是持有丢弃保持概率的张量
 *   `variable_scope`：这是变量范围的名称（默认层是`rnn_layer`）
-*   `random_state`：这是 dropout 包装器的随机状态
+*   `random_state`：这是丢弃包装器的随机状态
 
 最后，它返回形状为`[batch_size, max_seq_len, hidden_size]`的输出：
 
@@ -1237,8 +1237,8 @@ def __rnn_layer(self, hidden_size, x, seq_len, dropout_keep_prob, variable_scope
 *   `seq_len`：这是形状`[batch_size]`的序列长度张量
 *   `hidden_size`：这是一个数组，其中包含每个 RNN 层中 LSTM 单元中的单元数
 *   `n_classes`：这是分类的数量
-*   `dropout_keep_prob`：这是持有 dropout 保持概率的张量
-*   `random_state`：这是一个可选参数，但它可用于确保 dropout 包装器的随机状态
+*   `dropout_keep_prob`：这是持有丢弃保持概率的张量
+*   `random_state`：这是一个可选参数，但它可用于确保丢弃包装器的随机状态
 
 最后，`_score()`方法返回具有形状`[batch_size, n_classes]`的每个类的线性激活：
 
@@ -1643,7 +1643,7 @@ Real sentiment: [1\. 0.]
 
 # 使用 LSTM 模型识别人类活动
 
-人类活动识别（HAR）数据库[​​HTG0] 是通过对携带带有嵌入式惯性传感器的腰部智能手机的 30 名参加日常生活活动（ADL）的参与者进行测量而建立的。目标是将他们的活动分类为前面提到的六个类别之一。
+人类活动识别（HAR）数据库是通过对携带带有嵌入式惯性传感器的腰部智能手机的 30 名参加日常生活活动（ADL）的参与者进行测量而建立的。目标是将他们的活动分类为前面提到的六个类别之一。
 
 ## 数据集描述
 
@@ -1923,7 +1923,7 @@ biases = {
 pred = LSTM_RNN(x, weights, biases)
 ```
 
-此外，我们还需要计算`cost` op，正则化，优化器和评估。我们使用 L2 损失进行正则化，这可以防止这种过度杀伤神经网络过度适应训练中的问题：
+此外，我们还需要计算`cost`操作，正则化，优化器和评估。我们使用 L2 损失进行正则化，这可以防止这种过度杀伤神经网络过度适应训练中的问题：
 
 ```py
 l2 = lambda_loss_amount * sum(tf.nn.l2_loss(tf_var) for tf_var in tf.trainable_variables())