[1e feedback code]ch9

Author: astonzhang

chapter_computer-vision/anchor.md

@@ -29,7 +29,7 @@ img = image.imread('../img/catdog.jpg').asnumpy()
 h, w = img.shape[0:2]
 
 print(h, w)
-X = nd.random.uniform(shape=(1, 3, h, w))  # 构造输入数据。
+X = nd.random.uniform(shape=(1, 3, h, w))  # 构造输入数据
 Y = contrib.nd.MultiBoxPrior(X, sizes=[0.75, 0.5, 0.25], ratios=[1, 2, 0.5])
 Y.shape
 ```
@@ -44,7 +44,7 @@ boxes[250, 250, 0, :]
 为了描绘图像中以某个像素为中心的所有锚框，我们先定义`show_bboxes`函数以便在图像上画出多个边界框。
 
 ```{.python .input  n=4}
-# 本函数已保存在 d2lzh 包中方便以后使用。
+# 本函数已保存在d2lzh包中方便以后使用
 def show_bboxes(axes, bboxes, labels=None, colors=None):
     def _make_list(obj, default_values=None):
         if obj is None:
@@ -179,9 +179,9 @@ labels[0]
 anchors = nd.array([[0.1, 0.08, 0.52, 0.92], [0.08, 0.2, 0.56, 0.95],
                     [0.15, 0.3, 0.62, 0.91], [0.55, 0.2, 0.9, 0.88]])
 offset_preds = nd.array([0] * anchors.size)
-cls_probs = nd.array([[0] * 4,  # 背景的预测概率。
-                      [0.9, 0.8, 0.7, 0.1],  # 狗的预测概率。
-                      [0.1, 0.2, 0.3, 0.9]])  # 猫的预测概率。
+cls_probs = nd.array([[0] * 4,  # 背景的预测概率
+                      [0.9, 0.8, 0.7, 0.1],  # 狗的预测概率
+                      [0.1, 0.2, 0.3, 0.9]])  # 猫的预测概率
 ```
 
 在图像上打印预测边界框和它们的置信度。

chapter_computer-vision/bounding-box.md

@@ -17,24 +17,23 @@ from mxnet import image
 ```{.python .input}
 d2l.set_figsize()
 img = image.imread('../img/catdog.jpg').asnumpy()
-d2l.plt.imshow(img);  # 加分号只显示图。
+d2l.plt.imshow(img);  # 加分号只显示图
 ```
 
 ## 边界框
 
 在目标检测里，我们通常使用边界框（bounding box）来描述目标位置。边界框是一个矩形框，可以由矩形左上角的$x$和$y$轴坐标与右下角的$x$和$y$轴坐标确定。我们根据上图坐标信息来定义图中狗和猫的边界框。上图中的坐标原点在图像的左上角，原点往右和往下分别为$x$轴和$y$轴的正方向。
 
 ```{.python .input  n=2}
-# bbox 是 bounding box 的缩写。
+# bbox是bounding box的缩写
 dog_bbox, cat_bbox = [60, 45, 378, 516], [400, 112, 655, 493]
 ```
 
 我们可以在图中将边界框画出来，以检查其是否准确。画之前，我们定义一个辅助函数`bbox_to_rect`。它将边界框表示成matplotlib的边界框格式。
 
 ```{.python .input  n=3}
-def bbox_to_rect(bbox, color):  # 本函数已保存在 d2lzh 包中方便以后使用。
-    # 将边界框（左上 x、左上 y，右下 x，右下 y）格式转换成 matplotlib 格式：
-    # （（左上 x，左上 y），宽，高）。
+def bbox_to_rect(bbox, color):  # 本函数已保存在d2lzh包中方便以后使用
+    # 将边界框（左上x,左上y,右下x,右下y)格式转换成matplotlib格式：((左上x,左上y),宽,高)
     return d2l.plt.Rectangle(
         xy=(bbox[0], bbox[1]), width=bbox[2]-bbox[0], height=bbox[3]-bbox[1],
         fill=False, edgecolor=color, linewidth=2)

chapter_computer-vision/fine-tuning.md

