2021-01-19 14:20:45

new/pt-tut-17/04.md

@@ -73,7 +73,7 @@ b = torch.tensor([6., 4.], requires_grad=True)
 
 我们从`a`和`b`创建另一个张量`Q`。
 
-\[Q = 3a^3 - b^2\]
+![](img/tex4-1.gif)
 
 ```py
 Q = 3`a`3 - b**2
@@ -82,13 +82,15 @@ Q = 3`a`3 - b**2
 
 假设`a`和`b`是神经网络的参数，`Q`是错误。 在 NN 训练中，我们想要相对于参数的误差，即
 
-\[\frac{\partial Q}{\partial a} = 9a^2\] \[\frac{\partial Q}{\partial b} = -2b\]
+![](img/tex4-2.gif)
+
+![](img/tex4-3.gif)
 
 当我们在`Q`上调用`.backward()`时，Autograd 将计算这些梯度并将其存储在各个张量的`.grad`属性中。
 
 我们需要在`Q.backward()`中显式传递`gradient`参数，因为它是向量。 `gradient`是与`Q`形状相同的张量，它表示`Q`相对于本身的梯度，即
 
-\[\frac{dQ}{dQ} = 1\]
+![](img/tex4-4.gif)
 
 同样，我们也可以将`Q`聚合为一个标量，然后隐式地向后调用，例如`Q.sum().backward()`。
 
@@ -119,17 +121,17 @@ tensor([True, True])
 
 从数学上讲，如果您具有向量值函数`y = f(x)`，则`y`相对于`x`的雅可比矩阵`J`：
 
-\[\begin{split}J = \left(\begin{array}{cc} \frac{\partial \bf{y}}{\partial x_{1}} & ... & \frac{\partial \bf{y}}{\partial x_{n}} \end{array}\right) = \left(\begin{array}{ccc} \frac{\partial y_{1}}{\partial x_{1}} & \cdots & \frac{\partial y_{1}}{\partial x_{n}}\\ \vdots & \ddots & \vdots\\ \frac{\partial y_{m}}{\partial x_{1}} & \cdots & \frac{\partial y_{m}}{\partial x_{n}} \end{array}\right)\end{split}\]
+![](img/tex4-5.gif)
 
 一般来说，`torch.autograd`是用于计算向量雅可比积的引擎。 也就是说，给定任何向量`v`，计算乘积`J^T · v`
 
 如果`v`恰好是标量函数的梯度
 
-\[l = g\left(\vec{y}\right) = \left(\begin{array}{ccc}\frac{\partial l}{\partial y_{1}} & \cdots & \frac{\partial l}{\partial y_{m}}\end{array}\right)^{T}\]
+![](img/tex4-6.gif)
 
 然后根据链式规则，向量-雅可比积将是`l`相对于`x`的梯度：
 
-\[\begin{split}J^{T}\cdot \vec{v}=\left(\begin{array}{ccc} \frac{\partial y_{1}}{\partial x_{1}} & \cdots & \frac{\partial y_{m}}{\partial x_{1}}\\ \vdots & \ddots & \vdots\\ \frac{\partial y_{1}}{\partial x_{n}} & \cdots & \frac{\partial y_{m}}{\partial x_{n}} \end{array}\right)\left(\begin{array}{c} \frac{\partial l}{\partial y_{1}}\\ \vdots\\ \frac{\partial l}{\partial y_{m}} \end{array}\right)=\left(\begin{array}{c} \frac{\partial l}{\partial x_{1}}\\ \vdots\\ \frac{\partial l}{\partial x_{n}} \end{array}\right)\end{split}\]
+![](img/tex4-7.gif)
 
 上面的示例中使用的是 vector-Jacobian 乘积的这一特征。 `external_grad`表示`v`。
 

new/pt-tut-17/21.md

@@ -124,7 +124,7 @@ CUDA Available:  True
 
 现在，我们可以通过干扰原始输入来定义创建对抗示例的函数。 `fgsm_attack`函数接受三个输入，`image`是原始的干净图像（`x`），`epsilon`是像素级扰动量`ε`，`data_grad`是输入图像损失的梯度（`ᐁ[x] J(θ, x, y)`）。 该函数然后创建扰动图像为
 
-\[perturbed\_image = image + epsilon*sign(data\_grad) = x + \epsilon * sign(\nabla_{x} J(\mathbf{\theta}, \mathbf{x}, y))\]
+![](img/tex21-1.gif)
 
 最后，为了维持数据的原始范围，将被扰动的图像裁剪到范围`[0,1]`。
 

new/pt-tut-17/22.md

@@ -20,7 +20,7 @@ GAN 是用于教授 DL 模型以捕获训练数据分布的框架，因此我们
 
 因此，`D(G(z))`是发生器`G`的输出是真实图像的概率（标量）。 如 [Goodfellow 的论文](https://papers.nips.cc/paper/5423-generative-adversarial-nets.pdf)中所述，`D`和`G`玩一个 minimax 游戏，其中`D`试图最大化其正确分类实物和假物`log D(x)`，并且`G`尝试最小化`D`预测其输出为假的概率`log(1 - D(G(g(x))))`。 从本文来看，GAN 损失函数为
 
-\[\underset{G}{\text{min}} \underset{D}{\text{max}}V(D,G) = \mathbb{E}_{x\sim p_{data}(x)}\big[logD(x)\big] + \mathbb{E}_{z\sim p_{z}(z)}\big[log(1-D(G(z)))\big]\]
+![](img/tex22-1.gif)
 
 从理论上讲，此极小极大游戏的解决方案是`p_g = p_data`，判别器会随机猜测输入是真实的还是假的。 但是，GAN 的收敛理论仍在积极研究中，实际上，模型并不总是能达到这一目的。
 
@@ -355,7 +355,7 @@ Discriminator(
 
 使用`D`和`G`设置，我们可以指定它们如何通过损失函数和优化器学习。 我们将使用在 PyTorch 中定义的二进制交叉熵损失（ [BCELoss](https://pytorch.org/docs/stable/nn.html#torch.nn.BCELoss) ）函数：
 
-\[\ell(x, y) = L = \{l_1,\dots,l_N\}^\top, \quad l_n = - \left[ y_n \cdot \log x_n + (1 - y_n) \cdot \log (1 - x_n) \right]\]
+![](img/tex22-2.gif)
 
 请注意，此函数如何提供目标函数中两个对数分量的计算（即`log D(x)`和`log(1 - D(G(z)))`）。 我们可以指定`y`输入使用 BCE 方程的哪一部分。 这是在即将到来的训练循环中完成的，但重要的是要了解我们如何仅通过更改`y`（即 GT 标签）即可选择希望计算的分量。
 

new/pt-tut-17/27.md

@@ -80,7 +80,7 @@ class PositionalEncoding(nn.Module):
 
 本教程使用`torchtext`生成 Wikitext-2 数据集。 vocab 对象是基于训练数据集构建的，用于将标记数字化为张量。 从顺序数据开始，`batchify()`函数将数据集排列为列，以修剪掉数据分成大小为`batch_size`的批量后剩余的所有令牌。 例如，以字母为序列（总长度为 26）并且批大小为 4，我们将字母分为 4 个长度为 6 的序列：
 
-\[\begin{split}\begin{bmatrix} \text{A} & \text{B} & \text{C} & \ldots & \text{X} & \text{Y} & \text{Z} \end{bmatrix} \Rightarrow \begin{bmatrix} \begin{bmatrix}\text{A} \\ \text{B} \\ \text{C} \\ \text{D} \\ \text{E} \\ \text{F}\end{bmatrix} & \begin{bmatrix}\text{G} \\ \text{H} \\ \text{I} \\ \text{J} \\ \text{K} \\ \text{L}\end{bmatrix} & \begin{bmatrix}\text{M} \\ \text{N} \\ \text{O} \\ \text{P} \\ \text{Q} \\ \text{R}\end{bmatrix} & \begin{bmatrix}\text{S} \\ \text{T} \\ \text{U} \\ \text{V} \\ \text{W} \\ \text{X}\end{bmatrix} \end{bmatrix}\end{split}\]
+![](img/tex27-1.gif)
 
 这些列被模型视为独立的，这意味着无法了解`G`和`F`的依赖性，但可以进行更有效的批量。
 

new/pt-tut-17/34.md

@@ -105,21 +105,21 @@ class ReplayMemory(object):
 
 Q 学习的主要思想是，如果我们有一个函数`Q*：State x Action => R`，这可以告诉我们，如果我们取一个 在给定状态下采取行动，那么我们就可以轻松地制定出使我们的回报最大化的策略：
 
-\[\pi^*(s) = \arg\!\max_a \ Q^*(s, a)\]
+![](img/tex34-1.gif)
 
 但是，我们对世界一无所知，因此无法访问`Q*`。 但是，由于神经网络是通用函数逼近器，因此我们可以简单地创建一个并将其训练为类似于`Q*`的函数。
 
 对于我们的训练更新规则，我们将使用一个事实，即某些策略的每个`Q`函数都遵循 Bellman 方程：
 
-\[Q^{\pi}(s, a) = r + \gamma Q^{\pi}(s', \pi(s'))\]
+![](img/tex34-2.gif)
 
 等式两侧之间的差异称为时间差异误差`delta`：
 
-\[\delta = Q(s, a) - (r + \gamma \max_a Q(s', a))\]
+![](img/tex34-3.gif)
 
 为了最小化此错误，我们将使用 [Huber 损失](https://en.wikipedia.org/wiki/Huber_loss)。 当误差较小时，Huber 损耗的作用类似于均方误差，而当误差较大时，则表现为平均绝对误差-当`Q`的估计值非常嘈杂时，这使它对异常值的鲁棒性更高。 我们通过从重播内存中采样的一批过渡`B`来计算：
 
-\[\mathcal{L} = \frac{1}{|B|}\sum_{(s, a, s', r) \ \in \ B} \mathcal{L}(\delta)\] \[\begin{split}\text{where} \quad \mathcal{L}(\delta) = \begin{cases} \frac{1}{2}{\delta^2} & \text{for } |\delta| \le 1, \\ |\delta| - \frac{1}{2} & \text{otherwise.} \end{cases}\end{split}\]
+![](img/tex34-4.gif)
 
 ### Q-network
 

new/pt-tut-17/35.md

@@ -365,11 +365,13 @@ class MarioNet(nn.Module):
 
 **TD 估计**-给定状态`s`的预测最佳`Q*`
 
-\[{TD}_e = Q_{online}^*(s,a)\]
+![](img/tex34-5.gif)
 
 **TD 目标**-当前奖励和下一状态`s'`中的估计`Q*`的汇总
 
