2021-01-16 18:25:01

new/dl-pt-workshop/2.md

@@ -192,7 +192,7 @@ Rosenblatt 还介绍了权重的概念（`w`1，`w`2，…，`w`n），这些数
 
 同样，`n`是指样本数。 ![2](img/B15778_02_Formula4.png)和![3](img/B15778_02_Formula5.png)分别是基本事实和预测值。
 
-### 向后传播
+### 反向传播
 
 训练过程的最后一步包括在网络架构中从右向左移动以计算损耗函数相对于每一层的权重和偏差的偏导数（也称为梯度），以便更新这些 参数（权重和偏差），以便在下一个迭代步骤中，损失函数较低。
 

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

@@ -30,7 +30,7 @@
 
 ![](img/29d7adbd-0103-4c43-b5b0-c2a65a121d48.png)
 
-整体架构看起来不错； 但是，这有一个问题。 如果通过在内存矩阵中指定行索引和列索引来访问内存位置，则无法获取该索引的梯度。 此操作不可向后传播，并且会使用标准的向后传播和基于梯度下降的优化技术来限制 NMT 的训练。 为了解决此问题，NTM 的控制器使用*模糊*读写操作与内存进行交互，这些操作与内存的所有元素进行不同程度的交互。 更准确地说，控制器以差分方式在所有存储位置上生成权重，这有助于使用基于标准梯度的优化方法从头到尾训练网络。
+整体架构看起来不错； 但是，这有一个问题。 如果通过在内存矩阵中指定行索引和列索引来访问内存位置，则无法获取该索引的梯度。 此操作不可反向传播，并且会使用标准的反向传播和基于梯度下降的优化技术来限制 NMT 的训练。 为了解决此问题，NTM 的控制器使用*模糊*读写操作与内存进行交互，这些操作与内存的所有元素进行不同程度的交互。 更准确地说，控制器以差分方式在所有存储位置上生成权重，这有助于使用基于标准梯度的优化方法从头到尾训练网络。
 
 在下一节中，我们将讨论如何产生这些权重以及如何执行读写操作。
 

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

@@ -263,7 +263,7 @@ GPT-2 与 BERT 类似，但在一些细微的方面有所不同。 虽然这两
 
 这是因为 GPT-2 实际上在其工作方式上是自回归的。 这意味着当它生成输出（句子中的第一个单词）时，该输出将递归添加到输入中。 然后，此输入用于预测句子中的下一个单词，并重复进行直到生成完整的句子为止。 您可以在以下示例中看到这一点：
 
-**步骤 1：**
+**步骤 1**：
 
 **输入**：`What color is the sky?`
 
@@ -271,7 +271,7 @@ GPT-2 与 BERT 类似，但在一些细微的方面有所不同。 虽然这两
 
 然后，将预测的输出添加到输入的末尾并重复此步骤：
 
-**步骤 2：**
+**步骤 2**：
 
 **输入**：`What color is the sky? The`
 
@@ -279,13 +279,13 @@ GPT-2 与 BERT 类似，但在一些细微的方面有所不同。 虽然这两
 
 我们重复此过程，直到生成完整的句子：
 
-**步骤 3：**
+**步骤 3**：
 
 **输入**：`What color is the sky? The sky`
 
 **输出**：`is`
 
-**步骤 4：**
+**步骤 4**：
 
 **输入**：`What color is the sky? The sky is`
 

new/pt-ai-fund/3.md

@@ -769,7 +769,7 @@ output = model(data)
 loss = criterion(output, target)
 ```
 
-11.然后，我们向后传播：
+11.然后，我们反向传播：
 
 ```py
 loss.backward()

new/pt-dl-handson/1.md