@@ -70,7 +70,7 @@ d2l.show_images(hotdogs + not_hotdogs, 2, 8, scale=1.4);
 在训练时，我们先从图像中裁剪出随机大小和随机高宽比的一块随机区域，然后将该区域缩放为高和宽均为224像素的输入。测试时，我们将图像的高和宽均缩放为256像素，然后从中裁剪出高和宽均为224像素的中心区域作为输入。此外，我们对RGB（红、绿、蓝）三个颜色通道的数值做标准化：每个数值减去该通道所有数值的平均值，再除以该通道所有数值的标准差作为输出。
 
 ```{.python .input  n=5}
-# 指定 RGB 三个通道的均值和方差来将图像通道归一化。
+# 指定RGB三个通道的均值和方差来将图像通道归一化
 normalize = gdata.vision.transforms.Normalize(
     [0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
 
@@ -107,7 +107,7 @@ pretrained_net.output
 finetune_net = model_zoo.vision.resnet18_v2(classes=2)
 finetune_net.features = pretrained_net.features
 finetune_net.output.initialize(init.Xavier())
-# output 中的模型参数将在迭代中使用 10 倍大的学习率。
+# output中的模型参数将在迭代中使用10倍大的学习率
 finetune_net.output.collect_params().setattr('lr_mult', 10)
 ```
 

chapter_computer-vision/image-augmentation.md

@@ -27,7 +27,7 @@ d2l.plt.imshow(img.asnumpy())
 下面定义绘图函数`show_images`。
 
 ```{.python .input  n=23}
-# 本函数已保存在 d2lzh 包中方便以后使用。
+# 本函数已保存在d2lzh包中方便以后使用
 def show_images(imgs, num_rows, num_cols, scale=2):
     figsize = (num_cols * scale, num_rows * scale)
     _, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize)
@@ -139,10 +139,10 @@ def load_cifar10(is_train, augs, batch_size):
 首先，我们定义`try_all_gpus`函数，从而能够获取所有可用的GPU。
 
 ```{.python .input  n=35}
-def try_all_gpus():  # 本函数已保存在 d2lzh 包中方便以后使用。
+def try_all_gpus():  # 本函数已保存在d2lzh包中方便以后使用
     ctxes = []
     try:
-        for i in range(16):  # 假设一台机器上 GPU 的个数不超过 16。
+        for i in range(16):  # 假设一台机器上GPU的数量不超过16
             ctx = mx.gpu(i)
             _ = nd.array([0], ctx=ctx)
             ctxes.append(ctx)
@@ -160,15 +160,14 @@ def _get_batch(batch, ctx):
     features, labels = batch
     if labels.dtype != features.dtype:
         labels = labels.astype(features.dtype)
-    # 当 ctx 包含多个 GPU 时，划分小批量数据样本并复制到各个 GPU 上。
     return (gutils.split_and_load(features, ctx),
             gutils.split_and_load(labels, ctx), features.shape[0])
 ```
 
 然后，我们定义`evaluate_accuracy`函数评价模型的分类准确率。与[“Softmax回归的从零开始实现”](../chapter_deep-learning-basics/softmax-regression-scratch.md)和[“卷积神经网络（LeNet）”](../chapter_convolutional-neural-networks/lenet.md)两节中描述的`evaluate_accuracy`函数不同，这里定义的函数更加通用：它通过辅助函数`_get_batch`使用`ctx`变量所包含的所有GPU来评价模型。
 
 ```{.python .input  n=36}
-# 本函数已保存在 d2lzh 包中方便以后使用。
+# 本函数已保存在d2lzh包中方便以后使用
 def evaluate_accuracy(data_iter, net, ctx=[mx.cpu()]):
     if isinstance(ctx, mx.Context):
         ctx = [ctx]
@@ -186,7 +185,7 @@ def evaluate_accuracy(data_iter, net, ctx=[mx.cpu()]):
 接下来，我们定义`train`函数使用多GPU训练并评价模型。
 
 ```{.python .input  n=37}
-# 本函数已保存在 d2lzh 包中方便以后使用。
+# 本函数已保存在d2lzh包中方便以后使用
 def train(train_iter, test_iter, net, loss, trainer, ctx, num_epochs):
     print('training on', ctx)
     if isinstance(ctx, mx.Context):

chapter_computer-vision/kaggle-gluon-cifar10.md

@@ -42,7 +42,7 @@ import time
 为方便快速上手，我们提供了上述数据集的小规模采样，其中“train_tiny.zip”包含100个训练样本，而“test_tiny.zip”仅包含1个测试样本。它们解压后的文件夹名称分别为“train_tiny”和“test_tiny”。此外，将训练数据集标签的压缩文件解压，并得到“trainLabels.csv”。如果你将使用上述Kaggle比赛的完整数据集，还需要把下面`demo`变量改为`False`。
 
 ```{.python .input  n=2}