-\[a' = argmax_{a} Q_{online}(s', a)\] \[{TD}_t = r + \gamma Q_{target}^*(s',a')\]
+![](img/tex34-6.gif)
+
+![](img/tex34-7.gif)
 
 由于我们不知道下一个动作`a'`是什么，因此我们在下一个状态`s'`中使用动作`a'`最大化`Q_online`。
 
@@ -402,11 +404,11 @@ class Mario(Mario):
 
 当 Mario 从其重播缓冲区中采样输入时，我们计算`TD_t`和`TD_e`并反向传播该损耗`Q_online`以更新其参数`θ_online`（\ （\ alpha \）是传递给`optimizer`的学习率`lr`）
 
-\[\theta_{online} \leftarrow \theta_{online} + \alpha \nabla(TD_e - TD_t)\]
+![](img/tex34-8.gif)
 
 `θ_target`不会通过反向传播进行更新。 相反，我们会定期将`θ_online`复制到`θ_target`
 
-\[\theta_{target} \leftarrow \theta_{online}\]
+![](img/tex34-9.gif)
 
 ```py
 class Mario(Mario):

new/pt-tut-17/56.md

@@ -103,7 +103,7 @@ print(torch.__config__.parallel_info())
 
 *   F1 分数的公式为：
 
-\[F1 = 2 * (\text{precision} * \text{recall}) / (\text{precision} + \text{recall})\]
+![](img/tex56-1.gif)
 
 ### 1.4 下载数据集