@@ -416,7 +416,7 @@ tensor([[6.],
 
 变量`x`和`y`为 3 x 2 张量，Python 乘法运算符执行逐元素乘法并给出相同形状的张量。 这个张量和形状为 2 x 1 的`z`张量正在通过 Python 的矩阵乘法运算符，并吐出 3 x 1 矩阵。
 
-如上例所示，张量-张量操作有多个选项，例如普通的 Python 运算符，就地 PyTorch 函数和就地 PyTorch 函数。
+如上例所示，张量-张量操作有多个选项，例如普通的 Python 运算符，原地 PyTorch 函数和原地 PyTorch 函数。
 
 ```py
  >>> z = x.add(y) 
@@ -448,7 +448,7 @@ tensor([[0.5594, 0.8875, 0.9234, 1.1294],
 
 #### 注意
 
-就地运算符遵循尾部下划线的约定，例如`add_`和`sub_`。
+原地运算符遵循尾部下划线的约定，例如`add_`和`sub_`。
 
 可以使用函数`matmul`完成矩阵乘法，而出于相同目的，还有其他函数，例如`mm`和 Python 的`@`。 切片，索引和连接是在对网络进行编码时最终要完成的下一个最重要的任务。 PyTorch 使您能够使用基本的 Pythonic 或 NumPy 语法来完成所有这些操作。
 

new/pt-dl-handson/2.md

@@ -525,7 +525,7 @@ tensor([[1]], dtype=torch.uint8)
 
 ### 损失功能
 
-现在我们有了`FizBuzNet`返回的预测，我们需要找出模型预测的水平，然后向后传播该错误。 我们调用损失函数来查找错误。 社区中普遍存在不同的损失函数。 PyTorch 带有`nn`模块中内置的所有流行损失函数。 损失函数接受对数和实际值，并在其上应用损失功能以查找损失得分。 此过程给出了错误率，该错误率代表了模型预测的好坏。 在新手模型中，我们使用了基本的 MSE 损失，已在`nn`模块中将其定义为`MSELoss()`。
+现在我们有了`FizBuzNet`返回的预测，我们需要找出模型预测的水平，然后反向传播该错误。 我们调用损失函数来查找错误。 社区中普遍存在不同的损失函数。 PyTorch 带有`nn`模块中内置的所有流行损失函数。 损失函数接受对数和实际值，并在其上应用损失功能以查找损失得分。 此过程给出了错误率，该错误率代表了模型预测的好坏。 在新手模型中，我们使用了基本的 MSE 损失，已在`nn`模块中将其定义为`MSELoss()`。
 
 ```py
 loss = nn.MSELoss()

new/pt-dl-handson/4.md

@@ -382,7 +382,7 @@ class ConvBlock(nn.Module):
 
 LinkNet 中的所有卷积都紧随其后的是批量规范化和 ReLU 层，但是有一些例外，没有 ReLU 层。 这就是`ConvBlock`的目标。 如前所述，`ConvBlock`是`torch.nn.Module`的子类，可以根据正向传递中发生的任何事情进行反向传播。 `__init__`接受输入和输出尺寸，内核大小，步幅值，填充宽度，表示是否需要偏置的布尔值和表示是否需要激活（ReLU）的布尔值。
 
-我们使用`torch.nn.Conv2d`，`torch.nn.BatchNorm2d`和`torch.nn.ReLu`来配置`ConvBlock`。 PyTorch 的 Conv2D 接受`ConvBlock`的`__init__`的所有参数，但表示类似激活要求的布尔值除外。 除此之外，Conv2D 还接受另外两个用于 dilation 和 group 的可选参数。 `torch.nn`的 ReLU 函数仅接受一个称为`inplace`的可选参数，默认为`False`。 如果`inplace`为`True`，则 ReLU 将应用于就地数据，而不是创建另一个存储位置。 在许多情况下，这可能会稍微节省内存，但会导致问题，因为我们正在破坏输入。 经验法则是：除非您迫切需要内存优化，否则请远离它。
+我们使用`torch.nn.Conv2d`，`torch.nn.BatchNorm2d`和`torch.nn.ReLu`来配置`ConvBlock`。 PyTorch 的 Conv2D 接受`ConvBlock`的`__init__`的所有参数，但表示类似激活要求的布尔值除外。 除此之外，Conv2D 还接受另外两个用于 dilation 和 group 的可选参数。 `torch.nn`的 ReLU 函数仅接受一个称为`inplace`的可选参数，默认为`False`。 如果`inplace`为`True`，则 ReLU 将应用于原地数据，而不是创建另一个存储位置。 在许多情况下，这可能会稍微节省内存，但会导致问题，因为我们正在破坏输入。 经验法则是：除非您迫切需要内存优化，否则请远离它。
 
 批量规范化用于规范每个批量中的数据，而不是一开始只进行一次。 在开始时，标准化对于获得相等比例的输入至关重要，这反过来又可以提高精度。 但是，随着数据流经网络，非线性和权重和偏差的增加可能导致内部数据规模不同。
 

new/pt-dl-handson/5.md

@@ -523,7 +523,7 @@ class Reduce(nn.Module):
 
 #### 追踪器
 
-在循环中每次 SPINN 的`forward`调用中都会调用`Tracker`的`forward`方法。 在归约运算开始之前，我们需要将上下文向量传递到`Reduce`网络，因此，我们需要遍历`transition`向量并创建缓冲区，堆栈和上下文向量，然后才能执行 SPINN 的`forward()`功能。 由于 PyTorch 变量会跟踪历史事件，因此将跟踪所有这些循环操作并可以向后传播：
+在循环中每次 SPINN 的`forward`调用中都会调用`Tracker`的`forward`方法。 在归约运算开始之前，我们需要将上下文向量传递到`Reduce`网络，因此，我们需要遍历`transition`向量并创建缓冲区，堆栈和上下文向量，然后才能执行 SPINN 的`forward()`功能。 由于 PyTorch 变量会跟踪历史事件，因此将跟踪所有这些循环操作并可以反向传播：
 
 ```py
 class Tracker(nn.Module):

new/pt-dl-handson/6.md

@@ -142,7 +142,7 @@ class MaskedConv2d(nn.Conv2d):
 self.mask = self.weight.data.clone()
 ```
 
-但这绝不会成为`state_dict`的一部分，也永远不会保存到磁盘。 使用`register_buffer`，我们可以确保我们创建的新张量将成为`state_dict`的一部分。 然后使用就地`fill_`操作将掩码张量填充为 1s，然后向其添加 0 以得到类似于“图 6.6”的张量，尽管该图仅显示了二维张量， 实际重量张量是三维的。 `forward`功能仅用于通过乘以遮罩张量来遮罩重量张量。 乘法将保留与掩码具有 1 的索引对应的所有值，同时删除与掩码具有 0 的索引对应的所有值。然后，对父级`Conv2d`层的常规调用使用权重张量，并执行两个操作 维卷积。
+但这绝不会成为`state_dict`的一部分，也永远不会保存到磁盘。 使用`register_buffer`，我们可以确保我们创建的新张量将成为`state_dict`的一部分。 然后使用原地`fill_`操作将掩码张量填充为 1s，然后向其添加 0 以得到类似于“图 6.6”的张量，尽管该图仅显示了二维张量， 实际重量张量是三维的。 `forward`功能仅用于通过乘以遮罩张量来遮罩重量张量。 乘法将保留与掩码具有 1 的索引对应的所有值，同时删除与掩码具有 0 的索引对应的所有值。然后，对父级`Conv2d`层的常规调用使用权重张量，并执行两个操作 维卷积。
 
 网络的最后一层是 softmax 层，该层可预测像素的 256 个可能值中的值，从而离散化网络的输出生成，而先前使用的最先进的自回归模型将在网络上继续生成值 最后一层。
 
@@ -171,7 +171,7 @@ DeepMind 在 PixelCNN 的一篇迭代论文中成功地使用了门控 PixelCNN
 
 DeepMind 在另一篇针对其自回归生成网络的迭代论文[2]中引入了 WaveNet，其中包括 PixelCNN。 实际上，WaveNet 架构是基于 PixelCNN 的构建的，与 PixelRNN 相比，WaveNet 架构使网络能够以相对更快的方式生成输出。 借助 WaveNet，我们在书中首次探索了针对音频信号的神经网络实现。 我们对音频信号使用一维卷积，这与 PixelCNN 的二维卷积不同，对于初学者而言，这是相当复杂的。
 
-WaveNet 取代了对音频信号使用傅里叶变换的传统方法。 它通过使神经网络找出要执行的转换来做到这一点。 因此，转换可以向后传播，原始音频数据可以使用一些技术来处理，例如膨胀卷积，8 位量化等。 但是人们一直在研究将 WaveNet 方法与传统方法相结合，尽管该方法将损失函数转换为多元回归，而不是 WaveNet 使用的分类。
+WaveNet 取代了对音频信号使用傅里叶变换的传统方法。 它通过使神经网络找出要执行的转换来做到这一点。 因此，转换可以反向传播，原始音频数据可以使用一些技术来处理，例如膨胀卷积，8 位量化等。 但是人们一直在研究将 WaveNet 方法与传统方法相结合，尽管该方法将损失函数转换为多元回归，而不是 WaveNet 使用的分类。
 
 PyTorch 向后公开了此类传统方法的 API。 以下是对傅立叶变换的结果进行快速傅立叶变换和傅立叶逆变换以获取实际输入的示例。 两种操作都在二维张量上，最后一个维为 2，表示复数的实部和虚部。
 

new/pt-tut-17/03.md

@@ -36,7 +36,7 @@ x_np = torch.from_numpy(np_array)
 
 ```
 
-**来自另一个张量：**
+**来自另一个张量**：
 
 除非明确覆盖，否则新张量将保留参数张量的属性（形状，数据类型）。
 
@@ -62,7 +62,7 @@ Random Tensor:
 
 ```
 
-**具有随机或恒定值：**
+**具有随机或恒定值**：
 
 `shape`是张量尺寸的元组。 在下面的函数中，它确定输出张量的维数。
 
@@ -136,7 +136,7 @@ if torch.cuda.is_available():
 
 尝试从列表中进行一些操作。 如果您熟悉 NumPy API，则可以轻松使用 Tensor API。
 
-**标准的类似 numpy 的索引和切片：**
+**类似 Numpy 的标准索引和切片**：
 
 ```py
 tensor = torch.ones(4, 4)
@@ -173,7 +173,7 @@ tensor([[1., 0., 1., 1., 1., 0., 1., 1., 1., 0., 1., 1.],
 
 ```
 
-**乘法张量**
+**相乘张量**
 
 ```py
 # This computes the element-wise product
@@ -226,7 +226,7 @@ tensor @ tensor.T
 
 ```
 
-**就地操作**后缀为`_`的操作就位。 例如：`x.copy_(y)`，`x.t_()`将更改为`x`。
+**原地操作**后缀为`_`的操作就位。 例如：`x.copy_(y)`，`x.t_()`将更改为`x`。
 
 ```py
 print(tensor, "\n")
@@ -252,7 +252,7 @@ tensor([[6., 5., 6., 6.],
 
 注意
 
-就地操作可以节省一些内存，但是在计算导数时可能会因为立即丢失历史记录而出现问题。 因此，不鼓励使用它们。
+原地操作可以节省一些内存，但是在计算导数时可能会因为立即丢失历史记录而出现问题。 因此，不鼓励使用它们。
 
 * * *
 
@@ -320,7 +320,7 @@ n: [2\. 2\. 2\. 2\. 2.]
 
 ```
 
-**脚本的总运行时间：**（0 分钟 0.045 秒）
+**脚本的总运行时间**：（0 分钟 0.045 秒）
 
 [`Download Python source code: tensor_tutorial.py`](../../_downloads/092fba3c36cb2ab226bfdaa78248b310/tensor_tutorial.py)
 

new/pt-tut-17/04.md

@@ -12,7 +12,7 @@
 
 **正向传播**：在正向传播中，NN 对正确的输出进行最佳猜测。 它通过其每个功能运行输入数据以进行猜测。
 
-**向后传播**：在反向传播中，NN 根据其猜测中的错误调整其参数。 它通过从输出向后遍历，收集有关函数参数（*梯度*）的误差导数并使用梯度下降来优化参数来实现。 有关 backprop 的更详细的演练，请查看 3Blue1Brown 的[视频。](https://www.youtube.com/watch?v=tIeHLnjs5U8)
+**反向传播**：在反向传播中，NN 根据其猜测中的错误调整其参数。 它通过从输出向后遍历，收集有关函数参数（*梯度*）的误差导数并使用梯度下降来优化参数来实现。 有关 backprop 的更详细的演练，请查看 3Blue1Brown 的[视频](https://www.youtube.com/watch?v=tIeHLnjs5U8)。
 
 ## 在 PyTorch 中的用法
 
@@ -33,7 +33,7 @@ prediction = model(data) # forward pass
 
 ```
 
-我们使用模型的预测和相应的标签来计算误差（`loss`）。 下一步是通过网络反向传播此错误。 当我们在误差张量上调用`.backward()`时，开始向后传播。 然后，Autograd 会为每个模型参数计算梯度并将其存储在参数的`.grad`属性中。
+我们使用模型的预测和相应的标签来计算误差（`loss`）。 下一步是通过网络反向传播此错误。 当我们在误差张量上调用`.backward()`时，开始反向传播。 然后，Autograd 会为每个模型参数计算梯度并将其存储在参数的`.grad`属性中。
 
 ```py
 loss = (prediction - labels).sum()
@@ -154,7 +154,7 @@ tensor([True, True])
 
 注意
 
-**DAG 在 PyTorch 中是动态的**要注意的重要一点是，图形是从头开始重新创建的； 在每个`.backward()`调用之后，autograd 开始填充新图。 这正是允许您在模型中使用控制流语句的原因。 您可以根据需要在每次迭代中更改形状，大小和操作。
+**DAG 在 PyTorch 中是动态的**。要注意的重要一点是，图形是从头开始重新创建的； 在每个`.backward()`调用之后，autograd 开始填充新图。 这正是允许您在模型中使用控制流语句的原因。 您可以根据需要在每次迭代中更改形状，大小和操作。
 
 ### 从 DAG 中排除] [docs / modern-java-zh /
 
@@ -222,10 +222,10 @@ optimizer = optim.SGD(model.fc.parameters(), lr=1e-2, momentum=0.9)
 
 ## 进一步阅读：
 
-*   [就地操作&多线程 Autograd](https://pytorch.org/docs/stable/notes/autograd.html)
+*   [原地操作&多线程 Autograd](https://pytorch.org/docs/stable/notes/autograd.html)
 *   [反向模式 autodiff](https://colab.research.google.com/drive/1VpeE6UvEPRz9HmsHh1KS0XxXjYu533EC) 的示例实现
 
-**脚本的总运行时间：**（0 分钟 5.184 秒）
+**脚本的总运行时间**：（0 分钟 5.184 秒）
 
 [`Download Python source code: autograd_tutorial.py`](../../_downloads/00a1ac60985c7481f4250bafeae15ffa/autograd_tutorial.py)
 

new/pt-tut-17/05.md

@@ -135,19 +135,19 @@ out.backward(torch.randn(1, 10))
 
 在继续之前，让我们回顾一下到目前为止所看到的所有课程。
 
-**Recap:**
+**回顾**：
 
-*   `torch.Tensor`-一个*多维数组*，支持诸如`backward()`的自动分级操作。 同样，*保持梯度*w.r.t。 张量。
+*   `torch.Tensor`-一个*多维数组*，支持诸如`backward()`的自动分级操作。 同样，保持相对于张量的梯度。
 *   `nn.Module`-神经网络模块。 *封装参数*的便捷方法，并带有将其移动到 GPU，导出，加载等的帮助器。
-*   `nn.Parameter`-一种张量，即*，当将其分配为* `Module`的属性时自动注册为参数。
-*   `autograd.Function`-实现自动分级操作的*正向和反向定义。 每个`Tensor`操作都会创建至少一个`Function`节点，该节点连接到创建`Tensor`的函数，并且*对其历史记录*进行编码。*
+*   `nn.Parameter`-一种张量，即将其分配时，`Module`的属性时自动注册为参数。
+*   `autograd.Function`-实现自动微分操作的正向和反向定义。 每个`Tensor`操作都会创建至少一个`Function`节点，该节点连接到创建`Tensor`的函数，并且对其历史记录进行编码。
 
-**At this point, we covered:**
+**目前为止，我们涵盖了**：
 
 *   定义神经网络
 *   处理输入并向后调用
 
-**Still Left:**
+**仍然剩下**：
 
 *   计算损失
 *   更新网络的权重
@@ -210,7 +210,7 @@ print(loss.grad_fn.next_functions[0][0].next_functions[0][0])  # ReLU
 
 ## 反向传播] [docs / modern-java-zh /
 
-要向后传播错误，我们要做的只是对`loss.backward()`。 不过，您需要清除现有的渐变，否则渐变将累积到现有的渐变中。
+要反向传播错误，我们要做的只是对`loss.backward()`。 不过，您需要清除现有的渐变，否则渐变将累积到现有的渐变中。
 
 现在，我们将其称为`loss.backward()`，然后看一下向后前后 conv1 的偏差梯度。
 
@@ -239,11 +239,11 @@ tensor([ 0.0111, -0.0064,  0.0053, -0.0047,  0.0026, -0.0153])
 
 现在，我们已经看到了如何使用损失函数。
 
-**稍后阅读：**
+**稍后阅读**：
 
 > 神经网络软件包包含各种模块和损失函数，这些模块和损失函数构成了深度神经网络的构建块。 带有文档的完整列表位于此处。
 
-**唯一需要学习的是：**
+**唯一需要学习的是**：
 
 > *   更新网络的权重
 
@@ -283,7 +283,7 @@ optimizer.step()    # Does the update
 
 观察如何使用`optimizer.zero_grad()`将梯度缓冲区手动设置为零。 这是因为如 [Backprop](#backprop) 部分中所述累积了梯度。
 
-**脚本的总运行时间：**（0 分钟 3.778 秒）
+**脚本的总运行时间**：（0 分钟 3.778 秒）
 
 [`Download Python source code: neural_networks_tutorial.py`](../../_downloads/3665741da15f111de82da3227a615699/neural_networks_tutorial.py)
 

new/pt-tut-17/06.md

@@ -412,7 +412,7 @@ inputs, labels = data[0].to(device), data[1].to(device)
 *   [在论坛上讨论 PyTorch](https://discuss.pytorch.org/)
 *   [在 Slack](https://pytorch.slack.com/messages/beginner/) 上与其他用户聊天
 
-**脚本的总运行时间：**（2 分钟 39.965 秒）
+**脚本的总运行时间**：（2 分钟 39.965 秒）
 
 [`Download Python source code: cifar10_tutorial.py`](../../_downloads/ba100c1433c3c42a16709bb6a2ed0f85/cifar10_tutorial.py)
 

new/pt-tut-17/08.md

@@ -50,7 +50,7 @@ print(f'Result: y = {a} + {b} x + {c} x^2 + {d} x^3')
 
 ```
 
-**脚本的总运行时间：**（0 分钟 0.000 秒）
+**脚本的总运行时间**：（0 分钟 0.000 秒）
 
 [`Download Python source code: polynomial_numpy.py`](../../_downloads/6287cd68dd239d4f34ac75d774a66e23/polynomial_numpy.py)
 

new/pt-tut-17/09.md

@@ -55,7 +55,7 @@ print(f'Result: y = {a.item()} + {b.item()} x + {c.item()} x^2 + {d.item()} x^3'
 
 ```
 
-**脚本的总运行时间：**（0 分钟 0.000 秒）
+**脚本的总运行时间**：（0 分钟 0.000 秒）
 
 [`Download Python source code: polynomial_tensor.py`](../../_downloads/38bc029908996abe0c601bcf0f5fd9d8/polynomial_tensor.py)
 

new/pt-tut-17/10.md

@@ -68,7 +68,7 @@ print(f'Result: y = {a.item()} + {b.item()} x + {c.item()} x^2 + {d.item()} x^3'
 
 ```
 
-**脚本的总运行时间：**（0 分钟 0.000 秒）
+**脚本的总运行时间**：（0 分钟 0.000 秒）
 
 [`Download Python source code: polynomial_autograd.py`](../../_downloads/2956e289de4f5fdd59114171805b23d2/polynomial_autograd.py)
 

new/pt-tut-17/11.md

@@ -94,7 +94,7 @@ print(f'Result: y = {a.item()} + {b.item()} * P3({c.item()} + {d.item()} x)')
 
 ```
 
-**脚本的总运行时间：**（0 分钟 0.000 秒）
+**脚本的总运行时间**：（0 分钟 0.000 秒）
 
 [`Download Python source code: polynomial_custom_function.py`](../../_downloads/b7ec15fd7bec1ca3f921104cfb6a54ed/polynomial_custom_function.py)
 

new/pt-tut-17/12.md

@@ -78,7 +78,7 @@ print(f'Result: y = {linear_layer.bias.item()} + {linear_layer.weight[:, 0].item
 
 ```
 
-**脚本的总运行时间：**（0 分钟 0.000 秒）
+**脚本的总运行时间**：（0 分钟 0.000 秒）
 
 [`Download Python source code: polynomial_nn.py`](../../_downloads/b4767df4367deade63dc8a0d3712c1d4/polynomial_nn.py)
 

new/pt-tut-17/13.md

@@ -62,7 +62,7 @@ print(f'Result: y = {linear_layer.bias.item()} + {linear_layer.weight[:, 0].item
 
 ```
 
-**脚本的总运行时间：**（0 分钟 0.000 秒）
+**脚本的总运行时间**：（0 分钟 0.000 秒）
 
 [`Download Python source code: polynomial_optim.py`](../../_downloads/bcfec6f02e0fe747a42dbd1579267469/polynomial_optim.py)
 

new/pt-tut-17/14.md

@@ -66,7 +66,7 @@ print(f'Result: {model.string()}')
 
 ```
 
-**脚本的总运行时间：**（0 分钟 0.000 秒）
+**脚本的总运行时间**：（0 分钟 0.000 秒）
 
 [`Download Python source code: polynomial_module.py`](../../_downloads/916a9c460c899330dbc53216cc775358/polynomial_module.py)
 

new/pt-tut-17/15.md

@@ -73,7 +73,7 @@ print(f'Result: {model.string()}')
 
 ```
 
-**脚本的总运行时间：**（0 分钟 0.000 秒）
+**脚本的总运行时间**：（0 分钟 0.000 秒）
 
 [`Download Python source code: dynamic_net.py`](../../_downloads/3900c903cde097dc0088c3b06d588c0b/dynamic_net.py)
 

new/pt-tut-17/16.md

@@ -102,7 +102,7 @@ tensor(0) tensor(9)
 
 PyTorch 提供了创建随机或零填充张量的方法，我们将使用它们来为简单的线性模型创建权重和偏差。 这些只是常规张量，还有一个非常特殊的附加值：我们告诉 PyTorch 它们需要渐变。 这使 PyTorch 记录了在张量上完成的所有操作，因此它可以在反向传播*时自动计算*的梯度！
 
-对于权重，我们在初始化之后设置`requires_grad` **，因为我们不希望该步骤包含在渐变中。 （请注意，PyTorch 中的尾随`_`表示该操作是就地执行的。）**
+对于权重，我们在初始化之后设置`requires_grad` **，因为我们不希望该步骤包含在渐变中。 （请注意，PyTorch 中的尾随`_`表示该操作是原地执行的。）**
 
 注意
 
@@ -962,7 +962,7 @@ fit(epochs, model, loss_func, opt, train_dl, valid_dl)
 > *   `Dataset` 中更新 `Parameter` 的权重。 具有 `__len__` 和 `__getitem__` 的对象，包括 Pytorch 提供的类，例如 `TensorDataset`
 > *   `DataLoader` ：获取任何 `Dataset` 并创建一个迭代器，该迭代器返回批量数据。
 
-**脚本的总运行时间：**（0 分钟 57.062 秒）
+**脚本的总运行时间**：（0 分钟 57.062 秒）
 
 [`Download Python source code: nn_tutorial.py`](../_downloads/a6246751179fbfb7cad9222ef1c16617/nn_tutorial.py)
 

new/pt-tut-17/20.md

@@ -581,7 +581,7 @@ plt.show()
 
 如果您想了解有关迁移学习的更多信息，请查看我们的[计算机视觉教程的量化迁移学习](https://pytorch.org/tutorials/intermediate/quantized_transfer_learning_tutorial.html)。
 
-**脚本的总运行时间：**（1 分钟 56.157 秒）
+**脚本的总运行时间**：（1 分钟 56.157 秒）
 
 [`Download Python source code: transfer_learning_tutorial.py`](../_downloads/07d5af1ef41e43c07f848afaf5a1c3cc/transfer_learning_tutorial.py)
 

new/pt-tut-17/21.md

@@ -292,7 +292,7 @@ plt.show()
 
 另一个方向是不同领域的对抗性攻击和防御。 对抗性研究不仅限于图像领域，请查看[对语音到文本模型的这种](https://arxiv.org/pdf/1801.01944.pdf)攻击。 但是，也许更多地了解对抗性机器学习的最好方法是动手。 尝试实施与 NIPS 2017 竞赛不同的攻击，并查看它与 FGSM 有何不同。 然后，尝试保护模型免受自己的攻击。
 
-**脚本的总运行时间：**（4 分钟 22.519 秒）
+**脚本的总运行时间**：（4 分钟 22.519 秒）
 
 [`Download Python source code: fgsm_tutorial.py`](../_downloads/c9aee5c8955d797c051f02c07927b0c0/fgsm_tutorial.py)
 

new/pt-tut-17/22.md

@@ -726,7 +726,7 @@ plt.show()
 *   在处查看其他一些不错的 GAN 项目
 *   创建可生成[音乐](https://deepmind.com/blog/wavenet-generative-model-raw-audio/)的 GAN
 
-**脚本的总运行时间：**（29 分钟 17.480 秒）
+**脚本的总运行时间**：（29 分钟 17.480 秒）
 
 [`Download Python source code: dcgan_faces_tutorial.py`](../_downloads/dc0e6f475c6735eb8d233374f8f462eb/dcgan_faces_tutorial.py)
 

new/pt-tut-17/24.md

@@ -490,7 +490,7 @@ Labels: [0, 0, 1, 0, 0, 0, 1, 0]
 
 我们使用示例原始音频信号或波形来说明如何使用`torchaudio`打开音频文件，以及如何对该波形进行预处理，变换和应用功能。 我们还演示了如何使用熟悉的 Kaldi 函数以及如何利用内置数据集构建模型。 鉴于`torchaudio`是基于 PyTorch 构建的，因此这些技术可以在利用 GPU 的同时，用作语音识别等更高级音频应用的构建块。
 
-**脚本的总运行时间：**（0 分钟 18.821 秒）
+**脚本的总运行时间**：（0 分钟 18.821 秒）
 
 [`Download Python source code: audio_preprocessing_tutorial.py`](../_downloads/5ffe15ce830e55b3a9e9c294d04ab41c/audio_preprocessing_tutorial.py)
 

new/pt-tut-17/25.md

@@ -447,7 +447,7 @@ ipd.Audio(waveform.numpy(), rate=sample_rate)
 
 在本教程中，我们使用了 torchaudio 来加载数据集并对信号进行重新采样。 然后，我们定义了经过训练的神经网络，以识别给定命令。 还有其他数据预处理方法，例如找到梅尔频率倒谱系数（MFCC），可以减小数据集的大小。 此变换也可以在[torchaudio]中作为`torchaudio.transforms.MFCC`使用。
 
-**脚本的总运行时间：**（0 分钟 0.000 秒）
+**脚本的总运行时间**：（0 分钟 0.000 秒）
 
 [`Download Python source code: speech_command_recognition_with_torchaudio.py`](../_downloads/4cbc77c0f631ff7a80a046f57b97a075/speech_command_recognition_with_torchaudio.py)
 

new/pt-tut-17/27.md

@@ -320,7 +320,7 @@ print('=' * 89)
 
 ```
 
-**脚本的总运行时间：**（4 分钟 50.218 秒）
+**脚本的总运行时间**：（4 分钟 50.218 秒）
 
 [`Download Python source code: transformer_tutorial.py`](../_downloads/f53285338820248a7c04a947c5110f7b/transformer_tutorial.py)
 

new/pt-tut-17/28.md

@@ -23,7 +23,7 @@ $ python predict.py Schmidhuber
 
 ```
 
-**推荐读物：**
+**推荐读物**：
 
 我假设您至少已经安装了 PyTorch，Python 和 Tensors：
 
@@ -546,7 +546,7 @@ $ python predict.py Hazaki
     *   尝试`nn.LSTM`和`nn.GRU`层
     *   将多个这些 RNN 合并为更高级别的网络
 
-**脚本的总运行时间：**（4 分钟 15.239 秒）
+**脚本的总运行时间**：（4 分钟 15.239 秒）
 
 [`Download Python source code: char_rnn_classification_tutorial.py`](../_downloads/ccb15f8365bdae22a0a019e57216d7c6/char_rnn_classification_tutorial.py)
 

new/pt-tut-17/29.md

@@ -31,7 +31,7 @@ Iun
 
 我们仍在手工制作带有一些线性层的小型 RNN。 最大的区别在于，我们无需输入名称中的所有字母即可预测类别，而是输入类别并一次输出一个字母。 反复预测字符以形成语言（这也可以用单词或其他高阶结构来完成）通常称为“语言模型”。
 
-**推荐读物：**
+**推荐读物**：
 
 我假设您至少已经安装了 PyTorch，Python 和 Tensors：
 
@@ -417,7 +417,7 @@ Iun
     *   尝试 nn.LSTM 和 nn.GRU 层
     *   将多个这些 RNN 合并为更高级别的网络
 
-**脚本的总运行时间：**（8 分钟 27.431 秒）
+**脚本的总运行时间**：（8 分钟 27.431 秒）
 
 [`Download Python source code: char_rnn_generation_tutorial.py`](../_downloads/8167177b6dd8ddf05bb9fe58744ac406/char_rnn_generation_tutorial.py)
 

new/pt-tut-17/30.md

@@ -37,7 +37,7 @@
 
 为了改进此模型，我们将使用[注意机制](https://arxiv.org/abs/1409.0473)，该机制可使解码器学会专注于输入序列的特定范围。
 
-**推荐读物：**
+**推荐读物**：
 
 我假设您至少已经安装了 PyTorch，Python 和 Tensors：
 
@@ -785,7 +785,7 @@ output = he s a talented young writer . <EOS>
     *   仅保存编码器网络
     *   从那里训练新的解码器进行翻译
 
-**脚本的总运行时间：**（30 分钟 37.929 秒）
+**脚本的总运行时间**：（30 分钟 37.929 秒）
 
 [`Download Python source code: seq2seq_translation_tutorial.py`](../_downloads/a96a2daac1918ec72f68233dfe3f2c47/seq2seq_translation_tutorial.py)
 

new/pt-tut-17/31.md

@@ -339,7 +339,7 @@ This is a Sports news
 
 您可以在此处找到本说明[中显示的代码示例。](https://github.com/pytorch/text/tree/master/examples/text_classification)
 
-**脚本的总运行时间：**（1 分 38.483 秒）
+**脚本的总运行时间**：（1 分 38.483 秒）
 
 [`Download Python source code: text_sentiment_ngrams_tutorial.py`](../_downloads/1824f32965271d21829e1739cc434729/text_sentiment_ngrams_tutorial.py)
 

new/pt-tut-17/32.md

@@ -492,7 +492,7 @@ Epoch: 10 | Time: 0m 59s
 *   在上查看使用`torchtext` [的 Ben Trevett 其余教程。](https://github.com/bentrevett/)
 *   敬请关注使用其他`torchtext`功能以及`nn.Transformer`通过下一个单词预测进行语言建模的教程！
 
-**脚本的总运行时间：**（10 分钟 13.398 秒）
+**脚本的总运行时间**：（10 分钟 13.398 秒）
 
 [`Download Python source code: torchtext_translation_tutorial.py`](../_downloads/96d6dc961c7477af88e16ca6c9592240/torchtext_translation_tutorial.py)
 

new/pt-tut-17/34.md

@@ -387,7 +387,7 @@ plt.show()
 
 可以随机选择或根据策略选择动作，从健身环境中获取下一步样本。 我们将结果记录在重播内存中，并在每次迭代时运行优化步骤。 优化会从重播内存中随机抽取一批来进行新策略的训练。 “较旧”的 target_net 也用于优化计算期望的 Q 值； 有时会对其进行更新以使其保持最新状态。
 
-**脚本的总运行时间：**（0 分钟 0.000 秒）
+**脚本的总运行时间**：（0 分钟 0.000 秒）
 
 [`Download Python source code: reinforcement_q_learning.py`](../_downloads/b8954cc7b372cac10a92b8c6183846a3/reinforcement_q_learning.py)
 

new/pt-tut-17/35.md

@@ -400,7 +400,7 @@ class Mario(Mario):
 
 #### 更新模型
 
-当 Mario 从其重播缓冲区中采样输入时，我们计算\（TD_t \）和\（TD_e \）并向后传播该损耗\（Q_ {online} \）以更新其参数\（\ theta_ {online} \）（\ （\ alpha \）是传递给`optimizer`的学习率`lr`）
+当 Mario 从其重播缓冲区中采样输入时，我们计算\（TD_t \）和\（TD_e \）并反向传播该损耗\（Q_ {online} \）以更新其参数\（\ theta_ {online} \）（\ （\ alpha \）是传递给`optimizer`的学习率`lr`）
 
 \[\theta_{online} \leftarrow \theta_{online} + \alpha \nabla(TD_e - TD_t)\]
 
@@ -660,7 +660,7 @@ Episode 0 - Step 40 - Epsilon 0.9999900000487484 - Mean Reward 231.0 - Mean Leng
 
 在本教程中，我们看到了如何使用 PyTorch 来训练玩游戏的 AI。 您可以使用相同的方法训练 AI 在 [OpenAI 体育馆](https://gym.openai.com/)上玩任何游戏。 希望您喜欢本教程，请随时通过[和我们的 github](https://github.com/yuansongFeng/MadMario/) 与我们联系！
 
-**脚本的总运行时间：**（0 分钟 21.485 秒）
+**脚本的总运行时间**：（0 分钟 21.485 秒）
 
 [`Download Python source code: mario_rl_tutorial.py`](../_downloads/5f9fbaa1fe608e9c6ceeeae4c9bea7ed/mario_rl_tutorial.py)
 

new/pt-tut-17/37.md

@@ -310,7 +310,7 @@ resp = requests.post("http://localhost:5000/predict",
 *   在本教程中，我们仅展示了如何构建可以一次返回单个图像预测的服务。 我们可以修改服务以能够一次返回多个图像的预测。 此外，[服务流媒体](https://github.com/ShannonAI/service-streamer)库自动将对服务的请求排队，并将请求采样到微型批量中，这些微型批量可输入模型中。 您可以查看[本教程](https://github.com/ShannonAI/service-streamer/wiki/Vision-Recognition-Service-with-Flask-and-service-streamer)。
 *   最后，我们鼓励您在页面顶部查看链接到的其他 PyTorch 模型部署教程。
 
-**脚本的总运行时间：**（0 分钟 1.232 秒）
+**脚本的总运行时间**：（0 分钟 1.232 秒）
 
 [`Download Python source code: flask_rest_api_tutorial.py`](../_downloads/146c514e84d7e33f2a302bcc3ae793cb/flask_rest_api_tutorial.py)
 

new/pt-tut-17/38.md

@@ -254,7 +254,7 @@ def forward(self,
 
 ```
 
-那么**为什么我们要进行所有这些操作？ 有以下几个原因：**
+那么**为什么我们要进行所有这些操作？ 有以下几个原因**：
 
 1.  TorchScript 代码可以在其自己的解释器中调用，该解释器基本上是受限制的 Python 解释器。 该解释器不获取全局解释器锁定，因此可以在同一实例上同时处理许多请求。
 2.  这种格式允许我们将整个模型保存到磁盘上，然后将其加载到另一个环境中，例如在以 Python 以外的语言编写的服务器中
@@ -471,7 +471,7 @@ def forward(self,
 
 我们已经完成了教程！ 有关更多涉及的演示，[请查看 NeurIPS 演示以使用 TorchScript 转换机器翻译模型](https://colab.research.google.com/drive/1HiICg6jRkBnr5hvK2-VnMi88Vi9pUzEJ)。
 
-**脚本的总运行时间：**（0 分钟 0.269 秒）
+**脚本的总运行时间**：（0 分钟 0.269 秒）
 
 [`Download Python source code: Intro_to_TorchScript_tutorial.py`](../_downloads/bf4ee4ef1ffde8b469d9ed4001a28ee8/Intro_to_TorchScript_tutorial.py)
 

new/pt-tut-17/40.md

@@ -210,7 +210,7 @@ ONNX Runtime 是跨平台引擎，您可以在多个平台上以及在 CPU 和 G
 
 有关 ONNX 运行时[的更多信息，请点击](https://github.com/microsoft/onnxruntime)。
 
-**脚本的总运行时间：**（0 分钟 0.000 秒）
+**脚本的总运行时间**：（0 分钟 0.000 秒）
 
 [`Download Python source code: super_resolution_with_onnxruntime.py`](../_downloads/58ce6e85b9b9e9647d302d6b48feccb0/super_resolution_with_onnxruntime.py)
 

new/pt-tut-17/42.md

@@ -598,7 +598,7 @@ print(output.names)
 
 感谢您的阅读！ 命名张量仍在发展中。 如果您有反馈和/或改进建议，请通过创建[问题](https://github.com/pytorch/pytorch/issues)来通知我们。
 
-**脚本的总运行时间：**（0 分钟 0.094 秒）
+**脚本的总运行时间**：（0 分钟 0.094 秒）
 
 [`Download Python source code: named_tensor_tutorial.py`](../_downloads/1e94d0ce96a0c8097f002bcbe94c35d7/named_tensor_tutorial.py)
 

new/pt-tut-17/43.md

@@ -407,7 +407,7 @@ for (m, attrs) in old_attrs.items():
 
 如果您有反馈和/或改进建议，请通过创建[问题](https://github.com/pytorch/pytorch/issues)来通知我们。
 
-**脚本的总运行时间：**（0 分钟 2.300 秒）
+**脚本的总运行时间**：（0 分钟 2.300 秒）
 
 [`Download Python source code: memory_format_tutorial.py`](../_downloads/6c290a5fc635f734b10bbca97b52d2f1/memory_format_tutorial.py)
 

new/pt-tut-17/46.md

@@ -61,7 +61,7 @@ TorchScript 编译器了解固定数量的类型。 只有这些类型可以用
 
 ```
 
-我们正在将[称为 OpenCV `Mat`类的构造函数](https://docs.opencv.org/trunk/d3/d63/classcv_1_1Mat.html#a922de793eabcec705b3579c5f95a643e)，将张量转换为`Mat`对象。 我们向其传递原始`image`张量的行数和列数，数据类型（在此示例中，我们将其固定为`float32`），最后是指向基础数据的原始指针– `float*`。 `Mat`类的此构造函数的特殊之处在于它不会复制输入数据。 取而代之的是，它将简单地引用此存储器来执行`Mat`上的所有操作。 如果在`image_mat`上执行就地操作，这将反映在原始`image`张量中（反之亦然）。 即使我们实际上将数据存储在 PyTorch 张量中，这也使我们能够使用库的本机矩阵类型调用后续的 OpenCV 例程。 我们重复此过程将`warp` PyTorch 张量转换为`warp_mat` OpenCV 矩阵：
+我们正在将[称为 OpenCV `Mat`类的构造函数](https://docs.opencv.org/trunk/d3/d63/classcv_1_1Mat.html#a922de793eabcec705b3579c5f95a643e)，将张量转换为`Mat`对象。 我们向其传递原始`image`张量的行数和列数，数据类型（在此示例中，我们将其固定为`float32`），最后是指向基础数据的原始指针– `float*`。 `Mat`类的此构造函数的特殊之处在于它不会复制输入数据。 取而代之的是，它将简单地引用此存储器来执行`Mat`上的所有操作。 如果在`image_mat`上执行原地操作，这将反映在原始`image`张量中（反之亦然）。 即使我们实际上将数据存储在 PyTorch 张量中，这也使我们能够使用库的本机矩阵类型调用后续的 OpenCV 例程。 我们重复此过程将`warp` PyTorch 张量转换为`warp_mat` OpenCV 矩阵：
 
 ```py
   cv::Mat warp_mat(/*rows=*/warp.size(0),

new/pt-tut-17/49.md

@@ -84,7 +84,7 @@ MeanBackward0
 
 ```
 
-`.requires_grad_( ... )`就地更改现有张量的`requires_grad`标志。
+`.requires_grad_( ... )`原地更改现有张量的`requires_grad`标志。
 
 ```py
 auto a = torch::randn({2, 2});

new/pt-tut-17/52.md

@@ -276,7 +276,7 @@ Self CPU time total: 225.801ms
 *   [分析基于 RPC 的工作负载](https://pytorch.org/tutorials/recipes/distributed_rpc_profiling.html)
 *   [Profiler API 文档](https://pytorch.org/docs/stable/autograd.html?highlight=profiler#profiler)
 
-**脚本的总运行时间：**（0 分钟 0.000 秒）
+**脚本的总运行时间**：（0 分钟 0.000 秒）
 
 [`Download Python source code: profiler.py`](../_downloads/390e82110dc76e71b26225b3f9020e14/profiler.py)
 

new/pt-tut-17/53.md

@@ -1702,7 +1702,7 @@ Best trial test set accuracy: 0.5537
 
 就是这样了！ 您现在可以调整 PyTorch 模型的参数。
 
-**脚本的总运行时间：**（14 分钟 43.400 秒）
+**脚本的总运行时间**：（14 分钟 43.400 秒）
 
 [`Download Python source code: hyperparameter_tuning_tutorial.py`](../_downloads/95074cd7ce8c3e57a92e7a9c49182e6a/hyperparameter_tuning_tutorial.py)
 

new/pt-tut-17/54.md

@@ -772,7 +772,7 @@ tensor([0., 1., 0., 1., 0., 1., 0., 1., 0., 1.])
 
 ```
 
-**脚本的总运行时间：**（0 分钟 0.135 秒）
+**脚本的总运行时间**：（0 分钟 0.135 秒）
 
 [`Download Python source code: pruning_tutorial.py`](../_downloads/8eb4a30bf66c6a1a0d1faba246c07bb3/pruning_tutorial.py)
 

new/pt-tut-17/55.md

@@ -389,7 +389,7 @@ elapsed time (seconds): 166.3
 
 谢谢阅读！ 与往常一样，我们欢迎您提供反馈，因此，如果有任何问题，请在中创建一个问题[。](https://github.com/pytorch/pytorch/issues)
 
-**脚本的总运行时间：**（7 分钟 3.126 秒）
+**脚本的总运行时间**：（7 分钟 3.126 秒）
 
 [`Download Python source code: dynamic_quantization_tutorial.py`](../_downloads/3fa656e39c210acc81b96b164a3da032/dynamic_quantization_tutorial.py)
 

new/pt-tut-17/57.md

@@ -804,7 +804,7 @@ Elapsed time:   4 ms
 
 谢谢阅读！ 与往常一样，我们欢迎您提供反馈，因此，如果有任何问题，请在中创建一个问题[。](https://github.com/pytorch/pytorch/issues)
 
-**脚本的总运行时间：**（5 分钟 40.226 秒）
+**脚本的总运行时间**：（5 分钟 40.226 秒）
 
 [`Download Python source code: static_quantization_tutorial.py`](../_downloads/bd7ace4f5df8c6f747eadb10a7f737cd/static_quantization_tutorial.py)
 

new/pt-tut-17/61.md

@@ -250,11 +250,11 @@ plt.close(fig)
 
 结果表明，将`split_size`设置为 12 可获得最快的训练速度，从而导致`3.75/2.43-1=54%`加速。 仍有机会进一步加快训练过程。 例如，对`cuda:0`的所有操作都放在其默认流上。 这意味着下一个拆分的计算不能与上一个拆分的复制操作重叠。 但是，由于上一个和下一个分割是不同的张量，因此将一个计算与另一个副本重叠是没有问题的。 实现需要在两个 GPU 上使用多个流，并且不同的子网结构需要不同的流管理策略。 由于没有通用的多流解决方案适用于所有模型并行用例，因此在本教程中将不再讨论。
 
-**注意：**
+**注意**：
 
 这篇文章显示了几个性能指标。 当您在自己的计算机上运行相同的代码时，您可能会看到不同的数字，因为结果取决于底层的硬件和软件。 为了使您的环境获得最佳性能，一种正确的方法是首先生成曲线以找出最佳分割尺寸，然后将该分割尺寸用于管道输入。
 
-**脚本的总运行时间：**（6 分钟 20.515 秒）
+**脚本的总运行时间**：（6 分钟 20.515 秒）
 
 [`Download Python source code: model_parallel_tutorial.py`](../_downloads/d961a67e594a77a630ec636c89f84bb8/model_parallel_tutorial.py)
 

new/rl-tf/01.md

@@ -107,7 +107,7 @@
 
 ![](img/ba07be70-2b01-4112-be20-9689a19ac370.png)
 
-查看下面的 S 型函数的梯度，我们观察到取决于`x`的平滑曲线。 由于梯度曲线是连续的，因此很容易向后传播误差并更新参数![](img/62159668-8474-4e17-be25-39d5adf63489.png)和![](img/aff45916-8e2d-4140-9b75-9ce9f0681b4e.png)：
+查看下面的 S 型函数的梯度，我们观察到取决于`x`的平滑曲线。 由于梯度曲线是连续的，因此很容易反向传播误差并更新参数![](img/62159668-8474-4e17-be25-39d5adf63489.png)和![](img/aff45916-8e2d-4140-9b75-9ce9f0681b4e.png)：
 
 ![](img/d8011c52-5574-4521-a42d-e18893417c8d.png)
 

new/rl-tf/03.md

@@ -185,7 +185,7 @@ MDP 试图通过将网格划分为状态，动作，模型/转换模型和奖励
 
 其中![](img/74b40efa-128c-4241-b58d-ee317862e8d7.png)表示从状态序列获得的报酬的期望值，代理观察其是否遵循![](img/64edc6e8-2ff9-4cf7-89db-494345407621.png)策略。 因此，![](img/04d5cea0-7a4c-44bf-bbae-df26ebdc587a.png)输出具有最高预期奖励的![](img/151114d7-cb43-46c6-84d5-11a15df2050e.png)策略。
 
-同样，我们也可以计算状态为的策略的**效用，也就是说，如果我们处于*的*状态，则给定![](img/97497aa9-7dfa-470c-9a95-40fa91cc8588.png)策略，则， *的*状态的![](img/f7c447e9-5546-4220-9ec5-32ed98ba141b.png)政策，即![](img/9c937080-8ae6-47a7-919b-4778f5046829.png)将是从该状态开始的预期收益：**
+同样，我们也可以计算状态为的策略的**效用，也就是说，如果我们处于*的*状态，则给定![](img/97497aa9-7dfa-470c-9a95-40fa91cc8588.png)策略，则， *的*状态的![](img/f7c447e9-5546-4220-9ec5-32ed98ba141b.png)政策，即![](img/9c937080-8ae6-47a7-919b-4778f5046829.png)将是从该状态开始的预期收益**：
 
 ![](img/c99b8ca1-0cfb-419a-bc57-c9de97773b37.png)
 

new/rl-tf/04.md

@@ -482,7 +482,7 @@ def policy_forward(x):
     return p,h #probability of action 2(that is UP) and hidden layer state that is hidden state
 ```
 
-*   **向后传播**：`policy_backward(arr_hidden_state, gradient_logp, observation_values)`函数采用隐藏状态值，错误`gradient_logp`和观测值来针对不同权重参数计算导数，如以下代码所示：
+*   **反向传播**：`policy_backward(arr_hidden_state, gradient_logp, observation_values)`函数采用隐藏状态值，错误`gradient_logp`和观测值来针对不同权重参数计算导数，如以下代码所示：
 
 ```py
 def policy_backward(arr_hidden_state,gradient_logp,observation_values):