-# 如果使用下载的 Kaggle 比赛的完整数据集，把 demo 变量改为 False。
+# 如果使用下载的Kaggle比赛的完整数据集，把demo变量改为False
 demo = True
 if demo:
     import zipfile
@@ -58,7 +58,7 @@ if demo:
 ```{.python .input  n=3}
 def read_label_file(data_dir, label_file, train_dir, valid_ratio):
     with open(os.path.join(data_dir, label_file), 'r') as f:
-        # 跳过文件头行（栏名称）。
+        # 跳过文件头行（栏名称）
         lines = f.readlines()[1:]
         tokens = [l.rstrip().split(',') for l in lines]
         idx_label = dict(((int(idx), label) for idx, label in tokens))
@@ -72,7 +72,7 @@ def read_label_file(data_dir, label_file, train_dir, valid_ratio):
 下面定义一个辅助函数，从而仅在路径不存在的情况下创建路径。
 
 ```{.python .input  n=4}
-def mkdir_if_not_exist(path):  # 本函数已保存在 d2lzh 包中方便以后使用。
+def mkdir_if_not_exist(path):  # 本函数已保存在d2lzh包中方便以后使用
     if not os.path.exists(os.path.join(*path)):
         os.makedirs(os.path.join(*path))
 ```
@@ -126,8 +126,8 @@ def reorg_cifar10_data(data_dir, label_file, train_dir, test_dir, input_dir,
 
 ```{.python .input  n=8}
 if demo:
-    # 注意：此处使用小训练集和小测试集并将批量大小相应设小。使用 Kaggle 比赛的完整数据集时
-    # 可设批量大小为较大整数。
+    # 注意：此处使用小训练集和小测试集并将批量大小相应设小。使用Kaggle比赛的完整数据集时可
+    # 设批量大小为较大整数
     train_dir, test_dir, batch_size = 'train_tiny', 'test_tiny', 1
 else:
     train_dir, test_dir, batch_size = 'train', 'test', 128
