2019-02-22 11:53:55

docs/0.3/SUMMARY.md

@@ -28,7 +28,7 @@
             +   [PyTorch介绍](nlp_pytorch_tutorial.md)
             +   [PyTorch深度学习](nlp_deep_learning_tutorial.md)
             +   [词汇嵌入:编码词汇语义](nlp_word_embeddings_tutorial.md)
-            +   [序列模型和 LSTM 网络（长短记忆网络）](nlp_sequencemodels_tutorial.md)
+            +   [序列模型和 LSTM 网络（长短记忆网络）](nlp_sequence_models_tutorial.md)
             +   [高级教程: 作出动态决策和 Bi-LSTM CRF](nlp_advanced_tutorial.md)
     +   [中级教程](intermediate_tutorials.md)
         +   [用字符级RNN分类名称](char_rnn_classification_tutorial.md)

docs/0.3/autograd.md

@@ -39,7 +39,7 @@ torch.autograd.grad(outputs, inputs, grad_outputs=None, retain_graph=None, creat
 * `inputs (变量序列)`: 需要计算的梯度的输入 (并且不会被累加到 `.grad` 参数中). 
 * `grad_outputs (张量或变量序列)`: 每一个输出的梯度. 所有的张量都会变成变量并且是可变的除非参数 `create_graph` 为 `True`. 没有值可以被指定为标量变量或者不需要变化的值. 如果所有 grad_variabls 都可以接受 None 值,那么这个参数是可选的.
 *   `retain_graph (bool, 可选)`: 如果是 `False`, 用于计算 grad 的图将被释放. 几乎所有情况都设置为``True`` 并不是必须的并且能够高效地运行. 默认与 `create_graph` 参数一样.
-*   `create_graph (bool, 可选)`: 如果是 `True`, 梯度图将会被建立,用来求解高阶导数. 默认为 `False`` , 除非参数 `grad_variables` 包含不只一个变量.
+*   `create_graph (bool, 可选)`: 如果是 `True`, 梯度图将会被建立,用来求解高阶导数. 默认为 `False` , 除非参数 `grad_variables` 包含不只一个变量.
 *   `only_inputs (bool, 可选)`: 如果是 `True`, 叶子节点的导数将会在图中, 但是不会出现在参数 `inputs` 也不会被计算以及累加. 默认为 `True`.
 *   `allow_unused (bool, 可选)`: 如果是 `False`, 指定计算输出时未使用的输入（因此它们的 grad 始终为零）是错误的. 默认为 `False`.
 
@@ -90,21 +90,15 @@ backward(gradient=None, retain_graph=None, create_graph=None, retain_variables=N
 
 该图使用链式规则进行计算. 如果变量是非标量（即其数据具有多个元素）并且需要 改变,该功能另外需要指定“梯度”.它应该是一个包含匹配类型和位置的张量 微分函数的梯度w.r.t. `self` .
 
-> 这个功能在叶子上累积渐变 - 你可能需要调用之前将它们置零.
-> 
-> 参数: * gradient (Tensor, Variable or None): 计算变量的梯度. 如果是张量,则会自动转换
-> 
-> > 到一个变量,这是挥发性的,除非 `create_graph` 为真.没有值可以被指定为标量变量或那些 不要求毕业. 如果一个None值是可以接受的这个参数是可选的.
-> 
-> *   retain_graph (bool, 可选): 如果 “False” ,则用于计算的图形导数将被释放. 请注意,在几
-> 
-> > 乎所有情况下设置这个选项为 True 是不需要的,通常可以解决在一个更有效的方式. 默认值为
+这个功能在叶子上累积梯度 - 你可能需要调用之前将它们置零.
+
+参数: 
 
-     `create_graph`.
+*    `gradient (Tensor, Variable or None)`: 计算变量的梯度. 如果是张量,则会自动转换到一个变量,这是挥发性的,除非 `create_graph` 为真.没有值可以被指定为标量变量或那些 不要求毕业. 如果一个None值是可以接受的这个参数是可选的.
 
-*   `create_graph (bool, 可选)`: 如果“真”,派生图将会被构造,允许计算更高阶的导数.
+*   `retain_graph (bool, 可选)`: 如果 “False” ,则用于计算的图形导数将被释放. 请注意,在几乎所有情况下设置这个选项为 True 是不需要的,通常可以解决在一个更有效的方式. 默认值为`create_graph`.
 
-> 默认为 `False`,除非 `gradient` 是一个volatile变量.
+*   `create_graph (bool, 可选)`: 如果“真”,派生图将会被构造,允许计算更高阶的导数. 默认为 `False`,除非 `gradient` 是一个volatile变量.
 
 ```py
 detach()

docs/0.3/blitz_autograd_tutorial.md

@@ -22,7 +22,7 @@ Variable
 
 还有一个针对自动求导实现来说非常重要的类 - `Function`.
 
-`Variable` 和 `Function` 是相互联系的, 并且它们构建了一个非循环的图, 编码了一个完整的计算历史信息. 每一个 variable（变量）都有一个 `.grad_fn` 属性, 它引用了一个已经创建了 `Variable` 的 `Function` （除了用户创建的 `Variable `` 之外 - 它们的 ``grad_fn is None` ）.
+`Variable` 和 `Function` 是相互联系的, 并且它们构建了一个非循环的图, 编码了一个完整的计算历史信息. 每一个 variable（变量）都有一个 `.grad_fn` 属性, 它引用了一个已经创建了 `Variable` 的 `Function` （除了用户创建的 `Variable` 之外 - 它们的 `grad_fn` 为 `None` ）.
 
 如果你想计算导数, 你可以在 `Variable` 上调用 `.backward()` 方法. 如果 `Variable` 是标量的形式（例如, 它包含一个元素数据）, 你不必指定任何参数给 `backward()`, 但是, 如果它有更多的元素. 你需要去指定一个 `grad_output` 参数, 该参数是一个匹配 shape（形状）的张量.
 

docs/0.3/cuda.md

@@ -43,9 +43,11 @@ torch.cuda.device_count()
 
 返回可用的 GPU 数量.
 
-`torch.cuda.``device_ctx_manager`
+```py
+torch.cuda.device_ctx_manager
+```
 
-alias of `device`
+`device`的别名。
 
 ```py
 class torch.cuda.device_of(obj)

docs/0.3/nn.md

@@ -202,7 +202,7 @@ load_state_dict(state_dict, strict=True)
 参数：
 
 *   `state_dict (dict)` – 一个包含 parameters 和 persistent buffers（持久化缓存的）字典.
-*   `strict (bool)` – 严格的强制 `state_dict` 属性中的 key 与该模块的函数 `:func:`state_dict()` 返回的 keys 相匹配.
+*   `strict (bool)` – 严格的强制 `state_dict` 属性中的 key 与该模块的函数 `state_dict()` 返回的 keys 相匹配.
 
 
 
@@ -556,7 +556,7 @@ class torch.nn.ParameterList(parameters=None)
 
 ParameterList 可以像普通的 Python list 那样被索引, 但是它所包含的参数被正确的注册了, 并且所有的 Module 方法都可见的.
 
-参数：`modules (list, 可选)` – 要被添加的 `Parameter`` 列表
+参数：`modules (list, 可选)` – 要被添加的 `Parameter` 列表
 
 
 示例：
@@ -3570,7 +3570,7 @@ loss(x, class) = class != ignoreIndex ? -weight[class] * x[class] : 0
 参数：
 
 *   `weight (Tensor, 可选)` – 自定义的每个类别的权重. 必须是一个长度为 `C` 的 Tensor
-*   `size_average (bool, 可选)` – 默认情况下, loss 会在每个 mini-batch（小批量） 上取平均值. 如果字段 size_average 被设置为 `False`, loss` 将会在每个 mini-batch（小批量） 上累加, 而不会取平均值. 当 reduce 的值为 `False` 时该字段会被忽略. 默认值: `True`
+*   `size_average (bool, 可选)` – 默认情况下, loss 会在每个 mini-batch（小批量） 上取平均值. 如果字段 size_average 被设置为 `False`, loss 将会在每个 mini-batch（小批量） 上累加, 而不会取平均值. 当 reduce 的值为 `False` 时该字段会被忽略. 默认值: `True`
 *   `ignore_index (int, 可选)` – 设置一个目标值, 该目标值会被忽略, 从而不会影响到 输入的梯度. 当 size_average 为 `True` 时, loss 将会在没有被忽略的元素上 取平均值.
 *   `reduce (bool, 可选)` – 默认情况下, loss 会在每个 mini-batch（小批量）上求平均值或者 求和. 当 reduce 是 `False` 时, 损失函数会对每个 batch 元素都返回一个 loss 并忽 略 size_average 字段. 默认值: `True`
 
@@ -3937,10 +3937,10 @@ class torch.nn.MultiMarginLoss(p=1, margin=1, weight=None, size_average=True)
 
 ```py
 loss(x, y) = sum_i(max(0, (margin - x[y] + x[i]))^p) / x.size(0)
-             其中 `i == 0` 至 `x.size(0)` 并且 `i != y`.
-
 ```
 
+其中 `i == 0` 至 `x.size(0)` 并且 `i != y`.
+
 可选择的, 如果您不想所有的类拥有同样的权重的话, 您可以通过在构造函数中传入 `weight` 参数来 解决这个问题, `weight` 是一个1维 Tensor.
 
 传入 `weight` 后, 损失函数变为:
@@ -4364,7 +4364,7 @@ torch.nn.utils.rnn.pack_padded_sequence(input, lengths, batch_first=False)
 
 将填充过的变长序列打包(压紧).
 
-输入的形状可以是 `TxBx*` . T是最长序列长度(等于 `lengths0]`), B 是 batch size, [*代表任意维度(可以是0). 如果 `batch_first=True` , 那么相应的 input size 就是 `BxTx*` .
+输入的形状可以是 `TxBx*` . `T`是最长序列长度(等于 `lengths[0]`), `B`是批量大小, `*`代表任意维度(可以是 0). 如果 `batch_first=True` , 那么相应的输入大小就是 `BxTx*` .
 
 Variable 中保存的序列, 应该按序列长度的长短排序, 长的在前, 短的在后. 即 input[:,0] 代表的是最长的序列, input[:, B-1] 保存的是最短的序列.
 
@@ -4376,7 +4376,7 @@ Variable 中保存的序列, 应该按序列长度的长短排序, 长的在前,
 
 *   `input (Variable)` – 变长序列被填充后的 batch
 *   `lengths (list[int])` – Variable 中每个序列的长度.
-*   `batch_first (bool, 可选)` – 如果是 `True`, input 的形状应该是 BxTx*.
+*   `batch_first (bool, 可选)` – 如果是 `True`, input 的形状应该是 `BxTx*`.
 
 
 返回值：一个 `PackedSequence` 对象.
@@ -4392,14 +4392,14 @@ torch.nn.utils.rnn.pad_packed_sequence(sequence, batch_first=False, padding_valu
 
 这是 `pack_padded_sequence()` 的逆操作.
 
-返回的 Varaible 的值的 size 是 TxBx*, T 是最长序列的长度, B 是 batch_size, 如果 `batch_first=True`, 那么返回值是 BxTx*.
+返回的 Varaible 的值的 size 是 `TxBx*`, T 是最长序列的长度, B 是 batch_size, 如果 `batch_first=True`, 那么返回值是 `BxTx*`.
 
 Batch中的元素将会以它们长度的逆序排列.
 
 参数：
 
 *   `sequence (PackedSequence)` – 将要被填充的 batch
-*   `batch_first (bool, 可选)` – 如果为 `True`` , 返回的数据的格式为 BxTx*.
+*   `batch_first (bool, 可选)` – 如果为 `True` , 返回的数据的格式为 `BxTx*`.
 *   `padding_value (float, 可选)` – 用来填充元素的值
 
 

docs/0.3/notes_autograd.md

@@ -46,7 +46,7 @@ optimizer = optim.SGD(model.fc.parameters(), lr=1e-2, momentum=0.9)
 
 如果您确定不会调用 `.backward()`, 则推荐在纯粹的 inference mode (推断模式) 中使用 Volatile. 它比任何其它的 autograd (自动求导) 设置更高效 - 它将使用绝对最小量的内存来评估模型. `volatile` 也会确定 `require_grad 为 False`.
 
-Volatile 不同于 requires_grad 的标记传播方式. 即使一个操作只有一个单一的 `volatile` 输入, 它的输出也将会是 `volatile` 这样的. Volatility 在整个图中比 `non-requiring gradient (不需要梯度) `` 更容易传播 - 您只需要一个 **单个的** ``volatile` 叶子即可得到一个 `volatile` 输出, 相对的, 您需要 **所有的** 叶子以 `不需要梯度` 的方式, 来产生一个 `不需要梯度` 的输出. 使用 `volatile` 标记, 您不需要更改模型参数的任何参数, 以便将其用于 inference (推断) . 创建一个 `volatile` 输入已经足够了, 这种方式也将确保没有中间状态被保存.
+Volatile 不同于 `requires_grad` 的标记传播方式. 即使一个操作只有一个单一的 `volatile` 输入, 它的输出也将会是 `volatile` 这样的. Volatility 在整个图中比 `non-requiring` 梯度更容易传播 - 您只需要一个 **单个** `volatile` 叶子即可得到一个 `volatile` 输出, 相对的, 您需要 **所有** 叶子以 `non-requiring` 的方式, 来产生一个 `non-requiring` 的输出. 使用 `volatile` 标记, 您不需要更改模型参数的任何参数, 以便将其用于推断. 创建一个 `volatile` 输入已经足够了, 这种方式也将确保没有中间状态被保存.
 
 ```py
 >>> regular_input = Variable(torch.randn(1, 3, 227, 227))

docs/0.3/reinforcement_q_learning.md

@@ -109,7 +109,7 @@ Q-learning 的主要原理是, 假如我们有一个函数, ![Q^*: State \times
 
 ![\pi^*(s) = \arg\!\max_a \ Q^*(s, a)](img/tex-563cfdd06543171f7602210b52cc20bd.gif)
 
-由于我们对整个环境一无所知, 我们不需要知道确定的 !Q^*](img/tex-9a990ac9198b834153ee3ed7ea6ac5ec.gif). 但是, 因为神经网络 是一个泛化的逼近函数, 所以我们可以直接构造一个网络并训练它去模拟 :math:[`Q^*`即可.
+由于我们对整个环境一无所知, 我们不需要知道确定的 ![](img/tex-9a990ac9198b834153ee3ed7ea6ac5ec.gif). 但是, 因为神经网络 是一个泛化的逼近函数, 所以我们可以直接构造一个网络并训练它去模拟`Q^*`即可.
 
 对于我们训练的更新规则来说, 我们只需要让每一个 ![Q](img/tex-f09564c9ca56850d4cd6b3319e541aee.gif) 遵从贝尔曼方程 (Bellman equation) 就可以了.
 

docs/0.3/tensors.md

 # torch.Tensor
 
-> 译者：[[@Sylvester](https://github.com/coboe)、[@那伊抹微笑](https://github.com/wangyangting)
+> 译者：[@Sylvester](https://github.com/coboe)、[@那伊抹微笑](https://github.com/wangyangting)
 > 
 > 校对者：[@Sariel](https://github.com/Cyril-CC)
 
@@ -1450,7 +1450,7 @@ select(dim, index) → Tensor or number
 
 注解：
 
-`select`等效于切片. 例如, ``tensor.select(0, index)`()` 等效于 `tensor[index]` 和 `tensor.select(2, index)` 等效于 `tensor[:,:,index]`.
+`select`等效于切片. 例如, `tensor.select(0, index)` 等效于 `tensor[index]` 和 `tensor.select(2, index)` 等效于 `tensor[:,:,index]`.
 
 ```py
 set_(source=None, storage_offset=0, size=None, stride=None)

docs/0.3/torch.md

@@ -900,7 +900,7 @@ torch.set_rng_state(new_state)
 参数：`new_state (torch.ByteTensor)` – 理想状态
 
 
-`torch.``default_generator` _= <torch._C.Generator object at 0x28bcc10>_
+`torch.default_generator = <torch._C.Generator object at 0x28bcc10>`
 
 ```py
 torch.bernoulli(input, out=None) → Tensor

docs/0.3/transforms.md

@@ -139,7 +139,7 @@ class torchvision.transforms.FiveCrop(size)
 
 该变换返回一个图像元组, 并且数据集返回的输入和目标的数量可能不匹配. 请参阅下面的例子来处理这个问题.
 
-参数：`size (sequence 或 int)` – 期望输出的裁剪尺寸. 如果 size（尺寸）是 `int`` 类型的整数, 而不是像 (h, w) 这样类型的序列, 裁剪出来的图像是 (size, size) 这样的正方形的..
+参数：`size (sequence 或 int)` – 期望输出的裁剪尺寸. 如果 `size` 是 `int` 类型的整数, 而不是像 `(h, w)` 这样类型的序列, 裁剪出来的图像是 `(size, size)` 这样的正方形的..
 
 
 Example