revise till cnn

STYLE_GUIDE.md

@@ -15,6 +15,8 @@
     * 使用中文双引号
 * 符号描述
     * 时刻t（不是t时刻）
+	* 形状使用中文标点
+		*（10，20）不是(10, 20)
 * 人称
     * 第一人称 → 我们
     * 第二人称 → 你、大家
@@ -100,6 +102,8 @@
 * Python规范一致
     * PEP8
         * 二元操作符换行：操作符和后一元一起换行 (https://www.python.org/dev/peps/pep-0008/#should-a-line-break-before-or-after-a-binary-operator)
+* 将相邻赋值语句尽可能合并为同一行
+	* 如 num_epochs, lr = 5, 0.1
 * 变量名一致
     * num_epochs
         * 迭代周期

chapter_convolutional-neural-networks/alexnet.md

@@ -56,16 +56,16 @@ AlextNet与LeNet的设计理念非常相似。但也有显著的区别。
 import sys
 sys.path.insert(0, '..')
 
-import os
-import sys
 import gluonbook as gb
-from mxnet import nd, init, gluon
+from mxnet import gluon, init, nd
 from mxnet.gluon import data as gdata, nn
+import os
+import sys
 
 net = nn.Sequential()
-net.add(  # 使用较大的 11 x 11 窗口来捕获物体。同时使用步幅 4 来较大减小输出高宽。
-        # 这里使用的输入通道数比 LeNet 也要大很多。
-        nn.Conv2D(96, kernel_size=11, strides=4, activation='relu'),
+# 使用较大的 11 x 11 窗口来捕获物体。同时使用步幅 4 来较大减小输出高宽。
+# 这里使用的输入通道数比 LeNet 也要大很多。
+net.add(nn.Conv2D(96, kernel_size=11, strides=4, activation='relu'),
         nn.MaxPool2D(pool_size=3, strides=2),
         # 减小卷积窗口，使用填充为 2 来使得输入输出高宽一致，且增大输出通道数。
         nn.Conv2D(256, kernel_size=5, padding=2, activation='relu'),

chapter_convolutional-neural-networks/batch-norm.md

@@ -61,7 +61,7 @@ import sys
 sys.path.insert(0, '..')
 
 import gluonbook as gb
-from mxnet import nd, gluon, init, autograd
+from mxnet import autograd, gluon, init, nd
 from mxnet.gluon import nn
 
 def batch_norm(X, gamma, beta, moving_mean, moving_var, eps, momentum):    

chapter_convolutional-neural-networks/conv-layer.md

@@ -97,12 +97,12 @@ Y
 虽然我们之前构造了`Conv2D`类，但由于`corr2d`使用了对单个元素赋值（`[i, j]=`）的操作从而无法自动求导。下面我们使用Gluon提供的`Conv2D`类来实现这个例子。
 
 ```{.python .input  n=83}
-# 构造一个输出通道是 1（将在后面小节介绍通道），核数组形状是 (1，2) 的二维卷积层。
+# 构造一个输出通道是 1（将在后面小节介绍通道），核数组形状是（1，2）的二维卷积层。
 conv2d = nn.Conv2D(1, kernel_size=(1, 2))
 conv2d.initialize()
 
-# 二维卷积层使用 4 维输入输出，格式为（样本，通道，高，宽），这里批量大小（批量中的样本数）和通道
-# 数均为 1。
+# 二维卷积层使用 4 维输入输出，格式为（样本，通道，高，宽），这里批量大小（批量中的样本数）
+# 和通道数均为 1。
 X = X.reshape((1, 1, 6, 8))
 Y = Y.reshape((1, 1, 6, 7))
 

chapter_convolutional-neural-networks/densenet.md

@@ -18,7 +18,7 @@ import sys
 sys.path.insert(0, '..')
 
 import gluonbook as gb
-from mxnet import nd, gluon, init
+from mxnet import gluon, init, nd
 from mxnet.gluon import nn
 
 def conv_block(num_channels):
@@ -92,8 +92,7 @@ net.add(nn.Conv2D(64, kernel_size=7, strides=2, padding=3),
 ResNet里通过步幅为2的残差块在每个模块之间减小高和宽。这里我们则使用过渡层来减半高和宽，并减半通道数。
 
 ```{.python .input  n=5}
-num_channels = 64  # 当前的数据通道数。
-growth_rate = 32
+num_channels, growth_rate = 64, 32  # num_channels：当前的数据通道数。
 num_convs_in_dense_blocks = [4, 4, 4, 4]
 
 for i, num_convs in enumerate(num_convs_in_dense_blocks):

chapter_convolutional-neural-networks/googlenet.md

@@ -18,7 +18,7 @@ import sys
 sys.path.insert(0, '..')
 
 import gluonbook as gb
-from mxnet import nd, init, gluon
+from mxnet import gluon, init, nd
 from mxnet.gluon import nn
 
 class Inception(nn.Block):

chapter_convolutional-neural-networks/lenet.md

@@ -25,7 +25,7 @@ sys.path.insert(0, '..')
 
 import gluonbook as gb
 import mxnet as mx
-from mxnet import autograd, nd, gluon, init
+from mxnet import autograd, gluon, init, nd 
 from mxnet.gluon import loss as gloss, nn
 import time
 
@@ -66,7 +66,7 @@ train_iter, test_iter = gb.load_data_fashion_mnist(batch_size=batch_size)
 因为卷积神经网络计算比多层感知机要复杂，建议使用GPU来加速计算。我们尝试在GPU 0上创建NDArray，如果成功则使用GPU 0，否则仍然使用CPU。
 
 ```{.python .input}
-def try_gpu():  # try_gluon 已保存在 gluonbook 包中方便以后使用。
+def try_gpu():  # 本函数已保存在 gluonbook 包中方便以后使用。
     try:
         ctx = mx.gpu()
         _ = nd.zeros((1,), ctx=ctx)
@@ -81,7 +81,7 @@ ctx
 相应地，我们对[“Softmax回归的从零开始实现”](../chapter_deep-learning-basics/softmax-regression-scratch.md)一节中描述的`evaluate_accuracy`函数略作修改。由于数据刚开始存在CPU的内存上，当`ctx`变量为GPU时，我们通过[“GPU计算”](../chapter_deep-learning-computation/use-gpu.md)一节中介绍的`as_in_context`函数将数据复制到GPU上（例如GPU 0）。
 
 ```{.python .input}
-# 本函数以保存在 gluonbook 包中方便以后使用。该函数将被逐步改进：它的完整实现将在“图像增
+# 本函数已保存在 gluonbook 包中方便以后使用。该函数将被逐步改进：它的完整实现将在“图像增
 # 广”一节中描述。
 def evaluate_accuracy(data_iter, net, ctx):
     acc = nd.array([0], ctx=ctx)

chapter_convolutional-neural-networks/nin.md

@@ -16,7 +16,7 @@ import sys
 sys.path.insert(0, '..')
 
 import gluonbook as gb
-from mxnet import nd, gluon, init
+from mxnet import gluon, init, nd
 from mxnet.gluon import nn
 
 def nin_block(num_channels, kernel_size, strides, padding):

chapter_convolutional-neural-networks/resnet.md

@@ -18,7 +18,7 @@ import sys
 sys.path.insert(0, '..')
 
 import gluonbook as gb
-from mxnet import nd, gluon, init
+from mxnet import gluon, init, nd
 from mxnet.gluon import nn
 
 class Residual(nn.Block):  # 本类已保存在 gluonbook 包中方便以后使用。

chapter_convolutional-neural-networks/vgg.md

@@ -13,7 +13,7 @@ import sys
 sys.path.insert(0, '..')
 
 import gluonbook as gb
-from mxnet import nd, init, gluon
+from mxnet import gluon, init, nd
 from mxnet.gluon import nn
 
 def vgg_block(num_convs, num_channels):

chapter_deep-learning-basics/dropout.md

@@ -35,8 +35,8 @@ import sys
 sys.path.insert(0, '..')
 
 import gluonbook as gb
-from mxnet import autograd, nd, gluon, init
-from mxnet.gluon import nn, loss as gloss
+from mxnet import autograd, gluon, init, nd
+from mxnet.gluon import loss as gloss, nn
 
 def dropout(X, drop_prob):
     assert 0 <= drop_prob <= 1

chapter_deep-learning-basics/kaggle-house-price.md

@@ -32,7 +32,7 @@ sys.path.insert(0, '..')
 
 %matplotlib inline
 import gluonbook as gb
-from mxnet import autograd, init, gluon, nd
+from mxnet import autograd, gluon, init, nd
 from mxnet.gluon import data as gdata, loss as gloss, nn
 import numpy as np
 import pandas as pd

chapter_deep-learning-basics/linear-regression-scratch.md

@@ -6,10 +6,10 @@
 
 ```{.python .input  n=1}
 %matplotlib inline
-import random
-from matplotlib import pyplot as plt
 from IPython import display
+from matplotlib import pyplot as plt
 from mxnet import autograd, nd
+import random
 ```
 
 ## 生成数据集

chapter_deep-learning-basics/mlp-scratch.md

@@ -3,10 +3,10 @@
 我们已经从上一章里了解了多层感知机的原理。下面，我们一起来动手实现一个多层感知机。首先导入实现所需的包或模块。
 
 ```{.python .input  n=9}
-%matplotlib inline
 import sys
 sys.path.insert(0, '..')
 
+%matplotlib inline
 import gluonbook as gb
 from mxnet import nd
 from mxnet.gluon import loss as gloss

chapter_deep-learning-basics/weight-decay.md

@@ -38,7 +38,7 @@ sys.path.insert(0, '..')
 
 %matplotlib inline
 import gluonbook as gb
-from mxnet import autograd, gluon, nd, init
+from mxnet import autograd, gluon, init, nd
 from mxnet.gluon import data as gdata, loss as gloss, nn
 
 n_train, n_test, num_inputs,  = 20, 100, 200

chapter_deep-learning-computation/custom-layer.md

@@ -10,7 +10,7 @@
 首先，导入本节中实验需要的包或模块。
 
 ```{.python .input}
-from mxnet import nd, gluon
+from mxnet import gluon, nd
 from mxnet.gluon import nn
 ```
 

chapter_deep-learning-computation/deferred-init.md

@@ -4,7 +4,7 @@
 
 ## 延后的初始化
 
-注意到前面使用Gluon的章节里，我们在创建全连接层时都没有指定输入大小。例如在一直使用的多层感知机例子里，我们创建了输出大小为256的隐藏层。但是当在调用`initialize`函数的时候，我们并不知道这个层的参数到底有多大，因为它的输入大小仍然是未知。只有在当我们将形状是`(2,20)`的`x`输入进网络时，我们这时候才知道这一层的参数大小应该是`(256,20)`。所以这个时候我们才能真正开始初始化参数。
+注意到前面使用Gluon的章节里，我们在创建全连接层时都没有指定输入大小。例如在一直使用的多层感知机例子里，我们创建了输出大小为256的隐藏层。但是当在调用`initialize`函数的时候，我们并不知道这个层的参数到底有多大，因为它的输入大小仍然是未知。只有在当我们将形状是`（2，20）`的`x`输入进网络时，我们这时候才知道这一层的参数大小应该是`（256，20）`。所以这个时候我们才能真正开始初始化参数。
 
 让我们使用上节定义的MyInit类来清楚地演示这一个过程。下面我们创建多层感知机，然后使用MyInit实例来进行初始化。
 

chapter_deep-learning-computation/parameters.md

@@ -25,7 +25,7 @@ y = net(x)
 net[0].params
 ```
 
-可以看到我们得到了一个由参数名称映射到参数实例的字典。第一个参数的名称为`dense0_weight`，它由`net[0]`的名称（`dense0_`）和自己的变量名（`weight`）组成。而且可以看到它参数的形状为`(256, 20)`，且数据类型为32位浮点数。
+可以看到我们得到了一个由参数名称映射到参数实例的字典。第一个参数的名称为`dense0_weight`，它由`net[0]`的名称（`dense0_`）和自己的变量名（`weight`）组成。而且可以看到它参数的形状为`（256，20）`，且数据类型为32位浮点数。
 
 为了访问特定参数，我们既可以通过名字来访问字典里的元素，也可以直接使用它的变量名。下面两种方法是等价的，但通常后者的代码可读性更好。
 
@@ -68,7 +68,6 @@ net.collect_params('.*weight')
 
 当使用默认的模型初始化，Gluon会将权重参数元素初始化为[-0.07, 0.07]（一个之前流行的初始化区间）之间均匀分布的随机数，偏差参数则全为0。但我们经常需要使用其他的方法来初始化权重，MXNet的`init`模块里提供了多种预设的初始化方法。例如下面例子我们将权重参数初始化成均值为0，标准差为0.01的正态分布随机数。
 
-
 ```{.python .input  n=7}
 # 非首次对模型初始化需要指定 force_reinit。
 net.initialize(init=init.Normal(sigma=0.01), force_reinit=True)