Merge pull request #1 from apachecn/master

update

zh/dl10.md

@@ -48,7 +48,7 @@ Chloe在这里所做的是她特别关注路径中每个点处张量的维数，
 
 ![](../img/1_B_pXi5zpN2EGnhATYo-ZWg.png)
 
-**问题** ：通常，当我们下采样时，我们会增加滤波器的数量或深度。 当我们从7x7到4x4等进行采样时，为什么我们将数字从512减少到256？ 为什么不降低SSD头的尺寸？ （性能相关？） [[12:58](https://youtu.be/_ercfViGrgY%3Ft%3D12m58s)] 我们有许多外出路径，我们希望每个路径都相同，所以我们不希望每个路径都有不同数量的过滤器，这也就是论文的内容我试图与之相匹配。 拥有这256个 - 这是一个不同的概念，因为我们不仅利用了最后一层，而且利用了之前的层。 如果我们让它们更加一致，生活会更容易。
+**问题** ：通常，当我们下采样时，我们会增加滤波器的数量或深度。 当我们从7x7到4x4等进行采样时，为什么我们将数字从512减少到256？ 为什么不降低SSD头的尺寸？ （表现相关？） [[12:58](https://youtu.be/_ercfViGrgY%3Ft%3D12m58s)] 我们有许多外出路径，我们希望每个路径都相同，所以我们不希望每个路径都有不同数量的过滤器，这也就是论文的内容我试图与之相匹配。 拥有这256个 - 这是一个不同的概念，因为我们不仅利用了最后一层，而且利用了之前的层。 如果我们让它们更加一致，生活会更容易。
 
 * * *
 
@@ -428,7 +428,7 @@ NLP的基本路径是我们必须采用句子并将它们转换为数字，并
 *   我们将设置一大堆 Dropout。
 *   一旦我们有了一个模型数据对象，我们就可以从中获取模型，这样就可以给我们一个学习器。
 *   然后按照惯例，我们可以调用`learner.fit` 。 我们在最后一层做了一个迭代，只是为了那个好。 它的设置方式是最后一层是嵌入词，因为这显然是最错误的，因为很多嵌入权重甚至不存在于词汇中。 因此，我们将训练仅包含嵌入权重的单个时期。
-*   然后我们将开始做完整模型的几个时代。 怎么样？ 在第4课中，我们在14个时期之后损失了4.23。 在这种情况下，我们在1个迭代后有4.12的损失。 因此，通过对wikitext103进行预训练，我们在1个时期之后获得了比在语言模型中获得的最佳损失更好的损失。
+*   然后我们将开始做完整模型的几个迭代。 怎么样？ 在第4课中，我们在14个时期之后损失了4.23。 在这种情况下，我们在1个迭代后有4.12的损失。 因此，通过对wikitext103进行预训练，我们在1个时期之后获得了比在语言模型中获得的最佳损失更好的损失。
 
 **问题** ：wikitext103型号是什么？ 再次是AWD LSTM  [[52:41]( data-href=)] ？ 是的，我们即将深入研究。 我训练它的方式实际上是你在上面看到的相同代码行，但没有在wikitext103上预先训练它。
 
@@ -474,7 +474,7 @@ fastai doc项目的目标是创建文档，让读者说“哇，这是我读过
 
 ![](../img/1_ttM96lLbHQn06byFwmHj0g.png)
 
-这是fastai.model  [[1:03:41]( data-href=)] 中的`fit`函数。 这是最终通过每个时代最终结束的地方，从数据加载器创建迭代器，然后只通过它进行for循环。 因此，任何可以执行循环操作的东西都可以是数据加载器。 具体来说，它需要为小批量返回独立变量和因变量的元组。
+这是fastai.model  [[1:03:41]( data-href=)] 中的`fit`函数。 这是最终通过每个迭代最终结束的地方，从数据加载器创建迭代器，然后只通过它进行for循环。 因此，任何可以执行循环操作的东西都可以是数据加载器。 具体来说，它需要为小批量返回独立变量和因变量的元组。
 
 ![](../img/1_560U29nWI0xNGLsHgnWFNQ.png)
 
@@ -929,7 +929,7 @@ Jeremy：“你还不能写一篇关于这个的论文，因为你必须做类
 
 #### Concat汇集 [[1:51:36]( data-href=)] 
 
-所以你可能已经注意到，我们的分类器的第一层等于嵌入大小* 3。为什么时间3？时代3因为，再次，这似乎是人们以前没有做过的事情，所以一个新的想法“concat pooling”。我们采用激活序列的平均汇集，激活序列的最大汇集以及最终激活集合，并将它们连接在一起。这是我们在第1部分中讨论的内容，但之前似乎没有出现在文献中，所以它现在被称为“concat pooling”，它现在得到了一个等式，但这是整个实现。因此，你可以阅读本文，了解fastai代码如何实现每个部分。
+所以你可能已经注意到，我们的分类器的第一层等于嵌入大小* 3。为什么时间3？迭代3因为，再次，这似乎是人们以前没有做过的事情，所以一个新的想法“concat pooling”。我们采用激活序列的平均汇集，激活序列的最大汇集以及最终激活集合，并将它们连接在一起。这是我们在第1部分中讨论的内容，但之前似乎没有出现在文献中，所以它现在被称为“concat pooling”，它现在得到了一个等式，但这是整个实现。因此，你可以阅读本文，了解fastai代码如何实现每个部分。
 
 ![](../img/1_ilEQlVMIdx3m2WAKzOCjfQ.png)
 

zh/dl11.md

@@ -513,7 +513,7 @@ pytext中没有fasttext Python库，但这是一个方便的技巧 [[35:03](http
  _quels facteurs pourraient influer sur le choix de leur emplacement ?_ __eos__  _what factors influencetheir location ?_ __eos__  _what factors might might influence on the their ?_ _?_ __eos__  _qu' est -ce qui ne peut pas changer ?_ __eos__  _what can not change ?_ __eos__  _what not change change ?_ __eos__  _que faites - vous ?_ __eos__  _what do you do ?_ __eos__  _what do you do ?_ __eos__  _qui réglemente les pylônes d' antennes ?_ __eos__  _who regulates antenna towers ?_ __eos__  _who regulates the doors doors ?_ __eos__  _où sont - ils situés ?_ __eos__  _where are they located ?_ __eos__  _where are the located ?_ __eos__  _quelles sont leurs compétences ?_ __eos__  _what are their qualifications ?_ __eos__  _what are their skills ?_ __eos__  _qui est victime de harcèlement sexuel ?_ __eos__  _who experiences sexual harassment ?_ __eos__  _who is victim sexual sexual ?_ _?_ __eos__  _quelles sont les personnes qui visitent les communautés autochtones ?_ __eos__  _who visits indigenous communities ?_ __eos__  _who are people people aboriginal aboriginal ?_ __eos__  _pourquoi ces trois points en particulier ?_ __eos__  _why these specific three ?_ __eos__  _why are these two different ?_ _?_ __eos__  _pourquoi ou pourquoi pas ?_ __eos__  _why or why not ?_ __eos__  _why or why not _eos__ 
 ```
 
-令人惊讶的是，这种最简单的可能性很大程度上是从零开始写的PyTorch模块上只有五万个句子，有时候能够在验证集上为你提供正确的答案。 有时候正确的答案是措辞略有不同，有时句子真的没有语法上的明智，甚至有太多的问号。 所以我们走在正确的轨道上。 我们认为你会同意即使是最简单的seq-to-seq训练的极少数时代，没有任何预训练，除了使用单词嵌入是惊人的好。 我们稍后会对此进行改进，但是这里的消息甚至是顺序排列的模型，你认为它们比它们可能工作的更简单，即使数据少于你认为你可以学到的数据也可能是非常有效的，在某些情况下这可能就足够了你的需求。
+令人惊讶的是，这种最简单的可能性很大程度上是从零开始写的PyTorch模块上只有五万个句子，有时候能够在验证集上为你提供正确的答案。 有时候正确的答案是措辞略有不同，有时句子真的没有语法上的明智，甚至有太多的问号。 所以我们走在正确的轨道上。 我们认为你会同意即使是最简单的seq-to-seq训练的极少数迭代，没有任何预训练，除了使用单词嵌入是惊人的好。 我们稍后会对此进行改进，但是这里的消息甚至是顺序排列的模型，你认为它们比它们可能工作的更简单，即使数据少于你认为你可以学到的数据也可能是非常有效的，在某些情况下这可能就足够了你的需求。
 
 **问题** ：标准化标点符号会有帮助吗（例如`'` vs. `'` ）？  [[1:13:10](https://youtu.be/tY0n9OT5_nA%3Ft%3D1h13m10s)] 这个特殊情况的答案可能是肯定的 - 卷曲引号和直引号之间的区别实际上是语义上的。 你必须非常小心，因为可能会发现人们使用漂亮的卷曲引号，比如使用更正式的语言，而且他们的写作方式不同。 因此，如果你要进行某些预处理（如标点符号规范化），你一定要检查结果是否有，因为几乎总是那种预处理会使事情变得更糟，即使你确定它不会。
 
@@ -539,7 +539,7 @@ pytext中没有fasttext Python库，但这是一个方便的技巧 [[35:03](http
 
 **问题** ：为什么需要为循环设置范围？  [[1:20:58](https://youtu.be/tY0n9OT5_nA%3Ft%3D1h20m58s)] 因为当我们开始训练时，一切都是随机的，所以`if (dec_inp==1).all(): break`可能永远不会是真的。 后来，它几乎总会最终突破，但基本上我们将永远消失。 重要的是要记住，当你设计一个架构，当你开始时，模型对任何事情一无所知。 所以你想确定它是否会做一些至少它含糊不清的事情。
 
-单方向 [[1:21:46](https://youtu.be/tY0n9OT5_nA%3Ft%3D1h21m46s)] 得到3.58交叉熵损失。 随着双向，我们降到3.51，所以改善了一点。 它不应该真的减慢太多的东西。 双向确实意味着必须进行更多的顺序处理，但这通常是一个很好的胜利。 在谷歌翻译模型中，在8层中，只有第一层是双向的，因为它允许它并行执行更多操作，所以如果你创建真正的深层模型，你可能需要考虑哪些是双向的，否则我们有性能问题。
+单方向 [[1:21:46](https://youtu.be/tY0n9OT5_nA%3Ft%3D1h21m46s)] 得到3.58交叉熵损失。 随着双向，我们降到3.51，所以改善了一点。 它不应该真的减慢太多的东西。 双向确实意味着必须进行更多的顺序处理，但这通常是一个很好的胜利。 在谷歌翻译模型中，在8层中，只有第一层是双向的，因为它允许它并行执行更多操作，所以如果你创建真正的深层模型，你可能需要考虑哪些是双向的，否则我们有表现问题。
 
 ```
  rnn = Seq2SeqRNN_Bidir(fr_vecd, fr_itos, dim_fr_vec, en_vecd,  en_itos, dim_en_vec, nh, enlen_90)  learn = RNN_Learner(md, SingleModel(to_gpu(rnn)), opt_fn=opt_fn)  learn.crit = seq2seq_loss 
@@ -585,7 +585,7 @@ pytext中没有fasttext Python库，但这是一个方便的技巧 [[35:03](http
 
 ![](../img/1_hhksba0Jh8iyWmuC_tPtqg.png)
 
-我们曾经 [[1:27:49](https://youtu.be/tY0n9OT5_nA%3Ft%3D1h27m49s)] 查看了源代码。 我们已经看到它在每个时代中如何`stepper.step` ，并且循环遍历我们批处理中的每个事物并调用`stepper.step` 。 `stepper.step`是负责的事情：
+我们曾经 [[1:27:49](https://youtu.be/tY0n9OT5_nA%3Ft%3D1h27m49s)] 查看了源代码。 我们已经看到它在每个迭代中如何`stepper.step` ，并且循环遍历我们批处理中的每个事物并调用`stepper.step` 。 `stepper.step`是负责的事情：
 
 *   打电话给模型
 *   得到了损失
@@ -636,7 +636,7 @@ learn.fit（lr，1，cycle_len = 12，use_clr =（20,10），stepper = Seq2SeqSt
  [3.490643] 
 ```
 
-而现在我们的损失降至3.49。我们需要确保至少做10个时代，因为在此之前，它是通过使用教师强制作弊。
+而现在我们的损失降至3.49。我们需要确保至少做10个迭代，因为在此之前，它是通过使用教师强制作弊。
 
 #### 技巧＃3注意模型 [[1:31:00](https://youtu.be/tY0n9OT5_nA%3Ft%3D1h31m)] 
 
@@ -1080,7 +1080,7 @@ RNN输出两件事：它在每个时间步之后输出一个状态列表（ `enc
  lr = 1e-2  wd = 1e-7 
 ```
 
-我们正在训练所有需要很长时间的ImageNet。 所以`precompute=True`是你的朋友。 还记得`precompute=True`吗？ 这是我们很久以前学到的东西，它可以缓存最终卷积层的输出并训练完全连接的位。 即使`precompute=True` ，在整个ImageNet上训练一个迭代大约需要3分钟。 所以这大约需要一个小时的训练，但是使用fastai非常酷，我们可以在一个小时左右的时间内在所有ImageNet上训练40个时代的新定制头。
+我们正在训练所有需要很长时间的ImageNet。 所以`precompute=True`是你的朋友。 还记得`precompute=True`吗？ 这是我们很久以前学到的东西，它可以缓存最终卷积层的输出并训练完全连接的位。 即使`precompute=True` ，在整个ImageNet上训练一个迭代大约需要3分钟。 所以这大约需要一个小时的训练，但是使用fastai非常酷，我们可以在一个小时左右的时间内在所有ImageNet上训练40个迭代的新定制头。
 
 ```
  learn.precompute= **True** 

zh/dl12.md

@@ -129,7 +129,7 @@ Leaky ReLU（其中_x_ <0）的梯度变化但是大约0.1或0.01的常数。
 
 ![](../img/1_89Seymgfa5Bdx1_EXBW_lA.png)
 
-在家尝试一下。 尝试运行CIFAR，看看会发生什么。 甚至乘以2或摆弄。 这可以让你的GPU做更多的工作而且非常有趣，因为绝大多数谈论不同架构性能的论文从未实际计算通过它运行批量需要多长时间。 他们说“这个每批需要X次浮点运算”，但他们从来没有像真正的实验主义者那样费心去运行，并且发现它是更快还是更慢。 许多真正着名的体系结构现在变得像糖蜜一样缓慢并且需要大量的内存并且完全没用，因为研究人员从来没有真正费心去看它们是否很快并且实际上看它们是否适合RAM正常批量大小。 因此，广泛的ResNet纸张不同寻常之处在于它实际上需要花费多长时间才能获得同样的洞察力的YOLO v3纸张。 他们可能错过了Wide ResNet论文，因为YOLO v3论文得出了许多相同的结论，但Jeremy不确定他们选择了Wide ResNet论文，所以他们可能不知道所有这些工作都已完成。 很高兴看到人们真正计时并注意到实际上有意义的东西。
+在家尝试一下。 尝试运行CIFAR，看看会发生什么。 甚至乘以2或摆弄。 这可以让你的GPU做更多的工作而且非常有趣，因为绝大多数谈论不同架构表现的论文从未实际计算通过它运行批量需要多长时间。 他们说“这个每批需要X次浮点运算”，但他们从来没有像真正的实验主义者那样费心去运行，并且发现它是更快还是更慢。 许多真正着名的体系结构现在变得像糖蜜一样缓慢并且需要大量的内存并且完全没用，因为研究人员从来没有真正费心去看它们是否很快并且实际上看它们是否适合RAM正常批量大小。 因此，广泛的ResNet纸张不同寻常之处在于它实际上需要花费多长时间才能获得同样的洞察力的YOLO v3纸张。 他们可能错过了Wide ResNet论文，因为YOLO v3论文得出了许多相同的结论，但Jeremy不确定他们选择了Wide ResNet论文，所以他们可能不知道所有这些工作都已完成。 很高兴看到人们真正计时并注意到实际上有意义的东西。
 
 **问题** ：你对SELU（缩放指数线性单位）有何看法？  [[29:44](https://youtu.be/ondivPiwQho%3Ft%3D29m44s)]  [SELU](https://youtu.be/ondivPiwQho%3Ft%3D29m44s)主要用于全连接层，它允许你摆脱批量规范，基本的想法是，如果你使用这个不同的激活功能，它是自我规范化。 自我归一化意味着它将始终保持单位标准差和零均值，因此你不需要批量规范。 它并没有真正去过任何地方，原因是因为它非常挑剔 - 你必须使用一个非常具体的初始化，否则它不会以恰当的标准偏差和平均值开始。 很难将它与嵌入之类的东西一起使用，如果你这样做，你必须使用一种特殊的嵌入初始化，这对于嵌入是没有意义的。 你完成所有这些工作，很难做到正确，如果你最终做到了，那有什么意义呢？ 好吧，你已经设法摆脱了一些批量标准层，无论如何都没有真正损害你。 这很有趣，因为SELU论文 - 人们注意到它的主要原因是它是由LSTM的发明者创造的，并且它有一个巨大的数学附录。 因此人们认为“很多来自一个着名人物的数学 - 它一定很棒！”但在实践中，杰里米并没有看到任何人使用它来获得任何最先进的结果或赢得任何比赛。
 
@@ -192,7 +192,7 @@ Leaky ReLU（其中_x_ <0）的梯度变化但是大约0.1或0.01的常数。
 
 ![](../img/1_5lQZ0Jln6Cn29rd_9Bvzfw.png)
 
-在这种情况下，我们选择了50比例。 所以我们开始时学习率要小得多。 然后它就有了这个很酷的想法，你可以说你的时代占了三角形底部的百分比从几乎一直到零 - 这是第二个数字。 所以15％的批次都是从三角形底部进一步消耗的。
+在这种情况下，我们选择了50比例。 所以我们开始时学习率要小得多。 然后它就有了这个很酷的想法，你可以说你的迭代占了三角形底部的百分比从几乎一直到零 - 这是第二个数字。 所以15％的批次都是从三角形底部进一步消耗的。
 
 ![](../img/1_E0gxTQ5sf4XSceo9pWKxWQ.png)
 
@@ -282,7 +282,7 @@ GAN的基本思想是它是一个生成模型 [[51:23](https://youtu.be/ondivPiw
 
 **问题** ：GAN是否需要比狗与猫或NLP更多的数据？ 或者它是否可比 [[59:48](https://youtu.be/ondivPiwQho%3Ft%3D59m48s)] ？ 老实说，我有点不好意思说我不是GAN的专家。 我在第一部分讲的内容是我很乐意说的事情，我知道做这些事情的最好方法，所以我可以向你展示最先进的结果，就像我们在CIFAR10的帮助下做的一样学生们。 GANs我根本不在那里，所以我不太确定你需要多少。 一般来说，它似乎需要相当多但是记住我们在狗和猫中不需要太多的唯一原因是因为我们有一个预先训练过的模型，我们可以利用预先训练过的GAN模型并对它们进行微调，可能。 据我所知，我认为没有人这么做过。 这对于人们思考和实验来说可能是非常有趣的事情。 也许人们已经做到了，有些文献我们没有遇到过。 我对GAN中的主要文献有点熟悉，但我不知道所有这些，所以也许我错过了关于GAN中转学的一些内容。 但这不是需要太多数据的诀窍。
 
-**问** ：那么巨大的加速结合了一个周期学习率和动量退火加上八个GPU并行训练的半精度？ 是否只能用消费者GPU进行半精度计算？ 另一个问题是，为什么计算从单精度到半精度的速度提高了8倍，而从单精度加倍只有2倍 [[1:01:09](https://youtu.be/ondivPiwQho%3Ft%3D1h1m9s)] ？ 好的，所以CIFAR10结果，从单一到一半的速度不是8倍。 它从单一到一半快2到3倍。 NVIDIA声称张量核的触发器性能在学术上是正确的，但实际上没有意义，因为它实际上取决于你需要什么样的电话 - 所以大约有2或3倍的改进。 所以半精度有点帮助，额外的GPU有点帮助，一个循环有助于大量，然后另一个关键部分是玩我告诉你的参数。 因此，仔细阅读广泛的ResNet论文，确定他们在那里找到的东西，然后编写你刚看到的架构版本，这使我们很容易摆弄参数，熬夜尝试各种可能的组合不同内核大小，内核数量，层组数量，层组大小。 请记住，我们确实存在瓶颈，但实际上我们倾向于将注意力集中在扩大上，因此我们增加了尺寸然后减小它，因为它更好地利用了GPU。 所有这些事情结合在一起，我会说一个周期可能是最关键的，但每个周期都会导致大幅加速。 这就是为什么我们能够比最先进的CIFAR10获得30倍的改进。 我们对其他事情有一些想法 - 在这个DAWN工作台完成之后，也许我们会尝试进一步看看我们是否能在一天内击败一分钟。 那会很有趣。
+**问** ：那么巨大的加速结合了一个周期学习率和动量退火加上八个GPU并行训练的半精度？ 是否只能用消费者GPU进行半精度计算？ 另一个问题是，为什么计算从单精度到半精度的速度提高了8倍，而从单精度加倍只有2倍 [[1:01:09](https://youtu.be/ondivPiwQho%3Ft%3D1h1m9s)] ？ 好的，所以CIFAR10结果，从单一到一半的速度不是8倍。 它从单一到一半快2到3倍。 NVIDIA声称张量核的触发器表现在学术上是正确的，但实际上没有意义，因为它实际上取决于你需要什么样的电话 - 所以大约有2或3倍的改进。 所以半精度有点帮助，额外的GPU有点帮助，一个循环有助于大量，然后另一个关键部分是玩我告诉你的参数。 因此，仔细阅读广泛的ResNet论文，确定他们在那里找到的东西，然后编写你刚看到的架构版本，这使我们很容易摆弄参数，熬夜尝试各种可能的组合不同内核大小，内核数量，层组数量，层组大小。 请记住，我们确实存在瓶颈，但实际上我们倾向于将注意力集中在扩大上，因此我们增加了尺寸然后减小它，因为它更好地利用了GPU。 所有这些事情结合在一起，我会说一个周期可能是最关键的，但每个周期都会导致大幅加速。 这就是为什么我们能够比最先进的CIFAR10获得30倍的改进。 我们对其他事情有一些想法 - 在这个DAWN工作台完成之后，也许我们会尝试进一步看看我们是否能在一天内击败一分钟。 那会很有趣。
 
 ```
  **class** **DCGAN_D** (nn.Module):  **def** __init__(self, isize, nc, ndf, n_extra_layers=0):  super().__init__()  **assert** isize % 16 == 0, "isize has to be a multiple of 16"  self.initial = ConvBlock(nc, ndf, 4, 2, bn= **False** )  csize,cndf = isize/2,ndf  self.extra = nn.Sequential(*[ConvBlock(cndf, cndf, 3, 1)  **for** t **in** range(n_extra_layers)])  pyr_layers = []  **while** csize > 4:  pyr_layers.append(ConvBlock(cndf, cndf*2, 4, 2))  cndf *= 2; csize /= 2  self.pyramid = nn.Sequential(*pyr_layers)  self.final = nn.Conv2d(cndf, 1, 4, padding=0, bias= **False** )  **def** forward(self, input):  x = self.initial(input)  x = self.extra(x)  x = self.pyramid(x)  **return** self.final(x).mean(0).view(1) 
@@ -304,7 +304,7 @@ GAN的基本思想是它是一个生成模型 [[51:23](https://youtu.be/ondivPiw
  **class** **DCGAN_G** (nn.Module):  **def** __init__(self, isize, nz, nc, ngf, n_extra_layers=0):  super().__init__()  **assert** isize % 16 == 0, "isize has to be a multiple of 16"  cngf, tisize = ngf//2, 4  **while** tisize!=isize: cngf*=2; tisize*=2  layers = [DeconvBlock(nz, cngf, 4, 1, 0)]  csize, cndf = 4, cngf  **while** csize < isize//2:  layers.append(DeconvBlock(cngf, cngf//2, 4, 2, 1))  cngf //= 2; csize *= 2  layers += [DeconvBlock(cngf, cngf, 3, 1, 1)  **for** t **in** range(n_extra_layers)]  layers.append(nn.ConvTranspose2d(cngf, nc, 4, 2, 1,  bias= **False** ))  self.features = nn.Sequential(*layers)  **def** forward(self, input): **return** F.tanh(self.features(input)) 
 ```
 
-**问题** ：在ConvBlock中，为什么批量规范出现在ReLU之后（即`self.bn(self.relu(…))` ） [[1:07:50](https://youtu.be/ondivPiwQho%3Ft%3D1h7m50s)] ？ 我通常希望ReLU然后批量规范 [[1:08:23](https://youtu.be/ondivPiwQho%3Ft%3D1h8m23s)] 这实际上是对Jeremy有意义的顺序。 我们在暗网中的顺序是他们在暗网中使用的顺序，所以每个人似乎都有不同的顺序。 事实上，CIFAR10的大多数人都有不同的顺序，这是批量规范→ReLU→conv，这是一种古怪的思考方式，但事实证明，通常对于更好的残留块。 这被称为“预激活ResNet”。有一些博客文章在那里，人们已经尝试了不同的这些事情的顺序，它似乎很大程度上取决于它是什么特定的数据集和你正在做什么 - 虽然性能上的差异很小，除非是竞赛，否则你不会在意。
+**问题** ：在ConvBlock中，为什么批量规范出现在ReLU之后（即`self.bn(self.relu(…))` ） [[1:07:50](https://youtu.be/ondivPiwQho%3Ft%3D1h7m50s)] ？ 我通常希望ReLU然后批量规范 [[1:08:23](https://youtu.be/ondivPiwQho%3Ft%3D1h8m23s)] 这实际上是对Jeremy有意义的顺序。 我们在暗网中的顺序是他们在暗网中使用的顺序，所以每个人似乎都有不同的顺序。 事实上，CIFAR10的大多数人都有不同的顺序，这是批量规范→ReLU→conv，这是一种古怪的思考方式，但事实证明，通常对于更好的残留块。 这被称为“预激活ResNet”。有一些博客文章在那里，人们已经尝试了不同的这些事情的顺序，它似乎很大程度上取决于它是什么特定的数据集和你正在做什么 - 虽然表现上的差异很小，除非是竞赛，否则你不会在意。
 
 #### 反卷积 [[1:09:36](https://youtu.be/ondivPiwQho%3Ft%3D1h9m36s)] 
 
@@ -492,7 +492,7 @@ GAN的基本思想是它是一个生成模型 [[51:23](https://youtu.be/ondivPiw
  torch.backends.cudnn.benchmark= **True** 
 ```
 
-让我们训练一个时代：
+让我们训练一个迭代：
 
 ```
  train(1, **False** ) 
@@ -542,7 +542,7 @@ GAN的基本思想是它是一个生成模型 [[51:23](https://youtu.be/ondivPiw
 
 > _最后，作为否定结果，我们报告说，当一个人使用基于动量的优化器（例如Adam [8]（β1&gt; 0）对评论者或者使用高学习率时，WGAN训练变得不稳定。_ _由于评论家的损失是非平稳的，基于动量的方法似乎表现更差。_ _我们将动量确定为潜在原因，因为随着损失的爆发和样本变得更糟，亚当步和梯度之间的余弦通常变为负值。_ _这个余弦是负面的唯一地方是在这些不稳定的情况下。_ _因此，我们改用RMSProp [21]，即使在非常不稳定的问题上也能表现良好_
 
-**问题** ：在训练时哪种方法可以检测过度拟合？ 或者在我们完成训练后评估其中一个GAN模型的性能？ 换句话说，火车/瓦尔/测试装置的概念如何转化为GAN  [[1:41:57](https://youtu.be/ondivPiwQho%3Ft%3D1h41m57s)] ？ 这是一个很棒的问题，并且有很多人开玩笑说GAN是如何在一个你不需要测试集的领域，人们通过制作东西并说它看起来很棒来利用它。 GAN有一些着名的问题，其中一个叫做模式崩溃。 模式崩溃发生在你看卧室的地方，结果发现每种可能的噪声向量都只有三种卧室。 你看看你的画廊，结果发现它们都是同一个东西，或者只是三个不同的东西。 如果你崩溃到少数模式，如3或4，很容易看到模式崩溃。但是如果你有一个模式崩溃到10,000模式怎么办？ 因此，只有10,000个可能的卧室，所有的噪声向量都会崩溃。 你将无法在我们刚看到的画廊视图中看到，因为你不可能在10,000个房间中拥有两个相同的卧室。 或者如果这些卧室中的每一个基本上都是其中一个输入的直接副本 - 它基本上记住了一些输入。 可能会发生吗？ 事实上，大多数论文都没有做好工作，有时也没有做任何检查这些事情的工作。 因此，我们如何评估GANS的问题，甚至可能我们应该正确地评估GAN的问题，即使是现在还没有得到广泛的理解。 有些人正试图真正推动。 Ian Goodfellow是最着名的深度学习书籍的第一作者，也是GAN的发明者，他一直在发送连续的推文，提醒人们正确测试GAN的重要性。 如果你看到一篇声称具有特殊GAN结果的论文，那么这绝对值得关注。 他们谈过模式崩溃了吗？ 他们谈过记忆吗？ 等等。
+**问题** ：在训练时哪种方法可以检测过度拟合？ 或者在我们完成训练后评估其中一个GAN模型的表现？ 换句话说，火车/瓦尔/测试装置的概念如何转化为GAN  [[1:41:57](https://youtu.be/ondivPiwQho%3Ft%3D1h41m57s)] ？ 这是一个很棒的问题，并且有很多人开玩笑说GAN是如何在一个你不需要测试集的领域，人们通过制作东西并说它看起来很棒来利用它。 GAN有一些着名的问题，其中一个叫做模式崩溃。 模式崩溃发生在你看卧室的地方，结果发现每种可能的噪声向量都只有三种卧室。 你看看你的画廊，结果发现它们都是同一个东西，或者只是三个不同的东西。 如果你崩溃到少数模式，如3或4，很容易看到模式崩溃。但是如果你有一个模式崩溃到10,000模式怎么办？ 因此，只有10,000个可能的卧室，所有的噪声向量都会崩溃。 你将无法在我们刚看到的画廊视图中看到，因为你不可能在10,000个房间中拥有两个相同的卧室。 或者如果这些卧室中的每一个基本上都是其中一个输入的直接副本 - 它基本上记住了一些输入。 可能会发生吗？ 事实上，大多数论文都没有做好工作，有时也没有做任何检查这些事情的工作。 因此，我们如何评估GANS的问题，甚至可能我们应该正确地评估GAN的问题，即使是现在还没有得到广泛的理解。 有些人正试图真正推动。 Ian Goodfellow是最着名的深度学习书籍的第一作者，也是GAN的发明者，他一直在发送连续的推文，提醒人们正确测试GAN的重要性。 如果你看到一篇声称具有特殊GAN结果的论文，那么这绝对值得关注。 他们谈过模式崩溃了吗？ 他们谈过记忆吗？ 等等。
 
 **问题** ：GAN可以用于数据增加 [[1:45:33](https://youtu.be/ondivPiwQho%3Ft%3D1h45m33s)] 吗？ 是的，绝对可以使用GAN进行数据扩充。 你应该？ 我不知道。 有些论文试图用GAN进行半监督学习。 我还没有发现任何特别引人注目的东西，它们在广泛研究的真正有趣的数据集上展示了最先进的结果。 我有点怀疑并且我有点怀疑的原因是因为根据我的经验，如果你用合成数据训练模型，神经网络将非常善于识别你的合成数据的具体问题和那个结束它正在学习的东西。 有许多其他方法可以完成半监督模型。 有些地方可以工作。 例如，你可能还记得Otavio Good在缩放转换网络的第1部分中创建了奇妙的可视化，其中显示了通过MNIST的信件，至少在那个时候，他是自动遥控车比赛中的头号人物，并且他接受了训练他的模型使用综合增强数据，他基本上拍摄了一辆汽车在赛道上行驶的真实视频，并添加假人和假冒其他车辆。 我认为这很有效，因为A.他是一个天才和B.因为我认为他有一个明确定义的小子集，他必须工作。但总的来说，使用合成数据真的很难。 几十年来我一直尝试使用合成数据和模型（显然不是GAN，因为它们很新）但总的来说很难做到。 非常有趣的研究问题。
 
@@ -652,7 +652,7 @@ opt = TrainOptions（）。parse（[' -  dataroot'，'/ data0 / datasets / cycle
 *   然后我们可以把马变成斑马或斑马变成马，所以有一些方向
 *   归还我们的马，斑马，通往马的道路和斑马之路
 
-希望你能看到这看起来非常类似于fast.ai的那种东西。Fast.ai在转换和性能方面显然做得更多，但请记住，这是这一件事的研究代码，他们做了所有这些工作真的很酷。
+希望你能看到这看起来非常类似于fast.ai的那种东西。Fast.ai在转换和表现方面显然做得更多，但请记住，这是这一件事的研究代码，他们做了所有这些工作真的很酷。
 
 ![](../img/1_zWN8sgzWry6qu7R9FS0Ydw.png)
 

zh/dl13.md

@@ -12,7 +12,7 @@
 
 这是一篇很酷的新论文，刚刚在几天前[出版](https://arxiv.org/abs/1804.03189) ，名为[Deep Painterly Harmonization](https://arxiv.org/abs/1804.03189) ，它几乎完全采用了我们将在本课中学习的技巧，并进行了一些小的调整。 但你可以看到基本的想法是将一张图片粘贴在另一张图片的顶部，然后使用某种方法将两者结合起来。 这种方法被称为“风格转移”。
 
-在我们谈论这个之前，我想提一下William Horton的这个非常酷的贡献，他将这种随机权重平均技术添加到fastai库中，现在它已经合并并准备好了。 他写了一篇关于我强烈建议你查看的帖子，不仅因为随机权重平均让你从现有的神经网络中获得更高的性能，基本上没有额外的工作（就像为你的拟合函数添加两个参数一样简单： `use_swa` ， `swa_start` ）但他也描述了他构建这个的过程以及他如何测试它以及他如何为库做出贡献。 所以我觉得如果你有兴趣做这样的事情会很有趣。 我认为威廉之前没有建立过这种类型的库，因此他描述了他是如何做到的。
+在我们谈论这个之前，我想提一下William Horton的这个非常酷的贡献，他将这种随机权重平均技术添加到fastai库中，现在它已经合并并准备好了。 他写了一篇关于我强烈建议你查看的帖子，不仅因为随机权重平均让你从现有的神经网络中获得更高的表现，基本上没有额外的工作（就像为你的拟合函数添加两个参数一样简单： `use_swa` ， `swa_start` ）但他也描述了他构建这个的过程以及他如何测试它以及他如何为库做出贡献。 所以我觉得如果你有兴趣做这样的事情会很有趣。 我认为威廉之前没有建立过这种类型的库，因此他描述了他是如何做到的。
 
 ![](../img/1_hJeKM7VaXaDyvVTTXWlFqg.png)
 
@@ -42,7 +42,7 @@
  learn.fit_opt_sched(phases) 
 ```
 
-换句话说，使用具有这些阶段的优化程序调度程序来学习。 从那里开始，你传入的大部分内容都可以按照惯例发送到fit函数，因此大多数常用参数都能正常工作。 一般来说，我们可以使用这些训练阶段，你会发现它符合常规方式。 然后，当你说`plot_lr`你会看到上面的图表。 它不仅绘制学习率，还绘制动量，每个阶段，它告诉你它使用了什么优化器。 你可以关闭优化器的打印（ `show_text=False` ），你可以关闭动作的打印（ `show_moms=False` ），你可以做其他的小事情，比如训练阶段可以有一个`lr_decay`参数 [[5:47](https://youtu.be/xXXiC4YRGrQ%3Ft%3D5m47s)]  ：
+换句话说，使用具有这些阶段的优化程序调度器来学习。 从那里开始，你传入的大部分内容都可以按照惯例发送到fit函数，因此大多数常用参数都能正常工作。 一般来说，我们可以使用这些训练阶段，你会发现它符合常规方式。 然后，当你说`plot_lr`你会看到上面的图表。 它不仅绘制学习率，还绘制动量，每个阶段，它告诉你它使用了什么优化器。 你可以关闭优化器的打印（ `show_text=False` ），你可以关闭动作的打印（ `show_moms=False` ），你可以做其他的小事情，比如训练阶段可以有一个`lr_decay`参数 [[5:47](https://youtu.be/xXXiC4YRGrQ%3Ft%3D5m47s)]  ：
 
 ```
  phases = [TrainingPhase(epochs=1, opt_fn=optim.SGD, lr = 1e-2),  TrainingPhase(epochs=1, opt_fn=optim.SGD,  lr = (1e-2,1e-3), lr_decay=DecayType.LINEAR),  TrainingPhase(epochs=1, opt_fn=optim.SGD, lr = 1e-3)] 
@@ -280,7 +280,7 @@
 
 ![](../img/1_sOrJFBPiJYdUsxzythGk8w.png)
 
-他们也可以摧毁你，或者至少让你在历史上看起来很糟糕。 举几个例子，一个是回到第二次世界大战。 IBM提供了跟踪大屠杀所需的所有基础设施。 这些是他们使用的形式，他们有不同的代码 - 犹太人是8，吉普赛人是12，毒气室死亡是6，他们都在这些打卡上。 你现在可以去看博物馆中的这些打卡，这实际上已经由一位瑞士法官审查过，他说IBM的技术援助促进了纳粹的任务并委托他们犯下危害人类罪。 回顾这些时代的历史是很有意思的，看看当时IBM人们的想法是什么。 显而易见的是，有机会展示技术优势，有机会测试他们的新系统，当然还有他们正在制造的巨额资金。 如果你做了一些事情，在某些时候线下就会出现问题，即使你被告知这样做，这对你个人来说也会成为一个问题。 例如，你们都记得大众汽车的柴油机排放丑闻。 谁是一个入狱的人？ 工程师正在做他的工作。 如果所有关于实际上并没有弄乱世界的东西都不足以说服你，那也会让你的生活陷入困境。 如果你做了一些事情，即使有人告诉你这样做会导致问题，你绝对可以追究刑事责任。 Aleksandr Kogan是交出Cambridge Analytica数据的人。 他是剑桥大学的学者。 现在，世界上一位非常着名的剑桥学者为了摧毁民主的基础而尽自己的一份力量。 这不是我们想要的历史。
+他们也可以摧毁你，或者至少让你在历史上看起来很糟糕。 举几个例子，一个是回到第二次世界大战。 IBM提供了跟踪大屠杀所需的所有基础设施。 这些是他们使用的形式，他们有不同的代码 - 犹太人是8，吉普赛人是12，毒气室死亡是6，他们都在这些打卡上。 你现在可以去看博物馆中的这些打卡，这实际上已经由一位瑞士法官审查过，他说IBM的技术援助促进了纳粹的任务并委托他们犯下危害人类罪。 回顾这些迭代的历史是很有意思的，看看当时IBM人们的想法是什么。 显而易见的是，有机会展示技术优势，有机会测试他们的新系统，当然还有他们正在制造的巨额资金。 如果你做了一些事情，在某些时候线下就会出现问题，即使你被告知这样做，这对你个人来说也会成为一个问题。 例如，你们都记得大众汽车的柴油机排放丑闻。 谁是一个入狱的人？ 工程师正在做他的工作。 如果所有关于实际上并没有弄乱世界的东西都不足以说服你，那也会让你的生活陷入困境。 如果你做了一些事情，即使有人告诉你这样做会导致问题，你绝对可以追究刑事责任。 Aleksandr Kogan是交出Cambridge Analytica数据的人。 他是剑桥大学的学者。 现在，世界上一位非常着名的剑桥学者为了摧毁民主的基础而尽自己的一份力量。 这不是我们想要的历史。
 
 ![](../img/1_qXLN21dyZdaaYfxXuCTWhg.png)
 
@@ -455,7 +455,7 @@ VGG网络是接收输入并将其粘贴到多个层中的东西，我将把它
 
 换句话说，它有多弯曲？ 基本的想法是，如果你知道它不是很弯曲，那么你可能会跳得更远。 但如果它很弯曲那么你可能不想跳得那么远。 因此，在更高的维度中，梯度称为雅可比行列式，而二阶导数称为Hessian。 你会一直看到这些词，但这就是他们的意思。 同样，数学家也必须为所有事物发明你的话语。 他们就像深度学习研究人员 - 可能更加傲慢。 使用BFGS，我们将尝试计算二阶导数，然后我们将使用它来确定要走的路线和走多远 - 所以它不再是未知的疯狂跳跃。
 
-现在的问题是，实际计算Hessian（二阶导数）几乎肯定不是一个好主意 [[1:24:15](https://youtu.be/xXXiC4YRGrQ%3Ft%3D1h24m15s)] 。 因为在你要去的每个可能的方向上，对于你测量渐变的每个方向，你还必须在每个方向上计算Hessian。 它变得非常大。 因此，我们不是实际计算它，而是采取一些步骤，我们基本上看看每个步骤中梯度的变化程度，并使用这个小函数逼近Hessian。 再说一遍，这似乎是一件非常明显的事情，但是直到很久以后有人出人意料地没有人想到它。 跟踪你所采取的每一步都需要大量的记忆，所以，不要跟踪你采取的每一步 - 只需保留最后十或二十。 而那里的第二位，就是L到LBFGS。 因此，有限记忆BFGS意味着保留最后10或20个梯度，使用它来近似曲率，然后使用梯度曲率来估计行进方向和距离。 出于多种原因，这在深度学习中通常不是一个好主意。 显然比做Adam或SGD更新要做的工作要多得多，并且它也使用更多的内存 - 当你有一个GPU来存储它并且有数亿个权重时，内存就更成了一个大问题。 但更重要的是，迷你批次是非常颠簸的，所以弄清楚曲率来确定行程的确切距离正如我们所说的那样（是的，澳大利亚和英国的表达 - 你明白了）。 有趣的是，事实证明，实际上使用二阶导数信息就像是鞍点的磁铁。 所以有一些有趣的理论结果，基本上说如果你使用二阶导数信息，它实际上会将你发送到函数的令人讨厌的平坦区域。 所以通常不是一个好主意。
+现在的问题是，实际计算Hessian（二阶导数）几乎肯定不是一个好主意 [[1:24:15](https://youtu.be/xXXiC4YRGrQ%3Ft%3D1h24m15s)] 。 因为在你要去的每个可能的方向上，对于你测量渐变的每个方向，你还必须在每个方向上计算Hessian。 它变得非常大。 因此，我们不是实际计算它，而是采取一些步骤，我们基本上看看每个步骤中梯度的变化程度，并使用这个小函数近似Hessian。 再说一遍，这似乎是一件非常明显的事情，但是直到很久以后有人出人意料地没有人想到它。 跟踪你所采取的每一步都需要大量的记忆，所以，不要跟踪你采取的每一步 - 只需保留最后十或二十。 而那里的第二位，就是L到LBFGS。 因此，有限记忆BFGS意味着保留最后10或20个梯度，使用它来近似曲率，然后使用梯度曲率来估计行进方向和距离。 出于多种原因，这在深度学习中通常不是一个好主意。 显然比做Adam或SGD更新要做的工作要多得多，并且它也使用更多的内存 - 当你有一个GPU来存储它并且有数亿个权重时，内存就更成了一个大问题。 但更重要的是，迷你批次是非常颠簸的，所以弄清楚曲率来确定行程的确切距离正如我们所说的那样（是的，澳大利亚和英国的表达 - 你明白了）。 有趣的是，事实证明，实际上使用二阶导数信息就像是鞍点的磁铁。 所以有一些有趣的理论结果，基本上说如果你使用二阶导数信息，它实际上会将你发送到函数的令人讨厌的平坦区域。 所以通常不是一个好主意。
 
 ```
  **def** actn_loss(x): **return** F.mse_loss(m_vgg(x), targ_v)*1000 

zh/dl14.md

@@ -314,7 +314,7 @@ Alena Harley做了一些非常有趣的事情，她试图找出如果你只用
 
 ![](../img/1_rPTiAdy8iIVV3twfOG7mHg.png)
 
-所以我确信任何拥有多个GPU的人都有过这方面的经验。 那么我们如何让这些人一起工作呢？ 你需要做的就是使用PyTorch模块并使用`nn.DataParallel`包装它。 完成后，它会将其复制到每个GPU，并自动并行运行。 它可以很好地扩展到两个GPU，可以使用三个GPU，比四个GPU更好，除此之外，性能确实倒退。 默认情况下，它会将其复制到你的所有GPU - 你可以添加一组GPU，否则如果你想避免遇到麻烦，例如，我必须与Yannet共享我的盒子，如果我没有把它放在这里那么她现在会对我大喊大叫或抵制我的班级。 所以这就是你避免遇到Yannet麻烦的方法。
+所以我确信任何拥有多个GPU的人都有过这方面的经验。 那么我们如何让这些人一起工作呢？ 你需要做的就是使用PyTorch模块并使用`nn.DataParallel`包装它。 完成后，它会将其复制到每个GPU，并自动并行运行。 它可以很好地扩展到两个GPU，可以使用三个GPU，比四个GPU更好，除此之外，表现确实倒退。 默认情况下，它会将其复制到你的所有GPU - 你可以添加一组GPU，否则如果你想避免遇到麻烦，例如，我必须与Yannet共享我的盒子，如果我没有把它放在这里那么她现在会对我大喊大叫或抵制我的班级。 所以这就是你避免遇到Yannet麻烦的方法。
 
 ```
  m = to_gpu(SrResnet(64, scale))  m = nn.DataParallel(m, [0,2])  learn = Learner(md, SingleModel(m), opt_fn=optim.Adam)  learn.crit = F.mse_loss 
@@ -541,7 +541,7 @@ Alena Harley做了一些非常有趣的事情，她试图找出如果你只用
  learn.save('sr-samp1') 
 ```
 
-我试图弄清楚其中一些细节是正确的。 但这是我最喜欢的部分是接下来会发生什么。 现在我们已经完成了规模等于2 - 渐进式调整大小。 因此，逐步调整大小是让我们在DAWN工作台上获得ImageNet训练的最佳单一计算机结果的技巧。 这是从小开始逐渐变大的想法。 我只知道有两篇论文使用了这个想法。 一个是GANs论文的逐步调整，它允许训练一个非常高分辨率的GAN，另一个是EDSR论文。 关于渐进式调整大小的好处不仅仅是你早期的时代，假设你有2x2更小，快4倍。 你还可以使批量大小增加3或4倍。 但更重要的是，他们会更好地概括，因为你在训练期间为你的模型喂食不同大小的图像。 因此，我们能够像大多数人一样训练ImageNet的一半迭代。 我们的时代更快，而且它们更少。 因此，渐进式调整大小是特别是如果你从头开始训练（我不太确定它是否对微调转移学习有用，但如果你从头开始训练），你可能几乎一直都想做。
+我试图弄清楚其中一些细节是正确的。 但这是我最喜欢的部分是接下来会发生什么。 现在我们已经完成了规模等于2 - 渐进式调整大小。 因此，逐步调整大小是让我们在DAWN工作台上获得ImageNet训练的最佳单一计算机结果的技巧。 这是从小开始逐渐变大的想法。 我只知道有两篇论文使用了这个想法。 一个是GANs论文的逐步调整，它允许训练一个非常高分辨率的GAN，另一个是EDSR论文。 关于渐进式调整大小的好处不仅仅是你早期的迭代，假设你有2x2更小，快4倍。 你还可以使批量大小增加3或4倍。 但更重要的是，他们会更好地概括，因为你在训练期间为你的模型喂食不同大小的图像。 因此，我们能够像大多数人一样训练ImageNet的一半迭代。 我们的迭代更快，而且它们更少。 因此，渐进式调整大小是特别是如果你从头开始训练（我不太确定它是否对微调转移学习有用，但如果你从头开始训练），你可能几乎一直都想做。
 
 #### 进步调整大小 [[59:07](https://youtu.be/nG3tT31nPmQ%3Ft%3D59m7s)] 
 
@@ -1302,7 +1302,7 @@ PyTorch人对这种方法很有说服力。Lambda层实际上是fastai库的一
  _[0.086025625, 0.96324310824275017]_ 
 ```
 
-经过几个时代，我们的准确率达到了96％。 这是好事 [[1:40:56](https://youtu.be/nG3tT31nPmQ%3Ft%3D1h40m56s)] ？ 96％准确好吗？ 希望这个问题的答案取决于它。 这是为了什么？ 答案是Carvana想要这个，因为他们希望能够拍摄他们的汽车图像并将其剪切并粘贴在异国情调的蒙特卡罗背景或其他任何地方（那是蒙特卡洛的地方，而不是模拟）。 要做到这一点，你需要一个非常好的面具。 你不希望将后视镜留在后面，丢失一个车轮，或者包含一些背景或其他东西。 那看起来很愚蠢。 所以你需要一些非常好的东西。 所以只有96％的像素正确才听起来不太好。 但是在我们看之前我们不会真正知道。 让我们来看看吧。
+经过几个迭代，我们的准确率达到了96％。 这是好事 [[1:40:56](https://youtu.be/nG3tT31nPmQ%3Ft%3D1h40m56s)] ？ 96％准确好吗？ 希望这个问题的答案取决于它。 这是为了什么？ 答案是Carvana想要这个，因为他们希望能够拍摄他们的汽车图像并将其剪切并粘贴在异国情调的蒙特卡罗背景或其他任何地方（那是蒙特卡洛的地方，而不是模拟）。 要做到这一点，你需要一个非常好的面具。 你不希望将后视镜留在后面，丢失一个车轮，或者包含一些背景或其他东西。 那看起来很愚蠢。 所以你需要一些非常好的东西。 所以只有96％的像素正确才听起来不太好。 但是在我们看之前我们不会真正知道。 让我们来看看吧。
 
 ```
  learn.save('tmp') 

zh/dl2.md

@@ -189,8 +189,8 @@ learn.fit(1e-2, 1)
 [ 6. 0.01356 0.01518 0.9956 ]
 ```
 
-*   早些时候我们说`3`是epoch的数量，但它实际上是**周期** 。 因此，如果`cycle_len=2` ，它将进行3个循环，其中每个循环是2个epoch（即6个epoch）。 那为什么7呢？ 这是因为`cycle_mult`
-*   `cycle_mult=2` ：每个周期后,周期长度*`cycle_mult`（1个时期+ 2个时期+ 4个时期= 7个时期）。
+*   早些时候我们说`3`是迭代的数量，但它实际上是**周期**。 因此，如果`cycle_len=2`，它将进行 3 个周期，其中每个周期是 2 个迭代（即 6 个迭代）。那为什么是 7 呢？ 这是因为`cycle_mult`
+*   `cycle_mult=2`：它乘以每个周期后的周期长度（1 个迭代 + 2 个迭代 + 4 个迭代 = 7 个迭代）。
 
 ![](../img/1_SA5MA3z-jOBwvzF2e6-E6Q.png)
 
@@ -361,7 +361,7 @@ label_df.pivot_table(index='breed', aggfunc=len).sort_values('id', ascending=Fal
 *   `max_zoom` - 我们将放大1.1倍
 *   `ImageClassifierData.from_csv` - 上次我们使用了`from_paths`但由于标签是CSV文件，我们将调用`from_csv` 。
 *   `test_name` - 如果要提交给Kaggle比赛，我们需要指定测试集的位置
-*   `val_idx` - 没有`validation`文件夹，但我们仍想跟踪我们的本地性能有多好。 所以上面你会看到：
+*   `val_idx` - 没有`validation`文件夹，但我们仍想跟踪我们的本地表现有多好。 所以上面你会看到：
 
 `n = len(list(open(label_csv)))-1` ：打开CSV文件，创建行列表，然后获取长度。 `-1`因为第一行是标题。 因此`n`是我们拥有的图像数量。
 
@@ -471,7 +471,7 @@ label_df.pivot_table(index='breed', aggfunc=len).sort_values('id', ascending=Fal
  learn.fit(1e-2, 5, cycle_len =1) 
 ```
 
-*   提醒：一个`epoch`是一次通过数据，一个`cycle`是一个周期经历多少个epoch
+*   提醒：一个`epoch`是一次通过数据，一个`cycle`是你所说的`cycle`有多少个迭代
 
 ```py
  learn.save('224_pre')  
@@ -486,7 +486,7 @@ label_df.pivot_table(index='breed', aggfunc=len).sort_values('id', ascending=Fal
 
 *   如果你在较小尺寸的图像上训练模型，则可以调用`learn.set_data`并传入更大尺寸的数据集。 这将让你在当前的基础上继续训练更大的图像。
 
-> 开始对几个epoch的小图像进行训练，然后切换到更大的图像并继续训练是避免过拟合的一种非常有效的方法。
+> 开始对几个迭代的小图像进行训练，然后切换到更大的图像，继续训练是避免过拟合的一种非常有效的方法。
 
 ```py
  learn.fit(1e-2, 3, cycle_len=1) 

zh/dl4.md

@@ -75,7 +75,7 @@
  learn = ConvLearner.pretrained(arch, data, **ps=0.5** , precompute=True) 
 ```
 
-你可以通过设置`ps=0.`来删除dropout `ps=0.` 但即使在几个时代之后，我们开始大规模过拟合（训练损失«验证损失）：
+你可以通过设置`ps=0.`来删除dropout `ps=0.` 但即使在几个迭代之后，我们开始大规模过拟合（训练损失«验证损失）：
 
 ```
  [2. **0.3521** **0.55247** 0.84189] 
@@ -664,7 +664,7 @@ IMDB [大型电影评论数据集](http://ai.stanford.edu/~amaas/data/sentiment/
 
 *   我们通过使用`iter`包装数据加载器然后调用`next`获取我们的第一个训练批。
 *   我们得到了一个75乘64张（约70行但不完全）
-*   一个巧妙的技巧torchtext做的是每次随机改变`bptt`数，所以每个时代它的文本略有不同 - 类似于计算机视觉中的洗牌图像。 我们不能随意改变这些词，因为它们需要按正确的顺序排列，所以我们会随机移动它们的断点。
+*   一个巧妙的技巧torchtext做的是每次随机改变`bptt`数，所以每个迭代它的文本略有不同 - 类似于计算机视觉中的洗牌图像。 我们不能随意改变这些词，因为它们需要按正确的顺序排列，所以我们会随机移动它们的断点。
 *   目标值也是75乘64但由于技术上的原因，它被展平为单个向量。
 
 **问题** ：为什么不用句子分开？  [[01:53:40](https://youtu.be/gbceqO8PpBg?t=1h53m40s)] 不是真的 请记住，我们正在使用列。 因此，我们每个专栏的长度都在100万左右，所以尽管这些专栏并不总是完全停止完成，但我们并不关心它们。 每列包含多个句子。

zh/dl5.md

@@ -252,7 +252,7 @@ _提示：_ `{o:i for i,o in enumerate(u_uniq)}`是一个方便的代码行保
 
 #### 神经网络版 [[1:17:21](https://youtu.be/J99NV9Cr75I%3Ft%3D1h17m21s)] 
 
-我们回到excel表来理解直觉。 请注意，我们创建user_idx以查找嵌入，就像我们之前在python代码中所做的那样。 如果我们对user_idx进行单热编码并将其乘以用户嵌入，我们将为用户获取适用的行。 如果它只是矩阵乘法，为什么我们需要嵌入？ 它用于计算性能优化目的。
+我们回到excel表来理解直觉。 请注意，我们创建user_idx以查找嵌入，就像我们之前在python代码中所做的那样。 如果我们对user_idx进行单热编码并将其乘以用户嵌入，我们将为用户获取适用的行。 如果它只是矩阵乘法，为什么我们需要嵌入？ 它用于计算表现优化目的。
 
 ![](../img/1_0CRZIBnNzw1lT_9EHOyd5g.png)
 

zh/dl9.md

@@ -938,7 +938,7 @@ learn.fit(lrs, 1, cycle_len=4, use_clr=(20,8))
 
 [SSD：单发多盒检测器](https://arxiv.org/abs/1512.02325)
 
-*   在同一时间，这些论文出来了。 这两个都做得非常酷，他们取得了与更快的R-CNN类似的性能但是有一个阶段。
+*   在同一时间，这些论文出来了。 这两个都做得非常酷，他们取得了与更快的R-CNN类似的表现但是有一个阶段。
 *   他们采用了multibox的想法，他们试图弄清楚如何处理凌乱的输出。 基本的想法是使用，例如，硬通过负面挖掘，他们会经历并发现所有看起来不那么好并将它们丢弃的匹配，使用非常棘手和复杂的数据增强方法，以及所有类型的hackery。 但他们让他们工作得很好。
 
 [密集物体检测的焦点损失](https://arxiv.org/abs/1708.02002) （RetinaNet）