@@ -143,15 +143,15 @@ reorg_cifar10_data(data_dir, label_file, train_dir, test_dir, input_dir,
 
 ```{.python .input  n=9}
 transform_train = gdata.vision.transforms.Compose([
-    # 将图像放大成高和宽各为 40 像素的正方形。
+    # 将图像放大成高和宽各为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(),
     gdata.vision.transforms.ToTensor(),
-    # 对图像的每个通道做标准化。
+    # 对图像的每个通道做标准化
     gdata.vision.transforms.Normalize([0.4914, 0.4822, 0.4465],
                                       [0.2023, 0.1994, 0.2010])])
 ```
@@ -170,7 +170,7 @@ transform_test = gdata.vision.transforms.Compose([
 接下来，我们可以通过创建`ImageFolderDataset`实例来读取整理后的含原始图像文件的数据集，其中每个数据样本包括图像和标签。
 
 ```{.python .input  n=10}
-# 读取原始图像文件。flag=1 说明输入图像有三个通道（彩色）。
+# 读取原始图像文件。flag=1说明输入图像有3个通道（彩色）
 train_ds = gdata.vision.ImageFolderDataset(
     os.path.join(data_dir, input_dir, 'train'), flag=1)
 valid_ds = gdata.vision.ImageFolderDataset(

chapter_computer-vision/kaggle-gluon-dog.md

@@ -43,7 +43,7 @@ import zipfile
 为方便快速上手，我们提供了上述数据集的小规模采样“train_valid_test_tiny.zip”。如果你要使用上述Kaggle比赛的完整数据集，还需要把下面`demo`变量改为`False`。
 
 ```{.python .input  n=1}
-# 如果使用下载的 Kaggle 比赛的完整数据集，把下面改为 False。
+# 如果使用下载的Kaggle比赛的完整数据集，把demo变量改为False
 demo = True
 data_dir = '../data/kaggle_dog'
 if demo:
@@ -61,10 +61,10 @@ for f in zipfiles:
 
 ```{.python .input}
 def reorg_train_valid(data_dir, train_dir, input_dir, valid_ratio, idx_label):
-    # 训练集中数量最少一类的狗的样本数。
+    # 训练集中数量最少一类的狗的样本数
     min_n_train_per_label = (
         collections.Counter(idx_label.values()).most_common()[:-2:-1][0][1])
-    # 验证集中每类狗的样本数。
+    # 验证集中每类狗的样本数
     n_valid_per_label = math.floor(min_n_train_per_label * valid_ratio)
     label_count = {}
     for train_file in os.listdir(os.path.join(data_dir, train_dir)):
@@ -89,14 +89,14 @@ def reorg_train_valid(data_dir, train_dir, input_dir, valid_ratio, idx_label):
 ```{.python .input  n=2}
 def reorg_dog_data(data_dir, label_file, train_dir, test_dir, input_dir,
                    valid_ratio):
-    # 读取训练数据标签。
+    # 读取训练数据标签
     with open(os.path.join(data_dir, label_file), 'r') as f:
-        # 跳过文件头行（栏名称）。
+        # 跳过文件头行（栏名称）
         lines = f.readlines()[1:]
         tokens = [l.rstrip().split(',') for l in lines]
         idx_label = dict(((idx, label) for idx, label in tokens))
     reorg_train_valid(data_dir, train_dir, input_dir, valid_ratio, idx_label)
-    # 整理测试集。
+    # 整理测试集
     d2l.mkdir_if_not_exist([data_dir, input_dir, 'test', 'unknown'])
     for test_file in os.listdir(os.path.join(data_dir, test_dir)):
         shutil.copy(os.path.join(data_dir, test_dir, test_file),
@@ -107,8 +107,8 @@ def reorg_dog_data(data_dir, label_file, train_dir, test_dir, input_dir,
 
 ```{.python .input  n=3}
 if demo:
-    # 注意：此处使用小数据集并将批量大小相应设小。使用 Kaggle 比赛的完整数据集时可设批量大
-    # 小为较大整数。
+    # 注意：此处使用小数据集并将批量大小相应设小。使用Kaggle比赛的完整数据集时可设批量大小
+    # 为较大整数
     input_dir, batch_size = 'train_valid_test_tiny', 1
 else:
     label_file, train_dir, test_dir = 'labels.csv', 'train', 'test'
@@ -123,18 +123,18 @@ else:
 
 ```{.python .input  n=4}
 transform_train = gdata.vision.transforms.Compose([
-    # 随机对图像裁剪出面积为原图像面积 0.08 到 1 倍之间、且高和宽之比在 3/4 和 4/3 之间
-    # 的图像，再放缩为高和宽均为 224 像素的新图像。
+    # 随机对图像裁剪出面积为原图像面积0.08到1倍之间、且高和宽之比在3/4和4/3之间的图像，再
+    # 放缩为高和宽均为224像素的新图像
     gdata.vision.transforms.RandomResizedCrop(224, scale=(0.08, 1.0),
                                               ratio=(3.0/4.0, 4.0/3.0)),
     gdata.vision.transforms.RandomFlipLeftRight(),
-    # 随机变化亮度、对比度和饱和度。
+    # 随机变化亮度、对比度和饱和度
     gdata.vision.transforms.RandomColorJitter(brightness=0.4, contrast=0.4,
                                               saturation=0.4),
-    # 随机加噪音。
+    # 随机加噪声
     gdata.vision.transforms.RandomLighting(0.1),
     gdata.vision.transforms.ToTensor(),
-    # 对图像的每个通道做标准化。
+    # 对图像的每个通道做标准化
     gdata.vision.transforms.Normalize([0.485, 0.456, 0.406],
                                       [0.229, 0.224, 0.225])])
 ```
@@ -144,7 +144,7 @@ transform_train = gdata.vision.transforms.Compose([
 ```{.python .input}
 transform_test = gdata.vision.transforms.Compose([
     gdata.vision.transforms.Resize(256),
-    # 将图像中央的高和宽均为 224 的正方形区域裁剪出来。
+    # 将图像中央的高和宽均为224的正方形区域裁剪出来
     gdata.vision.transforms.CenterCrop(224),
     gdata.vision.transforms.ToTensor(),
     gdata.vision.transforms.Normalize([0.485, 0.456, 0.406],
@@ -188,14 +188,14 @@ test_iter = gdata.DataLoader(test_ds.transform_first(transform_test),
 ```{.python .input  n=6}
 def get_net(ctx):
     finetune_net = model_zoo.vision.resnet34_v2(pretrained=True)
-    # 定义新的输出网络。
+    # 定义新的输出网络
     finetune_net.output_new = nn.HybridSequential(prefix='')
     finetune_net.output_new.add(nn.Dense(256, activation='relu'))
-    # 120 是输出的类别数。
+    # 120是输出的类别个数
     finetune_net.output_new.add(nn.Dense(120))
-    # 初始化输出网络。
+    # 初始化输出网络
     finetune_net.output_new.initialize(init.Xavier(), ctx=ctx)
-    # 把模型参数分配到即将用于计算的 CPU 或 GPU 上。
+    # 把模型参数分配到内存或显存上
     finetune_net.collect_params().reset_ctx(ctx)
     return finetune_net
 ```
@@ -223,7 +223,7 @@ def evaluate_loss(data_iter, net, ctx):
 ```{.python .input  n=7}
 def train(net, train_iter, valid_iter, num_epochs, lr, wd, ctx, lr_period,
           lr_decay):
-    # 只训练我们定义的小规模输出网络。
+    # 只训练自定义的小规模输出网络
     trainer = gluon.Trainer(net.output_new.collect_params(), 'sgd',
                             {'learning_rate': lr, 'momentum': 0.9, 'wd': wd})
     for epoch in range(num_epochs):

chapter_computer-vision/multiscale-object-detection.md

@@ -25,7 +25,7 @@ h, w
 d2l.set_figsize()
 
 def display_anchors(fmap_w, fmap_h, s):
-    fmap = nd.zeros((1, 10, fmap_w, fmap_h))  # 前两维的取值不影响输出结果。
+    fmap = nd.zeros((1, 10, fmap_w, fmap_h))  # 前两维的取值不影响输出结果
     anchors = contrib.nd.MultiBoxPrior(fmap, sizes=s, ratios=[1, 2, 0.5])
     bbox_scale = nd.array((w, h, w, h))
     d2l.show_bboxes(d2l.plt.imshow(img.asnumpy()).axes,

chapter_computer-vision/neural-style.md

@@ -160,13 +160,13 @@ style_channels = [net[l].weight.shape[0] for l in style_layers]
 content_weight, style_weight, tv_weight = 1, 1e3, 10
 
 def compute_loss(X, contents_Y_hat, styles_Y_hat, contents_Y, styles_Y_gram):
-    # 分别计算内容、样式和总变差损失。
+    # 分别计算内容损失、样式损失和总变差损失
     contents_l = [content_loss(Y_hat, Y) * content_weight for Y_hat, Y in zip(
         contents_Y_hat, contents_Y)]
     styles_l = [style_loss(Y_hat, Y) * style_weight for Y_hat, Y in zip(
         styles_Y_hat, styles_Y_gram)]
     tv_l = tv_loss(X) * tv_weight
-    # 对所有损失求和。
+    # 对所有损失求和
     l = nd.add_n(*styles_l) + nd.add_n(*contents_l) + tv_l
     return contents_l, styles_l, tv_l, l
 ```

chapter_computer-vision/object-detection-dataset.md

@@ -29,17 +29,17 @@ def _download_pikachu(data_dir):
 我们通过创建`ImageDetIter`实例来读取目标检测数据集。其中名称里的“Det”指的是Detection（检测）。我们将以随机顺序读取训练数据集。由于数据集的格式为RecordIO，我们需要提供图像索引文件`'train.idx'`以随机读取小批量。此外，对于训练集的每张图像，我们将采用随机裁剪，并要求裁剪出的图像至少覆盖每个目标95%的区域。由于裁剪是随机的，这个要求不一定总被满足。我们设定最多尝试200次随机裁剪：如果都不符合要求则不裁剪图像。为保证输出结果的确定性，我们不随机裁剪测试数据集中的图像。我们也无需按随机顺序读取测试数据集。
 
 ```{.python .input  n=2}
-# 本函数已保存在 d2lzh 包中方便以后使用。
-def load_data_pikachu(batch_size, edge_size=256):  # edge_size：输出图像的宽和高。
+# 本函数已保存在d2lzh包中方便以后使用
+def load_data_pikachu(batch_size, edge_size=256):  # edge_size：输出图像的宽和高
     data_dir = '../data/pikachu'
     _download_pikachu(data_dir)
     train_iter = image.ImageDetIter(
         path_imgrec=os.path.join(data_dir, 'train.rec'),
         path_imgidx=os.path.join(data_dir, 'train.idx'),
         batch_size=batch_size,
-        data_shape=(3, edge_size, edge_size),  # 输出图像的形状。
-        shuffle=True,  # 以随机顺序读取数据集。
-        rand_crop=1,  # 随机裁剪的概率为 1。
+        data_shape=(3, edge_size, edge_size),  # 输出图像的形状
+        shuffle=True,  # 以随机顺序读取数据集
+        rand_crop=1,  # 随机裁剪的概率为1
         min_object_covered=0.95, max_attempts=200)
     val_iter = image.ImageDetIter(
         path_imgrec=os.path.join(data_dir, 'val.rec'), batch_size=batch_size,