update

Author: L1aoXingyu

README.md

@@ -1,4 +1,4 @@
-## 深度学习入门之PyTorch 
+# 深度学习入门之PyTorch 
 
 Learn Deep Learning with PyTorch
 
@@ -31,14 +31,15 @@ Learn Deep Learning with PyTorch
 
 - Chapter 4: 卷积神经网络
     - [PyTorch 中的卷积模块](https://github.com/SherlockLiao/code-of-learn-deep-learning-with-pytorch/blob/master/chapter4_CNN/basic_conv.ipynb)
-    - [批标准化，batch normalization](https://github.com/SherlockLiao/code-of-learn-deep-learning-with-pytorch/blob/master/chapter4_CNN/batch-normalization.ipynb))
+    - [批标准化，batch normalization](https://github.com/SherlockLiao/code-of-learn-deep-learning-with-pytorch/blob/master/chapter4_CNN/batch-normalization.ipynb)
     - [使用重复元素的深度网络，VGG](https://github.com/SherlockLiao/code-of-learn-deep-learning-with-pytorch/blob/master/chapter3_CNN/vgg.ipynb)
     - [更加丰富化结构的网络，GoogLeNet](https://github.com/SherlockLiao/code-of-learn-deep-learning-with-pytorch/blob/master/chapter3_CNN/googlenet.ipynb)
     - [深度残差网络，ResNet](https://github.com/SherlockLiao/code-of-learn-deep-learning-with-pytorch/blob/master/chapter3_CNN/resnet.ipynb)
     - [稠密连接的卷积网络，DenseNet](https://github.com/SherlockLiao/code-of-learn-deep-learning-with-pytorch/blob/master/chapter3_CNN/densenet.ipynb)
     - 更好的训练卷积网络
         - [数据增强](https://github.com/SherlockLiao/code-of-learn-deep-learning-with-pytorch/blob/master/chapter3_CNN/data-augumentation.ipynb)
-        - dropout、正则化方法和学习率衰减]()
+        - [正则化](https://github.com/SherlockLiao/code-of-learn-deep-learning-with-pytorch/blob/master/chapter3_CNN/regularization.ipynb)
+        - [学习率衰减](https://github.com/SherlockLiao/code-of-learn-deep-learning-with-pytorch/blob/master/chapter3_CNN/lr-decay.ipynb)
 
 - Chapter 5: 循环神经网络
     - LSTM 和 GRU
@@ -54,15 +55,15 @@ Learn Deep Learning with PyTorch
     - 深度卷积对抗网络(DCGANs)
 
 - Chapter 7: PyTorch高级
-    - tensorboard 可视化
+    - [tensorboard 可视化]()
     - 优化算法
         - [SGD](https://github.com/SherlockLiao/code-of-learn-deep-learning-with-pytorch/blob/master/chapter6_PyTorch-Advances/optimizer/sgd.ipynb)
         - [动量法](https://github.com/SherlockLiao/code-of-learn-deep-learning-with-pytorch/blob/master/chapter6_PyTorch-Advances/optimizer/momentum.ipynb)
         - [Adagrad](https://github.com/SherlockLiao/code-of-learn-deep-learning-with-pytorch/blob/master/chapter6_PyTorch-Advances/optimizer/adagrad.ipynb)
         - [RMSProp](https://github.com/SherlockLiao/code-of-learn-deep-learning-with-pytorch/blob/master/chapter6_PyTorch-Advances/optimizer/rmsprop.ipynb)
         - [Adadelta](https://github.com/SherlockLiao/code-of-learn-deep-learning-with-pytorch/blob/master/chapter6_PyTorch-Advances/optimizer/adadelta.ipynb)
         - [Adam](https://github.com/SherlockLiao/code-of-learn-deep-learning-with-pytorch/blob/master/chapter6_PyTorch-Advances/optimizer/adam.ipynb)
-    - 灵活的数据读取介绍
+    - [灵活的数据读取介绍]()
     - autograd.function 的介绍
     - 数据并行和多 GPU
     - PyTorch 的分布式应用

chapter3_NN/deep-nn.ipynb

@@ -112,13 +112,6 @@
     "a_label"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "这里的读入的数据是 PIL 库中的格式，我们可以非常方便地将其转换为 numpy array"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 6,
@@ -220,15 +213,6 @@
     "print(a_data)"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "我们可以将数组展示出来，里面的 0 就表示黑色，255 表示白色\n",
-    "\n",
-    "对于神经网络，我们第一层的输入就是 28 x 28 = 784，所以必须将得到的数据我们做一个变换，使用 reshape 将他们拉平成一个一维向量"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 8,
@@ -284,13 +268,6 @@
     "test_data = DataLoader(test_set, batch_size=128, shuffle=False)"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "使用这样的数据迭代器是非常有必要的，如果数据量太大，就无法一次将他们全部读入内存，所以需要使用 python 迭代器，每次生成一个批次的数据"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 11,
@@ -374,13 +351,6 @@
     "net"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "交叉熵在 pytorch 中已经内置了，交叉熵的数值稳定性更差，所以内置的函数已经帮我们解决了这个问题"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 28,

chapter3_NN/logistic-regression/logistic-regression.ipynb

@@ -503,13 +503,6 @@
     "print()\n",
     "print('During Time: {:.3f} s'.format(during))"
    ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "可以看到，使用了 PyTorch 自带的 loss 之后，速度有了一定的上升，虽然看上去速度的提升并不多，但是这只是一个小网络，对于大网络，使用自带的 loss 不管对于稳定性还是速度而言，都有质的飞跃，同时也避免了重复造轮子的困扰"
-   ]
   }
  ],
  "metadata": {

chapter3_NN/nn-sequential-module.ipynb

@@ -4,10 +4,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# 多层神经网络，Sequential 和 Module\n",
-    "通过前面的章节，我们了解到了机器学习领域中最常见的两个模型，线性回归模型和 Logistic 回归模型，他们分别是处理机器学习中最常见的两类问题-回归问题和分类问题。\n",
-    "\n",
-    "下面我们会讲第一个深度学习的模型，多层神经网络。"
+    "# 多层神经网络，Sequential 和 Module"
    ]
   },
   {
@@ -232,13 +229,6 @@
     "plt.title('logistic regression')"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "可以看到，logistic 回归并不能很好的区分开这个复杂的数据集，如果你还记得前面的内容，你就知道 logistic 回归是一个线性分类器，这个时候就该我们的神经网络登场了！"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 43,
@@ -360,24 +350,6 @@
     "## Sequential 和 Module"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "我们讲了数据处理，模型构建，loss 函数设计等等内容，但是目前为止我们还没有准备好构建一个完整的机器学习系统，一个完整的机器学习系统需要我们不断地读写模型。在现实应用中，一般我们会将模型在本地进行训练，然后保存模型，接着我们会将模型部署到不同的地方进行应用，所以在这节课我们会教大家如何保存 PyTorch 的模型。\n",
-    "\n",
-    "首先我们会讲一下 PyTorch 中的模块，Sequential 和 Module。"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "对于前面的线性回归模型、 Logistic回归模型和神经网络，我们在构建的时候定义了需要的参数。这对于比较小的模型是可行的，但是对于大的模型，比如100 层的神经网络，这个时候再去手动定义参数就显得非常麻烦，所以 PyTorch 提供了两个模块来帮助我们构建模型，一个是Sequential，一个是 Module。\n",
-    "\n",
-    "Sequential 允许我们构建序列化的模块，而 Module 是一种更加灵活的模型定义方式，我们下面分别用 Sequential 和 Module 来定义上面的神经网络。"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 73,
@@ -497,13 +469,6 @@
     "        print('epoch: {}, loss: {}'.format(e+1, loss.data[0]))"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "可以看到，训练 10000 次 loss 比之前的更低，这是因为 PyTorch 自带的模块比我们写的更加稳定，同时也有一些初始化的问题在里面，关于参数初始化，我们会在后面的课程中讲到"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 80,
@@ -558,35 +523,6 @@
     "\n"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "下面我们再用 Module 定义这个模型，下面是使用 Module 的模板\n",
-    "\n",
-    "```\n",
-    "class 网络名字(nn.Module):\n",
-    "    def __init__(self, 一些定义的参数):\n",
-    "        super(网络名字, self).__init__()\n",
-    "        self.layer1 = nn.Linear(num_input, num_hidden)\n",
-    "        self.layer2 = nn.Sequential(...)\n",
-    "        ...\n",
-    "        \n",
-    "        定义需要用的网络层\n",
-    "        \n",
-    "    def forward(self, x): # 定义前向传播\n",
-    "        x1 = self.layer1(x)\n",
-    "        x2 = self.layer2(x)\n",
-    "        x = x1 + x2\n",
-    "        ...\n",
-    "        return x\n",
-    "```\n",
-    "\n",
-    "注意的是，Module 里面也可以使用 Sequential，同时 Module 非常灵活，具体体现在 forward 中，如何复杂的操作都能直观的在 forward 里面执行\n",
-    "\n",
-    "下面我们照着模板实现一下上面的神经网络"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 84,
@@ -718,13 +654,6 @@
     "    if (e + 1) % 1000 == 0:\n",
     "        print('epoch: {}, loss: {}'.format(e+1, loss.data[0]))"
    ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "可以看到我们得到了相同的结果，而且使用 Sequential 和 Module 来定义模型更加方便"
-   ]
   }
  ],
  "metadata": {

chapter3_NN/param_initialize.ipynb

@@ -11,8 +11,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## 使用 NumPy 来初始化\n",
-    "因为 PyTorch 是一个非常灵活的框架，理论上能够对所有的 Tensor 进行操作，所以我们能够通过定义新的 Tensor 来初始化，直接看下面的例子"
+    "## 使用 NumPy 来初始化"
    ]
   },
   {
@@ -87,13 +86,6 @@
     "print(w1)"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "注意，这是一个 Parameter，也就是一个特殊的 Variable，我们可以访问其 `.data`属性得到其中的数据，然后直接定义一个新的 Tensor 对其进行替换，我们可以使用 PyTorch 中的一些随机数据生成的方式，比如 `torch.randn`，如果要使用更多 PyTorch 中没有的随机化方式，可以使用 numpy"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 16,
@@ -134,13 +126,6 @@
     "print(net1[0].weight)"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "可以看到这个参数的值已经被改变了，也就是说已经被定义成了我们需要的初始化方式，如果模型中某一层需要我们手动去修改，那么我们可以直接用这种方式去访问，但是更多的时候是模型中相同类型的层都需要初始化成相同的方式，这个时候一种更高效的方式是使用循环去访问，比如"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 18,
@@ -156,13 +141,6 @@
     "        # 定义为均值为 0，方差为 0.5 的正态分布"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "对于 Module 的参数初始化，其实也非常简单，如果想对其中的某层进行初始化，可以直接像 Sequential 一样对其 Tensor 进行重新定义，其唯一不同的地方在于，如果要用循环的方式访问，需要介绍两个属性，children 和 modules，下面我们举例来说明"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 28,
@@ -293,15 +271,6 @@
     "    print(i)"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "通过上面的例子，看到区别了吗?\n",
-    "\n",
-    "children 只会访问到模型定义中的第一层，因为上面的模型中定义了三个 Sequential，所以只会访问到三个 Sequential，而 modules 会访问到最后的结构，比如上面的例子，modules 不仅访问到了 Sequential，也访问到了 Sequential 里面，这就对我们做初始化非常方便，比如"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 33,
@@ -320,15 +289,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "这上面实现了和 Sequential 相同的初始化，同样非常简便"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## torch.nn.init\n",
-    "因为 PyTorch 灵活的特性，我们可以直接对 Tensor 进行操作从而初始化，PyTorch 也提供了初始化的函数帮助我们快速初始化，就是 `torch.nn.init`，其操作层面仍然在 Tensor 上，下面我们举例说明"
+    "## torch.nn.init"
    ]
   },
   {
@@ -397,7 +358,7 @@
     }
    ],
    "source": [
-    "init.xavier_uniform(net1[0].weight) # 这就是上面我们讲过的 Xavier 初始化方法，PyTorch 直接内置了其实现"
+    "init.xavier_uniform(net1[0].weight)"
    ]
   },
   {
@@ -427,22 +388,6 @@
    "source": [
     "print(net1[0].weight)"
    ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "可以看到参数已经被修改了\n",
-    "\n",
-    "`torch.nn.init` 为我们提供了更多的内置初始化方式，避免了我们重复去实现一些相同的操作"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "上面讲了两种初始化方式，其实它们的本质都是一样的，就是去修改某一层参数的实际值，而 `torch.nn.init` 提供了更多成熟的深度学习相关的初始化方式，非常方便"
-   ]
   }
  ],
  "metadata": {