Revert "ruler 79 fix"

This reverts commit 6de4b4b.

Author: astonzhang

chapter_computer-vision/fcn.md

@@ -178,8 +178,8 @@ test_iter = gdata.DataLoader(
 ctx = d2l.try_all_gpus()
 loss = gloss.SoftmaxCrossEntropyLoss(axis=1)
 net.collect_params().reset_ctx(ctx)
-trainer = gluon.Trainer(net.collect_params(), 'sgd',
-                        {'learning_rate': 0.1, 'wd': 1e-3})
+trainer = gluon.Trainer(net.collect_params(), 'sgd', {'learning_rate': 0.1,
+                                                      'wd': 1e-3})
 d2l.train(train_iter, test_iter, net, loss, trainer, ctx, num_epochs=5)
 ```
 

chapter_computer-vision/fine-tuning.md

@@ -175,6 +175,8 @@ hotdog_w = nd.split(weight.data(), 1000, axis=0)[713]
 hotdog_w.shape
 ```
 
+
+
 ## 参考文献
 
 [1] GluonCV工具包。https://gluon-cv.mxnet.io/

chapter_computer-vision/kaggle-gluon-cifar10.md

@@ -143,8 +143,8 @@ reorg_cifar10_data(data_dir, label_file, train_dir, test_dir, input_dir,
 transform_train = gdata.vision.transforms.Compose([
     # 将图像放大成高和宽各为40像素的正方形
     gdata.vision.transforms.Resize(40),
-    # 随机对高和宽各为40像素的正方形图像裁剪出面积为原图像面积0.64~1倍的小正方形，再放缩为高
-    # 和宽各为32像素的正方形
+    # 随机对高和宽各为40像素的正方形图像裁剪出面积为原图像面积0.64~1倍的小正方形，再放缩为
+    # 高和宽各为32像素的正方形
     gdata.vision.transforms.RandomResizedCrop(32, scale=(0.64, 1.0),
                                               ratio=(1.0, 1.0)),
     gdata.vision.transforms.RandomFlipLeftRight(),

chapter_computer-vision/neural-style.md

@@ -147,8 +147,8 @@ $$\sum_{i,j} \left|x_{i,j} - x_{i+1,j}\right| + \left|x_{i,j} - x_{i,j+1}\right|
 
 ```{.python .input  n=13}
 def tv_loss(Y_hat):
-    return 0.5 * ((Y_hat[:, :, 1:, :] - Y_hat[:, :, :-1, :]).abs().mean()
-                  + (Y_hat[:, :, :, 1:] - Y_hat[:, :, :, :-1]).abs().mean())
+    return 0.5 * ((Y_hat[:, :, 1:, :] - Y_hat[:, :, :-1, :]).abs().mean() +
+                  (Y_hat[:, :, :, 1:] - Y_hat[:, :, :, :-1]).abs().mean())
 ```
 
 ### 损失函数

chapter_computer-vision/ssd.md

@@ -28,7 +28,8 @@ from mxnet.gluon import loss as gloss, nn
 import time
 
 def cls_predictor(num_anchors, num_classes):
-    return nn.Conv2D(num_anchors * (num_classes + 1), kernel_size=3, padding=1)
+    return nn.Conv2D(num_anchors * (num_classes + 1), kernel_size=3,
+                     padding=1)
 ```
 
 ### 边界框预测层
@@ -152,8 +153,8 @@ class TinySSD(nn.Block):
         for i in range(5):
             # 即赋值语句self.blk_i = get_blk(i)
             setattr(self, 'blk_%d' % i, get_blk(i))
-            setattr(self, 'cls_%d' % i,
-                    cls_predictor(num_anchors, num_classes))
+            setattr(self, 'cls_%d' % i, cls_predictor(num_anchors,
+                                                      num_classes))
             setattr(self, 'bbox_%d' % i, bbox_predictor(num_anchors))
 
     def forward(self, X):
@@ -258,8 +259,8 @@ for epoch in range(20):
         m += bbox_labels.size
 
     if (epoch + 1) % 5 == 0:
-        print('epoch %2d, class err %.2e, bbox mae %.2e, time %.1f sec'
-              % (epoch + 1, 1 - acc_sum / n, mae_sum / m, time.time() - start))
+        print('epoch %2d, class err %.2e, bbox mae %.2e, time %.1f sec' % (
+            epoch + 1, 1 - acc_sum / n, mae_sum / m, time.time() - start))
 ```
 
 ## 预测

chapter_deep-learning-basics/dropout.md

@@ -33,7 +33,8 @@ from mxnet.gluon import loss as gloss, nn
 def dropout(X, drop_prob):
     assert 0 <= drop_prob <= 1
     keep_prob = 1 - drop_prob
-    if keep_prob == 0:  # 这种情况下把全部元素都丢弃
+    # 这种情况下把全部元素都丢弃
+    if keep_prob == 0:
         return X.zeros_like()
     mask = nd.random.uniform(0, 1, X.shape) < keep_prob
     return mask * X / keep_prob
@@ -99,8 +100,8 @@ def net(X):
 num_epochs, lr, batch_size = 5, 0.5, 256
 loss = gloss.SoftmaxCrossEntropyLoss()
 train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)
-d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, batch_size, params,
-              lr)
+d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, batch_size,
+              params, lr)
 ```
 
 ## 简洁实现

chapter_deep-learning-basics/fashion-mnist.md

@@ -50,8 +50,8 @@ Fashion-MNIST中一共包括了10个类别，分别为t-shirt（T恤）、trouse
 ```{.python .input  n=25}
 # 本函数已保存在d2lzh包中方便以后使用
 def get_fashion_mnist_labels(labels):
-    text_labels = ['t-shirt', 'trouser', 'pullover', 'dress', 'coat', 'sandal',
-                   'shirt', 'sneaker', 'bag', 'ankle boot']
+    text_labels = ['t-shirt', 'trouser', 'pullover', 'dress', 'coat',
+                   'sandal', 'shirt', 'sneaker', 'bag', 'ankle boot']
     return [text_labels[int(i)] for i in labels]
 ```
 

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

@@ -26,8 +26,10 @@ Gluon提供了`data`包来读取数据。由于`data`常用作变量名，我们
 from mxnet.gluon import data as gdata
 
 batch_size = 10
-dataset = gdata.ArrayDataset(features, labels)  # 将训练数据的特征和标签组合
-data_iter = gdata.DataLoader(dataset, batch_size, shuffle=True)  # 随机读取小批量
+# 将训练数据的特征和标签组合
+dataset = gdata.ArrayDataset(features, labels)
+# 随机读取小批量
+data_iter = gdata.DataLoader(dataset, batch_size, shuffle=True)
 ```
 
 这里`data_iter`的使用跟上一节中的一样。让我们读取并打印第一个小批量数据样本。

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

@@ -137,8 +137,8 @@ net = linreg
 loss = squared_loss
 
 for epoch in range(num_epochs):  # 训练模型一共需要num_epochs个迭代周期
-    # 在每一个迭代周期中，会使用训练数据集中所有样本一次（假设样本数能够被批量大小整除）。X和
-    # y分别是小批量样本的特征和标签
+    # 在每一个迭代周期中，会使用训练数据集中所有样本一次（假设样本数能够被批量大小整除）。X
+    # 和y分别是小批量样本的特征和标签
     for X, y in data_iter(batch_size, features, labels):
         with autograd.record():
             l = loss(net(X, w, b), y)  # l是有关小批量X和y的损失

chapter_deep-learning-basics/mlp-scratch.md

@@ -69,8 +69,8 @@ loss = gloss.SoftmaxCrossEntropyLoss()
 
 ```{.python .input  n=7}
 num_epochs, lr = 5, 0.5
-d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, batch_size, params,
-              lr)
+d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, batch_size,
+              params, lr)
 ```
 
 ## 小结

chapter_deep-learning-basics/weight-decay.md

@@ -147,7 +147,8 @@ def fit_and_plot_gluon(wd):
             trainer_b.step(batch_size)
         train_ls.append(loss(net(train_features),
                              train_labels).mean().asscalar())
-        test_ls.append(loss(net(test_features), test_labels).mean().asscalar())
+        test_ls.append(loss(net(test_features),
+                            test_labels).mean().asscalar())
     d2l.semilogy(range(1, num_epochs + 1), train_ls, 'epochs', 'loss',
                  range(1, num_epochs + 1), test_ls, ['train', 'test'])
     print('L2 norm of w:', net[0].weight.data().norm().asscalar())

chapter_deep-learning-computation/model-construction.md

@@ -51,9 +51,9 @@ class MySequential(nn.Block):
         super(MySequential, self).__init__(**kwargs)
 
     def add(self, block):
-        # block是一个Block子类实例，假设它有一个独一无二的名字。我们将它保存在Block类的成
-        # 员变量_children里，其类型是OrderedDict。当MySequential实例调用initialize函
-        # 数时，系统会自动对_children里所有成员初始化
+        # block是一个Block子类实例，假设它有一个独一无二的名字。我们将它保存在Block类的
+        # 成员变量_children里，其类型是OrderedDict。当MySequential实例调用
+        # initialize函数时，系统会自动对_children里所有成员初始化
         self._children[block.name] = block
 
     def forward(self, x):

chapter_natural-language-processing/machine-translation.md

@@ -20,8 +20,8 @@ PAD, BOS, EOS = '<pad>', '<bos>', '<eos>'
 接着定义两个辅助函数对后面读取的数据进行预处理。
 
 ```{.python .input}
-# 将一个序列中所有的词记录在all_tokens中以便之后构造词典，然后在该序列后面添加PAD直到序列长
-# 度变为max_seq_len，然后将序列保存在all_seqs中
+# 将一个序列中所有的词记录在all_tokens中以便之后构造词典，然后在该序列后面添加PAD直到序列
+# 长度变为max_seq_len，然后将序列保存在all_seqs中
 def process_one_seq(seq_tokens, all_tokens, all_seqs, max_seq_len):
     all_tokens.extend(seq_tokens)
     seq_tokens += [EOS] + [PAD] * (max_seq_len - len(seq_tokens) - 1)

chapter_natural-language-processing/sentiment-analysis-rnn.md

@@ -26,7 +26,8 @@ import tarfile
 首先下载这个数据集到`../data`路径下，然后解压至`../data/aclImdb`下。
 
 ```{.python .input  n=3}
-def download_imdb(data_dir='../data'):  # 本函数已保存在d2lzh包中方便以后使用
+# 本函数已保存在d2lzh包中方便以后使用
+def download_imdb(data_dir='../data'):
     url = ('http://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz')
     sha1 = '01ada507287d82875905620988597833ad4e0903'
     fname = gutils.download(url, data_dir, sha1_hash=sha1)
@@ -127,8 +128,8 @@ class BiRNN(nn.Block):
         self.decoder = nn.Dense(2)
 
     def forward(self, inputs):
-        # inputs的形状是(批量大小, 词数)，因为LSTM需要将序列作为第一维，所以将输入转置后再
-        # 提取词特征，输出形状为(词数, 批量大小, 词向量维度)
+        # inputs的形状是(批量大小, 词数)，因为LSTM需要将序列作为第一维，所以将输入转置后
+        # 再提取词特征，输出形状为(词数, 批量大小, 词向量维度)
         embeddings = self.embedding(inputs.T)
         # states形状是(词数, 批量大小, 2 * 隐藏单元个数)
         states = self.encoder(embeddings)

chapter_natural-language-processing/word2vec-gluon.md

@@ -349,6 +349,9 @@ get_similar_tokens('chip', 3, net[0])
 * 当数据集较大时，我们通常在迭代模型参数时才对当前小批量里的中心词采样背景词和噪声词。也就是说，同一个中心词在不同的迭代周期可能会有不同的背景词或噪声词。这样训练有哪些好处？尝试实现该训练方法。
 
 
+
+
+
 ## 参考文献
 
 [1] Penn Tree Bank. https://catalog.ldc.upenn.edu/LDC99T42

chapter_optimization/adadelta.md

@@ -51,7 +51,8 @@ def adadelta(params, states, hyperparams):
 使用超参数$\rho=0.9$来训练模型。
 
 ```{.python .input  n=12}
-d2l.train_ch7(adadelta, init_adadelta_states(), {'rho': 0.9}, features, labels)
+d2l.train_ch7(adadelta, init_adadelta_states(), {'rho': 0.9}, features,
+              labels)
 ```
 
 ## 简洁实现

chapter_optimization/adam.md

@@ -59,7 +59,8 @@ def adam(params, states, hyperparams):
 使用学习率为0.01的Adam算法来训练模型。
 
 ```{.python .input  n=5}
-d2l.train_ch7(adam, init_adam_states(), {'lr': 0.01, 't': 1}, features, labels)
+d2l.train_ch7(adam, init_adam_states(), {'lr': 0.01, 't': 1}, features,
+              labels)
 ```
 
 ## 简洁实现

chapter_optimization/momentum.md

@@ -146,8 +146,8 @@ d2l.train_ch7(sgd_momentum, init_momentum_states(),
 在Gluon中，只需要在`Trainer`实例中通过`momentum`来指定动量超参数即可使用动量法。
 
 ```{.python .input  n=9}
-d2l.train_gluon_ch7('sgd', {'learning_rate': 0.004, 'momentum': 0.9}, features,
-                    labels)
+d2l.train_gluon_ch7('sgd', {'learning_rate': 0.004, 'momentum': 0.9},
+                    features, labels)
 ```
 
 ## 小结

chapter_recurrent-neural-networks/rnn-scratch.md

@@ -226,19 +226,21 @@ pred_period, pred_len, prefixes = 50, 50, ['分开', '不分开']
 下面采用随机采样训练模型并创作歌词。
 
 ```{.python .input  n=13}
-train_and_predict_rnn(rnn, get_params, init_rnn_state, num_hiddens, vocab_size,
-                      ctx, corpus_indices, idx_to_char, char_to_idx, True,
-                      num_epochs, num_steps, lr, clipping_theta, batch_size,
-                      pred_period, pred_len, prefixes)
+train_and_predict_rnn(rnn, get_params, init_rnn_state, num_hiddens,
+                      vocab_size, ctx, corpus_indices, idx_to_char,
+                      char_to_idx, True, num_epochs, num_steps, lr,
+                      clipping_theta, batch_size, pred_period, pred_len,
+                      prefixes)
 ```
 
 接下来采用相邻采样训练模型并创作歌词。
 
 ```{.python .input  n=19}
-train_and_predict_rnn(rnn, get_params, init_rnn_state, num_hiddens, vocab_size,
-                      ctx, corpus_indices, idx_to_char, char_to_idx, False,
-                      num_epochs, num_steps, lr, clipping_theta, batch_size,
-                      pred_period, pred_len, prefixes)
+train_and_predict_rnn(rnn, get_params, init_rnn_state, num_hiddens,
+                      vocab_size, ctx, corpus_indices, idx_to_char,
+                      char_to_idx, False, num_epochs, num_steps, lr,
+                      clipping_theta, batch_size, pred_period, pred_len,
+                      prefixes)
 ```
 
 ## 小结