Merge remote-tracking branch 'upstream/master'

zh/dl1.md

 # 深度学习：第一部分第一课
 
-[课程 Wiki](http://forums.fast.ai/t/wiki-lesson-1/9398/1)
++   [课程论坛](http://forums.fast.ai/t/wiki-lesson-1/9398/1)
 
 ## 入门 [[0:00](https://youtu.be/IPBSB1HLNLo)]：
 

zh/dl13.md

@@ -789,7 +789,7 @@ x = val_tfms.denorm（np.rollaxis（to_np（opt_img_v.data），1,4））[0] plt
 
 #### 数学 [[2:06:33](https://youtu.be/xXXiC4YRGrQ%3Ft%3D2h6m33s)] 
 
-实际上，我想我现在可能会在数学上工作了，下周我们将讨论多GPU和超级分辨率，因为这是来自论文，而且在我们谈论论文之后，我真的希望你做的一件事就是阅读论文，然后在论坛上提出任何不清楚的问题。但是本文的一个关键部分我想谈谈并讨论如何解释它。所以论文说，我们将得到一个输入图像_x_，这个小东西通常意味着它是一个向量，Rachel，但这个是一个矩阵。我想这也可能意味着。我不知道。通常小写字母粗体表示向量或带顶部箭头的小写字母表示向量。通常大字母表示矩阵或小写字母，顶部有两个箭头表示矩阵。在这种情况下，我们的图像是一个矩阵。我们基本上将它视为一个载体，所以也许我们只是领先于自己。
+实际上，我想我现在可能会在数学上工作了，下周我们将讨论多GPU和超级分辨率，因为这是来自论文，而且在我们谈论论文之后，我真的希望你做的一件事就是阅读论文，然后在论坛上提出任何不清楚的问题。但是本文的一个关键部分我想谈谈并讨论如何解释它。所以论文说，我们将得到一个输入图像_x_，这个小东西通常意味着它是一个向量，Rachel，但这个是一个矩阵。我想这也可能意味着。我不知道。通常小写字母粗体表示向量或带顶部箭头的小写字母表示向量。通常大字母表示矩阵或小写字母，顶部有两个箭头表示矩阵。在这种情况下，我们的图像是一个矩阵。我们基本上将它视为一个向量，所以也许我们只是领先于自己。
 
 ![](../img/1_kU-HMZL4kI2So7WV5xow6g.png)
 

zh/dl2.md

@@ -5,7 +5,7 @@
 
 ## 回顾上一课 [[01:02](https://youtu.be/JNxcznsrRb8%3Ft%3D1m2s)] 
 
-*   我们使用3行代码来构建图像分类器。
+*   我们使用 3 行代码来构建图像分类器。
 *   为了训练模型，需要在`PATH`下以某种方式组织数据（在本例中为`data/dogscats/` ）：
 
 ![](../img/1_DdsnEeT2DrnAAp_NrHc-jA.png)
@@ -19,7 +19,7 @@
 
 ## 学习率 [[4:54](https://youtu.be/JNxcznsrRb8%3Ft%3D4m54s)] 
 
-*   学习率的基本思想是，它将决定我们解决方案根据loss改进的速度。
+*   学习率的基本思想是，它将决定我们解决方案改进的速度。
 
 ![](../img/1_bl1EuPH_XEGvMcMW6ZloNg.jpeg)
 
@@ -78,12 +78,12 @@ learn.fit(1e-2, 1)
 ```
 
 *   现在我们创建了一个带有数据增强的新`data`对象。 最初，由于`precompute=True` ，增强实际上什么都不做。
-*   卷积神经网络将这些东西称为“激活”。激活是一个数字，表示“这个特征在这个地方具有这种置信水平（概率）”。 我们正在使用已经学会识别特征的预训练网络（即我们不想改变它所学习的超参数），所以我们可以做的是预先计算隐藏层的激活并只训练最后的线性部分。
+*   卷积神经网络将这些东西称为“激活”。激活是一个数字，表示“这个特征在这个地方具有这种置信水平（概率）”。 我们正在使用已经学会识别特征的预训练网络（即我们不想改变它所学习的超参数），所以我们可以做的是预计算隐藏层的激活并只训练最后的线性部分。
 
 ![](../img/1_JxE9HYahNpcbW9mImEJRPA.png)
 
-*   这就是为什么当你第一次训练你的模型时，它需要更长的时间 - 它预先计算这些激活。
-*   即使我们每次尝试显示不同版本的猫，我们已经预先计算了特定版本猫的激活（即我们没有重新计算更改版本的激活）。
+*   这就是为什么当你第一次训练你的模型时，它需要更长的时间 - 它预计算这些激活。
+*   即使我们每次尝试显示不同版本的猫，我们已经预计算了特定版本猫的激活（即我们没有重新计算更改版本的激活）。
 *   要使用数据增强，我们必须做`learn.precompute=False` ：
 
 ```py
@@ -133,7 +133,7 @@ learn.fit(1e-2, 1)
  learn.load('224_lastlayer') 
 ```
 
-*   当你预先计算激活或创建调整大小的图像（我们将很快了解它）时，会创建各种临时文件，你可以在`data/dogcats/tmp`文件夹中看到这些文件。 如果你遇到奇怪的错误，可能是因为预先计算的激活只完成了一半，或者在某种程度上与你正在做的事情不兼容。 所以你总是可以继续删除这个`/tmp`文件夹以查看它是否会使错误消失（fast.ai相当于将其关闭再打开）。
+*   当你预计算激活或创建调整大小的图像（我们将很快了解它）时，会创建各种临时文件，你可以在`data/dogcats/tmp`文件夹中看到这些文件。 如果你遇到奇怪的错误，可能是因为预计算的激活只完成了一半，或者在某种程度上与你正在做的事情不兼容。 所以你总是可以继续删除这个`/tmp`文件夹以查看它是否会使错误消失（fast.ai相当于将其关闭再打开）。
 *   你还会看到有一个名为`/models`的目录，当你说`learn.save`时，模型会被保存
 
 ![](../img/1_tzmWttjMDhvuAj1xZ7PeOw.png)
@@ -284,7 +284,7 @@ plot_confusion_matrix(cm, data.classes)
 
 1.  启用数据增强，并`precompute=True`
 2.  使用`lr_find()`找到损失仍在明显改善最高学习率
-3.  从预先计算的激活训练最后一层1-2个epoch
+3.  从预计算的激活训练最后一层1-2个epoch
 4.  使用数据增强（即`precompute=False` ）训练最后一层，持续2-3个时期，其中`cycle_len=1`
 5.  解冻所有层
 6.  将早期层设置为比下一个更高层低3x-10x的学习率。 经验法则：ImageNet像图像10倍，卫星或医学成像3倍

zh/dl3.md

 # 深度学习：第一部分第三课
 
-### [第3课](http://forums.fast.ai/t/wiki-lesson-3/9401/1)
++   [课程论坛](http://forums.fast.ai/t/wiki-lesson-3/9401/1)
 
-#### 学生创造的有用材料：
+### 学生创建的有用材料：
 
-*   [AWS操作方法](https://github.com/reshamas/fastai_deeplearn_part1/blob/master/tools/aws_ami_gpu_setup.md)
+*   [AWS 操作方法](https://github.com/reshamas/fastai_deeplearn_part1/blob/master/tools/aws_ami_gpu_setup.md)
 *   [TMUX](https://github.com/reshamas/fastai_deeplearn_part1/blob/master/tools/tmux.md)
-*   [第2课总结](https://medium.com/%40apiltamang/case-study-a-world-class-image-classifier-for-dogs-and-cats-err-anything-9cf39ee4690e)
-*   [学习率查询器](https://towardsdatascience.com/estimating-optimal-learning-rate-for-a-deep-neural-network-ce32f2556ce0)
+*   [第 2 课总结](https://medium.com/%40apiltamang/case-study-a-world-class-image-classifier-for-dogs-and-cats-err-anything-9cf39ee4690e)
+*   [学习率查找器](https://towardsdatascience.com/estimating-optimal-learning-rate-for-a-deep-neural-network-ce32f2556ce0)
 *   [PyTorch](https://towardsdatascience.com/a-practitioners-guide-to-pytorch-1d0f6a238040)
 *   [学习率与批量大小](https://miguel-data-sc.github.io/2017-11-05-first/)
-*   [误差表面与泛化的平滑区域](https://medium.com/%40radekosmulski/do-smoother-areas-of-the-error-surface-lead-to-better-generalization-b5f93b9edf5b)
-*   [卷云神经网络在5分钟内完成](https://medium.com/%40init_27/convolutional-neural-network-in-5-minutes-8f867eb9ca39)
-*   [解码ResNet架构](http://teleported.in/posts/decoding-resnet-architecture/)
-*   [另一个ResNet教程](https://medium.com/%40apiltamang)
+*   [误差表面的平滑区域与泛化](https://medium.com/%40radekosmulski/do-smoother-areas-of-the-error-surface-lead-to-better-generalization-b5f93b9edf5b)
+*   [5 分钟搞定卷积神经网络](https://medium.com/%40init_27/convolutional-neural-network-in-5-minutes-8f867eb9ca39)
+*   [解码 ResNet 架构](http://teleported.in/posts/decoding-resnet-architecture/)
+*   [另一个 ResNet 教程](https://medium.com/%40apiltamang)
 
-#### 我们离开这里的地方：
+### 我们离开的地方：
 
 ![](../img/1_w03TpHU-IgKy5GsLuMYxzw.png)
 
-### 回顾 [[08:24](https://youtu.be/9C06ZPF8Uuc%3Ft%3D8m24s)] ：
+## 回顾 [[08:24](https://youtu.be/9C06ZPF8Uuc%3Ft%3D8m24s)] ：
 
-#### Kaggle CLI：如何下载数据1：
+### Kaggle CLI：如何下载数据 1：
 
-从Kaggle下载时， [Kaggle CLI](https://github.com/floydwch/kaggle-cli)是一个很好的工具。 因为它是从Kaggle网站下载数据（通过屏幕抓取），它会在网站更改时中断。 当发生这种情况时，运行`pip install kaggle-cli --upgrade` 。
+从 Kaggle 下载时， [Kaggle CLI](https://github.com/floydwch/kaggle-cli) 是一个很好的工具。 因为它从 Kaggle 网站下载数据（通过屏幕抓取），它会在网站更改时损坏。 当发生这种情况时，运行`pip install kaggle-cli --upgrade` 。
 
 然后你可以运行：
 
 ```
- $ kg download -u <username> -p <password> -c <competition> 
+$ kg download -u <username> -p <password> -c <competition> 
 ```
 
-将`&lt;username&gt;` ， `&lt;password&gt;`替换为你的凭证， `&lt;competition&gt;`是URL中的`/c/` 。 例如，如果你尝试从`https://www.kaggle.com **/c/** dog-breed-identification`下载狗品种数据，该命令将如下所示：
+将`<username>`，`<password>`替换为你的凭证，`<competition>`是 URL 中的`/c/`。 例如，如果你尝试从`https://www.kaggle.com/c/dog-breed-identification`下载狗品种数据，该命令将如下所示：
 
 ```
- `$ kg download -u john.doe -p mypassword -c` dog-breed-identification 
+$ kg download -u john.doe -p mypassword -c dog-breed-identification 
 ```
 
-确保你曾从计算机上单击过“ `Download`按钮并接受以下规则：
+确保你曾从计算机上单击过`Download`按钮并接受以下规则：
 
 ![](../img/1_NE_vFqUgrq_ZY-Ez8lYD1Q.png)
 
-#### CurWget（Chrome扩展程序）：如何下载数据2：
+### CurWget（Chrome 扩展程序）：如何下载数据 2：
 
 [![](../img/1_dpgcElfgbBLg-LKqyQHOBQ.png)](https://chrome.google.com/webstore/detail/curlwget/jmocjfidanebdlinpbcdkcmgdifblncg)
 
-#### 快狗与猫 [[13:39](https://youtu.be/9C06ZPF8Uuc%3Ft%3D13m39s)] 
+### 简单的猫狗识别 [[13:39](https://youtu.be/9C06ZPF8Uuc%3Ft%3D13m39s)] 
 
 ```
- **from** fastai.conv_learner **import** *  PATH = 'data/dogscats/'  sz=224; bs=64 
+from fastai.conv_learner import *  
+PATH = 'data/dogscats/'  
+sz=224
+bs=64 
 ```
 
-笔记本通常假设你的数据位于`data`文件夹中。 但也许你想把它们放在其他地方。 在这种情况下，你可以使用符号链接（简称符号链接）：
+笔记本通常假设你的数据位于`data`文件夹中。 但也许你想把它们放在其他地方。 在这种情况下，你可以使用符号链接（简称`symlink`）：
 
 ![](../img/1_f835x3bUfRPT9pFaqjvutw.png)
 
-这是一个端到端的过程，以获得狗与猫的最新结果：
+这是一个端到端的过程，用于获得猫狗识别的最新结果：
 
 ![](../img/1_ItxElIWV6hU9f_fwEZ9jMQ.png)
 
-Quick Dogs v Cats
+简单的猫狗识别
 
-
-
-#### 进一步分析：
+### 进一步分析：
 
 ```
- data = ImageClassifierData.from_paths(PATH, tfms= tfms, bs=bs, test_name='test') 
+data = ImageClassifierData.from_paths(PATH, tfms= tfms, bs=bs, test_name='test') 
 ```
 
 *   `from_paths` ：表示子文件夹名称是标签。 如果你的`train`文件夹或`valid`文件夹具有不同的名称，则可以发送`trn_name`和`val_name`参数。
@@ -85,7 +86,7 @@ Quick Dogs v Cats
 
 *   `bn_freeze` ：如果你在一个与ImageNet非常相似的数据集上使用更大的更深层次的模型，如ResNet50或ResNext101（数字大于34的任何东西）（即标准对象的侧面照片，其大小类似于ImageNet在200-500之间像素），你应该添加这一行。 我们将在课程的后半部分了解更多信息，但这会导致批量标准化移动平均值无法更新。
 
-#### [如何使用其他库 - Keras](https://github.com/fastai/fastai/blob/master/courses/dl1/keras_lesson1.ipynb)  [[20:02](https://youtu.be/9C06ZPF8Uuc%3Ft%3D20m2s)] 
+### [如何使用其他库 - Keras](https://github.com/fastai/fastai/blob/master/courses/dl1/keras_lesson1.ipynb)  [[20:02](https://youtu.be/9C06ZPF8Uuc%3Ft%3D20m2s)] 
 
 了解如何使用Fast.ai以外的库非常重要。 Keras是一个很好的例子，因为就像Fast.ai一样位于PyTorch之上，它位于各种库之上，如TensorFlow，MXNet，CNTK等。
 
@@ -177,7 +178,7 @@ Quick Dogs v Cats
 
 **Tensorflow** - 如果你想要转换你在本课程中学到的东西，可以使用**Keras**做更多的工作，但这需要更多的工作并且很难获得相同级别的结果。 也许将来会有TensorFlow兼容的Fast.ai版本。 我们会看到。
 
-#### 为Kaggle创建提交文件 [[32:45](https://youtu.be/9C06ZPF8Uuc%3Ft%3D32m45s)] 
+### 为Kaggle创建提交文件 [[32:45](https://youtu.be/9C06ZPF8Uuc%3Ft%3D32m45s)] 
 
 要创建提交文件，我们需要两条信息：
 
@@ -224,7 +225,7 @@ Quick Dogs v Cats
 
 *   你可以使用Kaggle CLI直接从服务器提交，也可以使用`FileLink` ，它将为你提供从服务器下载文件到计算机的链接。
 
-#### 个人预测 [[39:32](https://youtu.be/9C06ZPF8Uuc%3Ft%3D39m32s)] 
+### 个人预测 [[39:32](https://youtu.be/9C06ZPF8Uuc%3Ft%3D39m32s)] 
 
 如果我们想通过模型运行单个图像来获得预测怎么办？
 
@@ -262,7 +263,7 @@ Quick Dogs v Cats
 *   传递给模型或从模型返回的所有内容通常都假定为小批量。 这里我们只有一个图像，但我们必须将其转换为单个图像的小批量。 换句话说，我们需要创建一个不仅仅是`[rows, columns, channels]` ，而是`[number of images, rows, columns, channels]` 。
 *   `im[None]` ：在开始时添加额外单位轴的Numpy技巧。
 
-#### 理论：卷积神经网络在幕后实际发生了什么 [[42:17](https://youtu.be/9C06ZPF8Uuc%3Ft%3D42m17s)] 
+### 理论：卷积神经网络在幕后实际发生了什么 [[42:17](https://youtu.be/9C06ZPF8Uuc%3Ft%3D42m17s)] 
 
 *   我们在第1课中看到了一点理论 - [http://setosa.io/ev/image-kernels/](http://setosa.io/ev/image-kernels/)
 *   卷积是我们有一个小矩阵（在深度学习中几乎总是3x3）并将该矩阵的每个元素乘以图像的3x3部分的每个元素并将它们全部加在一起以在一个点获得该卷积的结果。
@@ -288,7 +289,7 @@ Quick Dogs v Cats
 
 **问题** ：如果输入有3个通道会发生什么？  [[1:05:30](https://youtu.be/9C06ZPF8Uuc%3Ft%3D1h5m30s)] 它看起来类似于具有2个通道的Conv1层 - 因此，滤波器每个滤波器有2个通道。 预先训练的ImageNet模型使用3个通道。 当你有少于3个频道时，你可以使用的一些技巧是复制其中一个频道使其成为3，或者如果你有2，则获得平均值并将其视为第三个频道。 如果你有4个通道，你可以用卷全部零点为卷积内核添加额外的级别。
 
-#### 接下来发生什么？  [[1:08:47](https://youtu.be/9C06ZPF8Uuc%3Ft%3D1h8m47s)] 
+### 接下来发生什么？  [[1:08:47](https://youtu.be/9C06ZPF8Uuc%3Ft%3D1h8m47s)] 
 
 我们已经达到完全连接层（它做经典矩阵产品）。 在excel表中，有一个激活。 如果我们想查看输入的十位数中的哪一位，我们实际上想要计算10个数字。
 
@@ -301,7 +302,7 @@ Quick Dogs v Cats
 
 为什么我们需要非线性？ 如果堆叠多个线性层，它仍然只是一个线性层。 通过添加非线性层，我们可以适应任意复杂的形状。 我们使用的非线性激活函数是ReLU。
 
-#### Softmax  [[01:14:08](https://youtu.be/9C06ZPF8Uuc%3Ft%3D1h14m8s)] 
+### Softmax  [[01:14:08](https://youtu.be/9C06ZPF8Uuc%3Ft%3D1h14m8s)] 
 
 Softmax仅出现在最后一层。 它输出0到1之间的数字，它们加起来为1.理论上，这并不是绝对必要的 - 我们可以要求神经网络学习一组内核，这些内核可以提供尽可能接近我们想要的概率的内核。 通常，通过深度学习，如果你可以构建你的体系结构，以便尽可能容易地表达所需的特征，你将获得更好的模型（更快速地学习并使用更少的参数）。
 
@@ -317,7 +318,7 @@ Softmax仅出现在最后一层。 它输出0到1之间的数字，它们加起
 
 **问题** ：如果想把图片分类为猫狗，我们使用什么样的激活功能？  [[1:20:27](https://youtu.be/9C06ZPF8Uuc%3Ft%3D1h20m27s)] 碰巧我们现在要这样做。 我们可能想要这样做的一个原因是进行多标签分类。
 
-### 星球大赛 [[01:20:54](https://youtu.be/9C06ZPF8Uuc%3Ft%3D1h20m54s)] 
+## 星球大赛 [[01:20:54](https://youtu.be/9C06ZPF8Uuc%3Ft%3D1h20m54s)] 
 
 [Notebook](https://github.com/fastai/fastai/blob/master/courses/dl1/lesson2-image_models.ipynb) / [Kaggle页面](https://www.kaggle.com/c/planet-understanding-the-amazon-from-space)
 
@@ -497,7 +498,7 @@ Softmax不喜欢预测多个事物。 它想要选择一件事。
 
 我们在这款笔记本上使用了[F-beta](http://scikit-learn.org/stable/modules/generated/sklearn.metrics.fbeta_score.html)而不是`accuacy` - 它是一种权衡假阴性和误报的方法。 我们使用它的原因是因为这个特殊的Kaggle比赛想要使用它。 看看[planet.py](https://github.com/fastai/fastai/blob/master/courses/dl1/planet.py) ，了解如何创建自己的指标函数。 这是最后打印出来的`[ 0\. 0.08932 0.08218 **0.9324** ]`
 
-#### 多标签分类的激活功能 [[01:44:25](https://youtu.be/9C06ZPF8Uuc%3Ft%3D1h44m25s)] 
+### 多标签分类的激活功能 [[01:44:25](https://youtu.be/9C06ZPF8Uuc%3Ft%3D1h44m25s)] 
 
 用于多标签分类的激活函数称为**sigmoid。**
 
@@ -513,7 +514,7 @@ Softmax不喜欢预测多个事物。 它想要选择一件事。
 
 问题：当你使用差异学习率时，这三种学习率是否在各层之间均匀分布？  [[01:55:35](https://youtu.be/9C06ZPF8Uuc%3Ft%3D1h55m35s)] 我们将在后面的课程中详细讨论这个问题，但是fast.ai库中有一个“层组”的概念。 在类似ResNet50的东西中，有数百个层，你可能不想写出数百个学习率，因此库决定如何拆分它们，最后一个总是指我们随机初始化的全连接层并补充说。
 
-#### 可视化层 [[01:56:42](https://youtu.be/9C06ZPF8Uuc%3Ft%3D1h56m42s)] 
+### 可视化层 [[01:56:42](https://youtu.be/9C06ZPF8Uuc%3Ft%3D1h56m42s)] 
 
 ```
  learn.summary() 
@@ -529,7 +530,7 @@ Softmax不喜欢预测多个事物。 它想要选择一件事。
 
 **问题** ：一个非常小的数据集的学习率查找器返回了奇怪的数字并且情节是空的 [[01:58:57](https://youtu.be/9C06ZPF8Uuc%3Ft%3D1h58m57s)]  - 学习率查找器将一次通过一个小批量。 如果你有一个很小的数据集，那么就没有足够的小批量。 所以诀窍是让你的批量大小非常小，如4或8。
 
-### 结构化数据 [[01:59:48](https://youtu.be/9C06ZPF8Uuc%3Ft%3D1h59m48s)] 
+## 结构化数据 [[01:59:48](https://youtu.be/9C06ZPF8Uuc%3Ft%3D1h59m48s)] 
 
 我们在机器学习中使用了两种类型的数据集：
 
@@ -541,7 +542,7 @@ Softmax不喜欢预测多个事物。 它想要选择一件事。
 *   [CorporaciónFavoritaGrocery销售预测](https://www.kaggle.com/c/favorita-grocery-sales-forecasting) - 目前正在运行
 *   [罗斯曼商店销售](https://www.kaggle.com/c/rossmann-store-sales) - 几乎与上述相同但已完成竞争。
 
-#### 罗斯曼商店促销 [[02:02:42](https://youtu.be/9C06ZPF8Uuc%3Ft%3D2h2m42s)] 
+### 罗斯曼商店促销 [[02:02:42](https://youtu.be/9C06ZPF8Uuc%3Ft%3D2h2m42s)] 
 
 [笔记本](https://github.com/fastai/fastai/blob/master/courses/dl1/lesson3-rossman.ipynb)
 
@@ -555,7 +556,7 @@ Softmax不喜欢预测多个事物。 它想要选择一件事。
 
 有很多数据预处理这个笔记本包含来自第三名获胜者（ [实体嵌入分类变量](https://arxiv.org/abs/1604.06737) ）的整个管道。 本课程不涉及数据处理，但在机器学习课程中有详细介绍，因为特征工程非常重要。
 
-#### 查看CSV文件
+### 查看CSV文件
 
 ```
  table_names = ['train', 'store', 'store_states', 'state_names',  'googletrend', 'weather', 'test'] 
@@ -573,7 +574,7 @@ Softmax不喜欢预测多个事物。 它想要选择一件事。
 
 *   `StoreType` - 你经常会获得某些列包含“代码”的数据集。 代码意味着什么并不重要。 远离对它的过多学习，看看数据首先说的是什么。
 
-#### 加入表格
+### 加入表格
 
 这是一个关系数据集，你已经连接了很多表 - 这很容易与Pandas `merge` ：
 
@@ -596,7 +597,7 @@ Softmax不喜欢预测多个事物。 它想要选择一件事。
 
 *   `to_feather` ：将Pandas的数据帧保存为“羽状”格式，将其放在RAM中并将其转储到磁盘上。 所以真的很快。 厄瓜多尔杂货竞赛有3.5亿条记录，因此你需要关心保存需要多长时间。
 
-#### 下周
+### 下周
 
 *   将列拆分为两种类型：分类和连续。 分类列将表示为一个热编码，并且连续列按原样馈送到全连接层。
 *   分类：商店＃1和商店＃2在数量上并不相互关联。 类似地，星期一（第0天）和星期二（第1天）的星期几。

zh/dl4.md

 # 深度学习：第一部分第四课
 
-### [第4课](http://forums.fast.ai/t/wiki-lesson-4/9402/1)
++   [课程论坛](http://forums.fast.ai/t/wiki-lesson-4/9402/1)
 
-学生用品：
+学生的文章：
 
-*   [改善我们学习率的方式](https://techburst.io/improving-the-way-we-work-with-learning-rate-5e99554f163b)
+*   [改善学习率的方式](https://techburst.io/improving-the-way-we-work-with-learning-rate-5e99554f163b)
 *   [循环学习率技术](http://teleported.in/posts/cyclic-learning-rate/)
-*   [使用重新启动（SGDR）探索随机梯度下降](https://medium.com/38th-street-studios/exploring-stochastic-gradient-descent-with-restarts-sgdr-fa206c38a74e)
-*   [使用差异学习率转移学习](https://towardsdatascience.com/transfer-learning-using-differential-learning-rates-638455797f00)
+*   [探索带有重启动的随机梯度下降（SGDR）](https://medium.com/38th-street-studios/exploring-stochastic-gradient-descent-with-restarts-sgdr-fa206c38a74e)
+*   [使用差异学习率的迁移学习](https://towardsdatascience.com/transfer-learning-using-differential-learning-rates-638455797f00)
 *   [让计算机看得比人类更好](https://medium.com/%40ArjunRajkumar/getting-computers-to-see-better-than-humans-346d96634f73)
 
 ![](../img/1_D0WqPCX7RfOL47TOEfkzYg.png)
 
-####  Dropout [04:59]
+###  Dropout [04:59]
 
 ```
- learn = ConvLearner.pretrained(arch, data, ps=0.5, precompute=True) 
+learn = ConvLearner.pretrained(arch, data, ps=0.5, precompute=True) 
 ```
 
-*   `precompute=True` ：预先计算从最后一个卷积层出来的激活。 请记住，激活是一个数字，它是根据构成内核/过滤器的一些权重/参数计算出来的，它们会应用于上一层的激活或输入。
+*   `precompute=True` ：预计算来自最后一个卷积层的激活。 请记住，激活是一个数字，它是根据构成内核/过滤器的一些权重/参数计算出来的，它们会应用于上一层的激活或输入。
 
 ```
- learn 
+learn 
 ```
 
 ```
- _Sequential(_  _(0): BatchNorm1d(1024, eps=1e-05, momentum=0.1, affine=True)_  _(1): Dropout(p=0.5)_  _(2): Linear(in_features=1024, out_features=512)_  _(3): ReLU()_  _(4): BatchNorm1d(512, eps=1e-05, momentum=0.1, affine=True)_  _(5): Dropout(p=0.5)_  _(6): Linear(in_features=512, out_features=120)_  _(7): LogSoftmax()_  _)_ 
+Sequential(
+  (0): BatchNorm1d(1024, eps=1e-05, momentum=0.1, affine=True)
+  (1): Dropout(p=0.5)
+  (2): Linear(in_features=1024, out_features=512)
+  (3): ReLU()
+  (4): BatchNorm1d(512, eps=1e-05, momentum=0.1, affine=True)
+  (5): Dropout(p=0.5)
+  (6): Linear(in_features=512, out_features=120)
+  (7): LogSoftmax()
+)
 ```
 
 `learn` - 这将显示我们最后添加的层。 这些是我们在`precompute=True`时训练的层
 
 （0），（4）： `BatchNorm`将在上一课中介绍
 
-（1），（5）： `Dropout`
+（1），（5）：`Dropout`
 
-（2）： `Linear`层简单地表示矩阵乘法。 这是一个包含1024行和512列的矩阵，因此它将进行1024次激活并输出512次激活。
+（2）： `Linear`层仅仅是矩阵乘法。 这是一个包含 1024 行和 512 列的矩阵，因此它将接受 1024 个激活并输出 512 个激活。
 
-（3）： `ReLU` - 只需用零替换负数
+（3）： `ReLU` - 只是用零替换负数
 
-（6）： `Linear` - 第二个线性层，从前一个线性层获取512次激活并将它们通过一个新矩阵乘以512乘120并输出120次激活
+（6）： `Linear` - 第二个线性层，从前一个线性层获取 512 个激活并将它们乘以 512 乘 120 的新矩阵并输出 120 个激活
 
-（7）： `Softmax` - 激活函数，返回最多为1的数字，每个数字在0和1之间：
+（7）： `Softmax` - 激活函数，返回最大为 1 的数字，每个数字在 0 和 1 之间：
 
 ![](../img/1_PNRoFZeNc0DfGyqsq-S7sA.png)
 
-出于较小的数值精度原因，事实证明最好直接使用softmax的log而不是softmax  [[15:03](https://youtu.be/gbceqO8PpBg%3Ft%3D15m3s)] 。 这就是为什么当我们从模型中得到预测时，我们必须做`np.exp(log_preds)` 。
+出于较小的数值精度原因，事实证明最好直接使用 softmax 的 log 而不是 softmax [[15:03](https://youtu.be/gbceqO8PpBg%3Ft%3D15m3s)]。这就是为什么当我们从模型中得到预测时，我们必须执行`np.exp(log_preds)`。
 
-#### 什么是`Dropout` ，什么是`p` ？  [[08:17](https://youtu.be/gbceqO8PpBg%3Ft%3D8m17s)] 
+### 什么是`Dropout` ，什么是`p` ？  [[08:17](https://youtu.be/gbceqO8PpBg%3Ft%3D8m17s)] 
 
 ```
  _Dropout(p=0.5)_ 
@@ -127,7 +136,7 @@
 
 **问题** ：我们是否需要在添加 Dropout 后调整学习率？ [[24:33](https://youtu.be/gbceqO8PpBg%3Ft%3D24m33s)] 它似乎不足以影响学习率。 理论上，它可能但不足以影响我们。
 
-#### 结构化和时间序列数据 [[25:03](https://youtu.be/gbceqO8PpBg%3Ft%3D25m3s)] 
+### 结构化和时间序列数据 [[25:03](https://youtu.be/gbceqO8PpBg%3Ft%3D25m3s)] 
 
 [笔记本](https://github.com/fastai/fastai/blob/master/courses/dl1/lesson3-rossman.ipynb) / [Kaggle](https://www.kaggle.com/c/rossmann-store-sales)
 
@@ -173,7 +182,7 @@
 *   循环遍历`cat_vars`并将适用的数据框列转换为分类列。
 *   循环通过`contin_vars`并将它们设置为`float32` （32位浮点），因为这是PyTorch所期望的。
 
-#### 从一个小样本开始 [[34:29](https://youtu.be/gbceqO8PpBg%3Ft%3D34m29s)] 
+### 从一个小样本开始 [[34:29](https://youtu.be/gbceqO8PpBg%3Ft%3D34m29s)] 
 
 ```
  idxs = get_cv_idxs(n, val_pct=150000/n)  joined_samp = joined.iloc[idxs].set_index("Date")  samp_size = len(joined_samp); samp_size 
@@ -205,7 +214,7 @@
 
 *   [如何（以及为什么）创建一个好的验证集](http://www.fast.ai/2017/11/13/validation-sets/)
 
-#### 让我们直接进入深度学习行动 [[39:48](https://youtu.be/gbceqO8PpBg%3Ft%3D39m48s)] 
+### 让我们直接进入深度学习行动 [[39:48](https://youtu.be/gbceqO8PpBg%3Ft%3D39m48s)] 
 
 对于任何Kaggle比赛，重要的是你要充分了解你的指标 - 你将如何评判。 在[本次比赛中](https://www.kaggle.com/c/rossmann-store-sales) ，我们将根据均方根百分比误差（RMSPE）进行判断。
 
@@ -248,7 +257,7 @@
 *   `[1000,500]` ： `[1000,500]`激活多少次
 *   `[0.001,0.01]` ：在后续层使用多少 Dropout 者
 
-#### 关键新概念：嵌入 [[45:39](https://youtu.be/gbceqO8PpBg%3Ft%3D45m39s)] 
+### 关键新概念：嵌入 [[45:39](https://youtu.be/gbceqO8PpBg%3Ft%3D45m39s)] 
 
 我们暂时忘记分类变量：
 
@@ -256,13 +265,13 @@
 
 请记住，你永远不想将ReLU放在最后一层，因为softmax需要负数来创建低概率。
 
-#### **完全连接神经网络的简单视图[** [**49:13**](https://youtu.be/gbceqO8PpBg%3Ft%3D49m13s) **]：**
+### **完全连接神经网络的简单视图[** [**49:13**](https://youtu.be/gbceqO8PpBg%3Ft%3D49m13s) **]：**
 
 ![](../img/1_5D0_nDy0K0QLKFHTD07gcQ.png)
 
 对于回归问题（不是分类），你甚至可以跳过softmax层。
 
-#### 分类变量 [[50:49](https://youtu.be/gbceqO8PpBg%3Ft%3D50m49s)] 
+### 分类变量 [[50:49](https://youtu.be/gbceqO8PpBg%3Ft%3D50m49s)] 
 
 我们创建一个7行的新矩阵和我们选择的列数（例如4）并用浮点数填充它。 要使用连续变量将“星期日”添加到我们的等级1张量中，我们会查看此矩阵，它将返回4个浮点数，并将它们用作“星期日”。
 
@@ -310,7 +319,7 @@
 
 **问题** ：嵌入是否适合某些类型的变量？  [[01:02:45](https://youtu.be/gbceqO8PpBg%3Ft%3D1h2m45s)] 嵌入适用于任何分类变量。 它唯一不能很好地工作的是基数太高的东西。 如果你有600,000行且变量有600,000个级别，那么这不是一个有用的分类变量。 但总的来说，本次比赛的第三名获胜者确实认为所有基因都不是太高，他们都把它们都视为绝对的。 好的经验法则是，如果你可以创建一个分类变量，你也可以这样，因为它可以学习这种丰富的分布式表示; 如果你把它留在连续的地方，它最能做的就是试着找到一个适合它的单一功能形式。
 
-#### 场景背后的矩阵代数 [[01:04:47](https://youtu.be/gbceqO8PpBg%3Ft%3D1h4m47s)] 
+### 场景背后的矩阵代数 [[01:04:47](https://youtu.be/gbceqO8PpBg%3Ft%3D1h4m47s)] 
 
 查找具有索引的嵌入与在单热编码向量和嵌入矩阵之间进行矩阵乘积相同。 但这样做非常低效，因此现代库实现这一点，即采用整数并查看数组。
 
@@ -326,7 +335,7 @@
 
 因此，例如，星期几现在变为八行四列嵌入矩阵。 从概念上讲，这允许我们的模型创建一些有趣的时间序列模型。 如果有一个七天周期的周期在周一和周三上升，但仅限于每天和仅在柏林，它可以完全这样做 - 它拥有它需要的所有信息。 这是处理时间序列的绝佳方式。 你只需确保时间序列中的循环指示符作为列存在。 如果你没有一个名为day of week的列，那么神经网络很难学会做mod 7并在嵌入矩阵中查找。 这不是不可能，但真的很难。 如果你预测旧金山的饮料销售，你可能想要一个AT＆T公园球赛开始时的清单，因为这会影响到SoMa有多少人在喝啤酒。 因此，你需要确保基本指标或周期性在你的数据中，并且只要它们在那里，神经网络将学会使用它们。
 
-#### 学习器 [[01:10:13](https://youtu.be/gbceqO8PpBg%3Ft%3D1h10m13s)] 
+### 学习器 [[01:10:13](https://youtu.be/gbceqO8PpBg%3Ft%3D1h10m13s)] 
 
 ```
  m = md.get_learner(emb_szs, len(df.columns)-len(cat_vars), 0.04, 1,  [1000,500], [0.001,0.01], y_range=y_range)  lr = 1e-3 
@@ -406,11 +415,11 @@
 
 **问题** ：缺点是什么？ 几乎没有人使用这个。 为什么不？  [[01:20:41](https://youtu.be/gbceqO8PpBg%3Ft%3D1h20m41s)] 基本上答案就像我们之前讨论过的那样，学术界没有人差不多正在研究这个问题，因为这不是人们发表的内容。 结果，人们可以看到的并没有很好的例子，并且说“哦，这是一种运作良好的技术，让我们的公司实施它”。 但也许同样重要的是，到目前为止，使用这个Fast.ai库，还没有任何方法可以方便地进行。 如果你想要实现其中一个模型，则必须自己编写所有自定义代码。 有很多大的商业和科学机会来使用它并解决以前未能很好解决的问题。
 
-### 自然语言处理 [[01:23:37](https://youtu.be/gbceqO8PpBg%3Ft%3D1h23m37s)] 
+## 自然语言处理 [[01:23:37](https://youtu.be/gbceqO8PpBg%3Ft%3D1h23m37s)] 
 
 最具前瞻性的深度学习领域，它落后于计算机视觉两三年。 软件的状态和一些概念远没有计算机视觉那么成熟。 你在NLP中找到的一件事是你可以解决的特殊问题，并且它们具有特定的名称。 NLP中存在一种称为“语言建模”的特殊问题，它有一个非常具体的定义 - 它意味着建立一个模型，只要给出一个句子的几个单词，你能预测下一个单词将会是什么。
 
-#### 语言建模 [[01:25:48](https://youtu.be/gbceqO8PpBg%3Ft%3D1h25m48s)] 
+### 语言建模 [[01:25:48](https://youtu.be/gbceqO8PpBg%3Ft%3D1h25m48s)] 
 
 [笔记本](https://github.com/fastai/fastai/blob/master/courses/dl1/lang_model-arxiv.ipynb)
 
@@ -485,7 +494,7 @@
 
 语言模型可以非常深刻和微妙，所以我们将尝试构建它 - 不是因为我们关心这一点，而是因为我们正在尝试创建一个用于执行其他任务的预训练模型。 例如，鉴于IMDB电影评论，我们将确定它们是正面还是负面。 这很像猫与狗 - 分类问题。 所以我们真的想使用预先训练好的网络，至少知道如何阅读英语。 因此，我们将训练一个模型来预测句子的下一个单词（即语言模型），就像在计算机视觉中一样，在最后粘贴一些新的层并要求它预测某些东西是正面的还是负面的。
 
-#### IMDB  [[1:31:11](https://youtu.be/gbceqO8PpBg?t=1h31m11s)] 
+### IMDB  [[1:31:11](https://youtu.be/gbceqO8PpBg?t=1h31m11s)] 
 
 [笔记本](https://github.com/fastai/fastai/blob/master/courses/dl1/lesson4-imdb.ipynb)
 
@@ -521,7 +530,7 @@
 
 *   `torchtext` - PyTorch的NLP库
 
-#### 数据 [[01:37:05](https://youtu.be/gbceqO8PpBg?t=1h37m5s)] 
+### 数据 [[01:37:05](https://youtu.be/gbceqO8PpBg?t=1h37m5s)] 
 
 IMDB [大型电影评论数据集](http://ai.stanford.edu/~amaas/data/sentiment/)
 
@@ -575,7 +584,7 @@ IMDB [大型电影评论数据集](http://ai.stanford.edu/~amaas/data/sentiment/
 
 在我们可以对文本执行任何操作之前，我们必须将其转换为标记列表。 标记基本上就像一个单词。 最终我们将它们变成一个数字列表，但第一步是将它变成一个单词列表 - 这在NLP中称为“分词”。 一个好的分词器可以很好地识别句子中的碎片。 每个分隔的标点符号将被分开，并且多部分单词的每个部分将被适当地分开。 Spacy做了很多NLP的东西，它拥有Jeremy所知道的最好的分词器。 因此，Fast.ai库可以与Spacech tokenizer一起使用，就像使用torchtext一样。
 
-#### 创建一个领域 [[01:41:01](https://youtu.be/gbceqO8PpBg?t=1h41m1s)] 
+### 创建一个领域 [[01:41:01](https://youtu.be/gbceqO8PpBg?t=1h41m1s)] 
 
 字段是如何预处理某些文本的定义。
 
@@ -643,7 +652,7 @@ IMDB [大型电影评论数据集](http://ai.stanford.edu/~amaas/data/sentiment/
 
 **问题** ：处理自然语言时，上下文不重要吗？ 我们为什么要对单词进行标记和查看？  [[01:46:38](https://youtu.be/gbceqO8PpBg?t=1h46m38s)] 不，我们不是在看单个词 - 它们仍然是有序的。 仅仅因为我们用12号替换了我，他们仍然按照这个顺序。 处理称为“词袋”的自然语言有一种不同的方式，它们会丢弃秩序和背景。 在机器学习课程中，我们将学习如何使用词语表示，但我相信它们不再有用或者不再有用。 我们开始学习如何使用深度学习来正确使用上下文。
 
-#### 批量大小和BPTT  [[01:47:40](https://youtu.be/gbceqO8PpBg?t=1h47m40s)] 
+### 批量大小和BPTT  [[01:47:40](https://youtu.be/gbceqO8PpBg?t=1h47m40s)] 
 
 在语言模型中发生的事情即使我们有很多电影评论，它们都会被连接成一个大块的文本。 因此，我们预测这个巨大的长篇内容中的下一个词是所有IMDB电影评论连接在一起。
 
@@ -671,7 +680,7 @@ IMDB [大型电影评论数据集](http://ai.stanford.edu/~amaas/data/sentiment/
 
 关于这个问题，Jeremy在这个语言模型矩阵中发现了一段时间有点令人费解的东西，所以不要担心，如果需要一段时间，你必须问几千个问题。
 
-#### 创建模型 [[01:55:46](https://youtu.be/gbceqO8PpBg?t=1h55m46s)] 
+### 创建模型 [[01:55:46](https://youtu.be/gbceqO8PpBg?t=1h55m46s)] 
 
 现在我们有了一个模型数据对象可以为我们批量生产，我们可以创建一个模型。 首先，我们将创建一个嵌入矩阵。
 
@@ -719,7 +728,7 @@ Fast.ai使用由Stephen Merity开发的最先进的[AWD LSTM语言模型](https:
 
 **问题：**模型的架构是什么？  [[02:03:55](https://youtu.be/gbceqO8PpBg?t=2h3m55s)] 我们将在[上一课](https://youtu.be/gbceqO8PpBg?t=2h3m55s)中学习模型架构，但目前，它是一个使用LSTM（长期短期记忆）的反复神经网络。
 
-#### 适合 [[02:04:24](https://youtu.be/gbceqO8PpBg?t=2h4m24s)] 
+### 适合 [[02:04:24](https://youtu.be/gbceqO8PpBg?t=2h4m24s)] 
 
 ```
  learner.fit(3e-3, 4, wds=1e-6, cycle_len=1, cycle_mult=2) 
@@ -769,7 +778,7 @@ Fast.ai使用由Stephen Merity开发的最先进的[AWD LSTM语言模型](https:
  pickle.dump(TEXT, open(f' **{PATH}** models/TEXT.pkl','wb')) 
 ```
 
-#### 测试 [[02:04:53](https://youtu.be/gbceqO8PpBg?t=2h4m53s)] 
+### 测试 [[02:04:53](https://youtu.be/gbceqO8PpBg?t=2h4m53s)] 
 
 我们可以使用我们的语言模型来检查它似乎工作正常。 首先，让我们创建一小段文本来“填充”一组预测。 我们将使用我们的torchtext字段对其进行数值化，以便我们可以将其提供给我们的语言模型。
 
@@ -815,7 +824,7 @@ Fast.ai使用由Stephen Merity开发的最先进的[AWD LSTM语言模型](https:
  _film ever !_ _<eos> i saw this movie at the toronto international film festival ._ _i was very impressed ._ _i was very impressed with the acting ._ _i was very impressed with the acting ._ _i was surprised to see that the actors were not in the movie ._ _..._ 
 ```
 
-#### 情绪 [[02:05:09](https://youtu.be/gbceqO8PpBg?t=2h5m9s)] 
+### 情绪 [[02:05:09](https://youtu.be/gbceqO8PpBg?t=2h5m9s)] 
 
 所以我们预先训练了一种语言模型，现在我们想对其进行微调以进行情感分类。
 
@@ -925,7 +934,7 @@ Bradbury等人最近的一篇论文， [学习翻译：语境化词汇向量](ht
 
 有一位名叫塞巴斯蒂安·鲁德（Sebastian Ruder）的非常出色的研究员，他是唯一一位真正在NLP中进行预训练，微调和转学习的NLP研究员。 Jeremy问他为什么这不会发生更多，他的观点是因为没有软件可以让它变得简单。 希望Fast.ai会改变这一点。
 
-#### 协同过滤介绍 [[02:11:38](https://youtu.be/gbceqO8PpBg?t=2h11m38s)] 
+### 协同过滤介绍 [[02:11:38](https://youtu.be/gbceqO8PpBg?t=2h11m38s)] 
 
 [笔记本](https://github.com/fastai/fastai/blob/master/courses/dl1/lesson5-movielens.ipynb)
 

zh/dl5.md

 # 深度学习：第一部分第五课
 
-### [第5课](http://forums.fast.ai/t/wiki-lesson-5/9403)
++   [课程论坛](http://forums.fast.ai/t/wiki-lesson-5/9403)
 
-### 一，引言
+## 一，引言
 
 没有足够的关于结构化深度学习的出版物，但它肯定出现在行业中：
 
-[**结构化深度学习**](https://towardsdatascience.com/structured-deep-learning-b8ca4138b848 "https://towardsdatascience.com/structured-deep-learning-b8ca4138b848")[
-](https://towardsdatascience.com/structured-deep-learning-b8ca4138b848 "https://towardsdatascience.com/structured-deep-learning-b8ca4138b848")[_作者：Kerem Turgutlu_朝向datascience.com](https://towardsdatascience.com/structured-deep-learning-b8ca4138b848 "https://towardsdatascience.com/structured-deep-learning-b8ca4138b848")[](https://towardsdatascience.com/structured-deep-learning-b8ca4138b848)
+[结构化深度学习](https://towardsdatascience.com/structured-deep-learning-b8ca4138b848)，作者：Kerem Turgutlu @datascience.com
 
-你可以使用[此工具](https://github.com/hardikvasa/google-images-download)从Google下载图片并解决自己的问题：
+你可以使用[此工具](https://github.com/hardikvasa/google-images-download)从 Google 下载图片并解决自己的问题：
 
-[**小图像数据集的乐趣（第2部分）**](https://towardsdatascience.com/fun-with-small-image-data-sets-part-2-54d683ca8c96 "https://towardsdatascience.com/fun-with-small-image-data-sets-part-2-54d683ca8c96")[
-](https://towardsdatascience.com/fun-with-small-image-data-sets-part-2-54d683ca8c96 "https://towardsdatascience.com/fun-with-small-image-data-sets-part-2-54d683ca8c96")[_作者：Nikhil B_ towardsdatascience.com](https://towardsdatascience.com/fun-with-small-image-data-sets-part-2-54d683ca8c96 "https://towardsdatascience.com/fun-with-small-image-data-sets-part-2-54d683ca8c96")[](https://towardsdatascience.com/fun-with-small-image-data-sets-part-2-54d683ca8c96)
+[小型图像数据集的乐趣（第2部分）](https://towardsdatascience.com/fun-with-small-image-data-sets-part-2-54d683ca8c96)，作者：Nikhil B @datascience.com
 
 如何训练神经网络的介绍（一篇伟大的技术写作）：
 
-[**我们如何“训练”神经网络？**](https://towardsdatascience.com/how-do-we-train-neural-networks-edd985562b73 "https://towardsdatascience.com/how-do-we-train-neural-networks-edd985562b73")[
-](https://towardsdatascience.com/how-do-we-train-neural-networks-edd985562b73 "https://towardsdatascience.com/how-do-we-train-neural-networks-edd985562b73")[_由Vitaly Bushaev_朝向dasatcience.com](https://towardsdatascience.com/how-do-we-train-neural-networks-edd985562b73 "https://towardsdatascience.com/how-do-we-train-neural-networks-edd985562b73")[](https://towardsdatascience.com/how-do-we-train-neural-networks-edd985562b73)
+[我们如何“训练”神经网络？](https://towardsdatascience.com/how-do-we-train-neural-networks-edd985562b73)，由 Vitaly Bushaev @datascience.com
 
-学生们在[Kaggle幼苗分类比赛中](https://www.kaggle.com/c/plant-seedlings-classification/leaderboard)与Jeremy [竞争](https://www.kaggle.com/c/plant-seedlings-classification/leaderboard) 。
+学生们在 [Kaggle 幼苗分类比赛](https://www.kaggle.com/c/plant-seedlings-classification/leaderboard)中与 Jeremy 竞争。
 
-### II。 协同过滤 - 使用MovieLens数据集
+## II. 协同过滤 - 使用 MovieLens 数据集
 
-讨论的笔记本可以在[这里](https://github.com/fastai/fastai/blob/master/courses/dl1/lesson5-movielens.ipynb)找到[（lesson5-movielens.ipynb）](https://github.com/fastai/fastai/blob/master/courses/dl1/lesson5-movielens.ipynb) 。
+讨论的笔记本可以在[这里](https://github.com/fastai/fastai/blob/master/courses/dl1/lesson5-movielens.ipynb)找到（`lesson5-movielens.ipynb`）。
 
 我们来看看数据。 我们将使用`userId` （类别）， `movieId` （类别）和`rating`（因变量）进行建模。
 
 ```
- ratings = pd.read_csv(path+'ratings.csv')  ratings.head() 
+ratings = pd.read_csv(path+'ratings.csv')
+ratings.head() 
 ```
 
 ![](../img/1_p-154IwDcs32F5_betEmEw.png)
 
-#### **为Excel创建子集**
+### 为 Excel 创建子集
 
-我们创建了最受欢迎的电影和大多数电影狂热粉的交叉表，我们将其复制到Excel中进行可视化。
+我们创建了最受欢迎的电影和大多数电影狂热粉的交叉表，我们将其复制到 Excel 中进行可视化。
 
 ```
- g=ratings.groupby('userId')['rating'].count()  topUsers=g.sort_values(ascending=False)[:15] 
+g=ratings.groupby('userId')['rating'].count()  
+topUsers=g.sort_values(ascending=False)[:15] 
 ```
 
 ```
- g=ratings.groupby('movieId')['rating'].count()  topMovies=g.sort_values(ascending=False)[:15] 
+g=ratings.groupby('movieId')['rating'].count()  
+topMovies=g.sort_values(ascending=False)[:15] 
 ```
 
 ```
- top_r = ratings.join(topUsers, rsuffix='_r', how='inner', on='userId')  top_r = top_r.join(topMovies, rsuffix='_r', how='inner', on='movieId') 
+top_r = ratings.join(topUsers, rsuffix='_r', how='inner', on='userId')
+top_r = top_r.join(topMovies, rsuffix='_r', how='inner', on='movieId') 
 ```
 
 ```
- pd.crosstab(top_r.userId, top_r.movieId, top_r.rating, aggfunc=np.sum) 
+pd.crosstab(top_r.userId, top_r.movieId, top_r.rating, aggfunc=np.sum) 
 ```
 
 ![](../img/1_QO-Doqw_0YGOU-vmI-R5CA.png)
 
-[这](https://github.com/fastai/fastai/blob/master/courses/dl1/excel/collab_filter.xlsx)是包含上述信息的excel文件。 首先，我们将使用**矩阵分解**而不是构建神经网络。
+[这](https://github.com/fastai/fastai/blob/master/courses/dl1/excel/collab_filter.xlsx)是包含上述信息的 excel 文件。 首先，我们将使用矩阵分解而不构建神经网络。
 
 ![](../img/1_ps-Mq2y88JBT3JsKBh-sKQ.png)
 
@@ -69,13 +70,13 @@
 
 ![](../img/1_2SeWMcKe9VCLkVQVuCvU8g.png)
 
-然后我们使用梯度下降来减少损失。 Microsoft Excel在加载项中有一个“求解器”，可以通过更改所选单元格来最小化变量（ `GRG Nonlinear`是你要使用的方法）。
+然后我们使用梯度下降来减少损失。 Microsoft Excel 在加载项中有一个“求解器”，可以通过更改所选单元格来最小化变量（`GRG Nonlinear`是你要使用的方法）。
 
-这可称为“浅学习”（与深度学习相反），因为没有非线性层或第二线性层。 那么我们直觉上做了什么呢？ 每部电影的五个数字称为“嵌入”（潜在因式） - 第一个数字可能代表科幻和幻想的数量，第二个数字可能是电影使用了多少特效，第三个可能是如何类似地，每个用户还有5个数字，例如，表示用户喜欢幻想，特效和电影中的对话的多少。 我们的预测是这些载体的叉乘。 由于我们没有每个用户的所有电影评论，因此我们试图找出哪些电影与这部电影相似，以及其他用户评价其他电影，如何与这个用户评价这个电影类似（因此称为“协同”）。
+这可称为“浅学习”（与深度学习相反），因为没有非线性层或第二线性层。 那么我们直觉上做了什么呢？ 每部电影的五个数字称为“嵌入”（潜在因式） - 第一个数字可能代表科幻和幻想的程度，第二个数字可能是电影使用了多少特效，第三个可能是对话驱动的程度。与之类似，每个用户还有 5 个数字，例如，表示用户喜欢幻想，特效和对话驱动的电影的程度。 我们的预测是这些向量的叉乘。 由于我们没有每个用户的每个电影评论，因此我们试图找出哪些电影与这部电影相似，以及其他用户评价其他电影，如何与这个用户评价这个电影类似（因此称为“协同”）。
 
 我们如何处理新用户或新电影 - 我们是否需要重新训练模型？ 我们现在没有时间来讨论这个问题，但基本上你需要有一个新的用户模型或最初会使用的新电影模型，随着时间的推移你需要重新训练模型。
 
-#### **简单的Python版本[** [**26:03**](https://youtu.be/J99NV9Cr75I%3Ft%3D26m3s) **]**
+### **简单的Python版本[** [**26:03**](https://youtu.be/J99NV9Cr75I%3Ft%3D26m3s) **]**
 
 这应该看起来很熟悉了。 我们通过选择随机ID集来创建验证集。 `wd`是L2正则化的权重衰减， `n_factors`是我们想要的嵌入矩阵有多大。
 
@@ -127,7 +128,7 @@
 
 ![](../img/1_cXAU8huHFkxKbJjZUwwxIA.png)
 
-#### **使用Python的点乘**
+### **使用Python的点乘**
 
 ![](../img/1_kSUYsjtdLbyn2SqW9cKiHA.jpeg)
 
@@ -149,7 +150,7 @@
  6  70  [torch.FloatTensor of size 2] 
 ```
 
-#### **构建我们的第一个自定义层（即 PyTorch 模块）[** [**33:55**](https://youtu.be/J99NV9Cr75I%3Ft%3D33m55s) **]**
+### **构建我们的第一个自定义层（即 PyTorch 模块）[** [**33:55**](https://youtu.be/J99NV9Cr75I%3Ft%3D33m55s) **]**
 
 我们通过创建一个扩展`nn.Module`并覆盖`forward`函数的 Python 类来实现它。
 
@@ -167,7 +168,7 @@
  6  70  [torch.FloatTensor of size 2] 
 ```
 
-#### **建造更复杂的模块[** [**41:31**](https://youtu.be/J99NV9Cr75I%3Ft%3D41m31s) **]**
+### **建造更复杂的模块[** [**41:31**](https://youtu.be/J99NV9Cr75I%3Ft%3D41m31s) **]**
 
 这个实现有两个`DotProduct`类的补充：
 
@@ -216,7 +217,7 @@ _提示：_ `{o:i for i,o in enumerate(u_uniq)}`是一个方便的代码行保
 
 这个函数来自fast.ai库 [[54:40](https://youtu.be/J99NV9Cr75I%3Ft%3D54m40s)] 并且比我们一直在使用的`learner.fit()`更接近常规的PyTorch方法。 它不会为你提供诸如“重启的随机梯度下降”或开箱即用的“差分学习率”等功能。
 
-#### **让我们改进我们的模型**
+### **让我们改进我们的模型**
 
 **偏见** - 适应普遍流行的电影或普遍热情的用户。
 
@@ -250,7 +251,7 @@ _提示：_ `{o:i for i,o in enumerate(u_uniq)}`是一个方便的代码行保
 
 让我们来看看我们在**Simple Python版本中**使用的fast.ai代码 [[1:13:44](https://youtu.be/J99NV9Cr75I%3Ft%3D1h13m44s)]  **。** 在`column_data.py`文件中， `CollabFilterDataSet.get_leaner`调用`get_model`函数，该函数创建与我们创建的相同的`EmbeddingDotBias`类。
 
-#### 神经网络版 [[1:17:21](https://youtu.be/J99NV9Cr75I%3Ft%3D1h17m21s)] 
+### 神经网络版 [[1:17:21](https://youtu.be/J99NV9Cr75I%3Ft%3D1h17m21s)] 
 
 我们回到excel表来理解直觉。 请注意，我们创建user_idx以查找嵌入，就像我们之前在python代码中所做的那样。 如果我们对user_idx进行单热编码并将其乘以用户嵌入，我们将为用户获取适用的行。 如果它只是矩阵乘法，为什么我们需要嵌入？ 它用于计算表现优化目的。
 
@@ -290,7 +291,7 @@ _提示：_ `{o:i for i,o in enumerate(u_uniq)}`是一个方便的代码行保
 *   增加/减少隐藏层数和激活次数
 *   增加/减少正规化
 
-#### **训练循环中发生了什么？**  [[1:33:21](https://youtu.be/J99NV9Cr75I%3Ft%3D1h33m21s)] 
+### **训练循环中发生了什么？**  [[1:33:21](https://youtu.be/J99NV9Cr75I%3Ft%3D1h33m21s)] 
 
 目前，我们正在将权重更新传递给PyTorch的优化器。 优化器有什么作用？ 什么是`momentum` ？
 
@@ -314,7 +315,7 @@ _提示：_ `{o:i for i,o in enumerate(u_uniq)}`是一个方便的代码行保
 
 有限差分在高维空间中变得复杂 [[1:41:46](https://youtu.be/J99NV9Cr75I%3Ft%3D1h41m46s)] ，并且它变得非常耗费内存并且需要很长时间。 所以我们想找到一些方法来更快地完成这项工作。 查找Jacobian和Hessian之类的东西是值得的（深度学习书： [第84页第4.3.1节](http://www.deeplearningbook.org/contents/numerical.html) ）。
 
-#### 链规则和反向传播
+### 链规则和反向传播
 
 更快的方法是分析地做到这一点 [[1:45:27](https://youtu.be/J99NV9Cr75I%3Ft%3D1h45m27s)] 。 为此，我们需要一个链规则：
 
@@ -334,7 +335,7 @@ _提示：_ `{o:i for i,o in enumerate(u_uniq)}`是一个方便的代码行保
 
 这就是你如何使用excel表格进行SGD。 如果你要使用CNN电子表格的输出更改预测值，我们可以使用SGD训练CNN。
 
-#### 动量 [[1:53:47](https://youtu.be/J99NV9Cr75I%3Ft%3D1h53m47s)] 
+### 动量 [[1:53:47](https://youtu.be/J99NV9Cr75I%3Ft%3D1h53m47s)] 
 
 > 来吧，采取一些暗示 - 这是一个很好的方向。 请继续这样做，但更多。
 
@@ -344,7 +345,7 @@ _提示：_ `{o:i for i,o in enumerate(u_uniq)}`是一个方便的代码行保
 
 与其符号（+/-）是随机的_de_ / _db_相比，具有动量的那个将继续向同一方向移动一点点直到某一点。 这将减少训练所需的一些时期。
 
-####  Adam  [[1:59:04](https://youtu.be/J99NV9Cr75I%3Ft%3D1h59m4s)] 
+###  Adam  [[1:59:04](https://youtu.be/J99NV9Cr75I%3Ft%3D1h59m4s)] 
 
  Adam 的速度要快得多，但问题在于最终的预测并不像SGD那样有动力。 似乎这是由于 Adam 和权重衰减的联合使用。 解决此问题的新版本称为**AdamW** 。
 
@@ -364,7 +365,7 @@ _提示：_ `{o:i for i,o in enumerate(u_uniq)}`是一个方便的代码行保
 
 另一个有用的概念是每当你看到`α（...）+（1-α）（...）`时，立即想到**线性插值。**
 
-#### **一些直觉**
+### **一些直觉**
 
 *   我们计算了梯度平方的指数加权移动平均值，取其平方根，并将学习率除以它。
 *   渐变平方总是积极的。
@@ -375,7 +376,7 @@ _提示：_ `{o:i for i,o in enumerate(u_uniq)}`是一个方便的代码行保
 *   **自适应学习率** - 跟踪梯度平方的平均值，并使用它来调整学习率。 因此，只有一种学习风格，但如果梯度是恒定的，每个时期的每个参数都会得到更大的跳跃; 否则会跳得更小。
 *   有两个瞬间 - 一个用于渐变，另一个用于渐变平方（在PyTorch中，它被称为beta，它是两个数字的元组）
 
-#### AdamW  [[2:11:18](https://youtu.be/J99NV9Cr75I%3Ft%3D2h11m18s)] 
+### AdamW  [[2:11:18](https://youtu.be/J99NV9Cr75I%3Ft%3D2h11m18s)] 
 
 当参数多于数据点时，正则化变得很重要。 我们以前见过 Dropout ，权重衰退是另一种正规化。 权重衰减（L2正则化）通过将平方权重（权重衰减乘数乘以）加到损失中来惩罚大权重。 现在损失函数想要保持较小的权重，因为增加权重会增加损失; 因此，只有当损失提高超过罚款时才这样做。