算法工程师修仙之路：Mxnet（三）

深度学习基础

• 尽管强大的深度学习框架可以减少大量重复性工作，但若过于依赖它提供的便利，会导致我们很难深入理解深度学习是如何工作的。

• 因此，我们将介绍如何只利用 NDArray 和 autograd 来实现一个线性回归的训练。

线性回归的从零开始实现

---

• 首先，导入所需的包或模块，其中的 matplotlib 包可用于作图：

  from IPython import display
  from matplotlib import pyplot as plt 
  from mxnet import autograd, nd
  import random
  

生成数据集

• 我们构造一个简单的人工训练数据集，它可以使我们能够直观比较学到的参数和真实的模型参数的区别。

• 设训练数据集样本数为1000，输入个数（特征数）为2。

  • 给定随机生成的批量样本特征：$\mathbf{X}\in {\mathbb{R}}^{1000\times 2}$
  • 我们使用线性回归模型真实权重和偏差：$\mathbf{w}=[2,-3.4{]}^{\top }$、$b=4.2$
  • 以及一个随机噪声项：$ϵ$
  • 噪声项 $ϵ$ 服从均值为0、标准差为0.01的正态分布。
  • 噪声代表了数据集中无意义的干扰。
  • 生成标签：$\mathbf{y}=\mathbf{X}\mathbf{w}+b+ϵ$

• 下面，让我们生成数据集：

  # 生成数据集
  # features 的每一行是一个长度为2的向量，而 labels 的每一行是一个长度为1的向量（标量）。
  num_inputs = 2
  num_examples = 1000
  true_w = [2, -3.4]
  true_b = 4.2
  features = nd.random.normal(scale=1, shape=(num_examples, num_inputs))
  labels = true_w[0] * features[:, 0] + true_w[1] * features[:, 1] + true_b
  labels += nd.random.normal(scale=0.01, shape=labels.shape)
  print(features[0], labels[0])
  """
  Output:
  [1.1630785 0.4838046]
  <NDArray 2 @cpu(0)>
  [4.879625]
  <NDArray 1 @cpu(0)>
  """
  

• 通过生成第二个特征 features[:, 1] 和标签 labels 的散点图，可以更直观地观察两者间的线性关系：

  # 生成第二个特征 features[:, 1] 和标签 labels 的散点图
  def use_svg_display():
      # 用矢量图显示
      display.set_matplotlib_formats('svg')
  
  def set_figsize(figsize=(3.5, 2.5)):
      use_svg_display()
      # 设置图的尺寸
      plt.rcParams['figure.figsize'] = figsize
  
  set_figsize()
  # 加分号只显示图
  plt.scatter(features[:, 1].asnumpy(), labels.asnumpy(), 1);
  plt.show()
  

读取数据

• 在训练模型的时候，我们需要遍历数据集并不断读取小批量数据样本。

• 我们定义一个函数使其每次返回 batch_size（批量大小）个随机样本的特征和标签：

  # 定义一个函数：它每次返回 batch_size（批量大小）个随机样本的特征和标签。
  def data_iter(batch_size, features, labels):
      num_examples = len(features)
      indices = list(range(num_examples))
      # 样本的读取顺序是随机的
      random.shuffle(indices)
      for i in range(0, num_examples, batch_size):
          j = nd.array(indices[i: min(i + batch_size, num_examples)])
          # take 函数根据索引返回对应元素
          yield features.take(j), labels.take(j)
  

• 让我们读取第一个小批量数据样本并打印。每个批量的特征形状为(10, 2)，分别对应批量大小和输入个数；标签形状为批量大小。

  # 读取第一个小批量数据样本并打印
  batch_size = 10
  
  for x, y in data_iter(batch_size, features, labels):
      print(x, y)
      break
  """
  Output:
  [[-0.511572    0.3929431 ]
   [ 0.14603852 -1.4237237 ]
   [ 0.53989464 -0.8063781 ]
   [ 1.527508   -0.42868343]
   [-1.0910612   0.24606876]
   [-1.2520171   0.2591413 ]
   [ 0.8395475  -0.8393784 ]
   [ 0.9821262  -0.17373237]
   [ 0.99923676 -0.86133176]
   [ 0.47207657 -0.04626406]]
  <NDArray 10x2 @cpu(0)>
  [1.8385592  9.3246     8.017159   8.719315   1.1776838  0.83230937
   8.733551   6.7600207  9.121296   5.3175707 ]
  <NDArray 10 @cpu(0)>
  """
  

初始化模型参数

• 我们将权重初始化成均值为0、标准差为0.01的正态随机数，偏差则初始化成0：

  # 我们将权重初始化成均值为0、标准差为0.01的正态随机数，偏差则初始化成0。
  w = nd.random.normal(scale=0.01, shape=(num_inputs, 1))
  b = nd.zeros(shape=(1,))
  

• 模型训练中需要对这些参数求梯度来迭代参数的值，因此我们需要创建它们的梯度：

  # 创建它们的梯度
  w.attach_grad()
  b.attach_grad()
  

定义模型

• 下面是线性回归的矢量计算表达式的实现，我们使用 dot 函数做矩阵乘法：

  # 我们使用 dot 函数做矩阵乘法。
  def linreg(X, w, b):
      return nd.dot(X, w) + b
  

定义损失函数

• 使用平方损失来定义线性回归的损失函数。

• 在实现中，我们需要把真实值 $y$ 变形成预测值 $\hat{y}$ 的形状。

  # 定义损失函数
  # 以下函数返回的结果和 y_hat 的形状相同。
  def square_loss(y_hat, y):
      return (y_hat - y.reshape(y_hat.shape)) ** 2 / 2
  

定义优化算法

• sgd 函数实现了小批量随机梯度下降算法，它通过不断迭代模型参数来优化损失函数。

• 自动求梯度模块计算得来的梯度是一个批量样本的梯度和，我们将它除以批量大小来得到平均值：

  def sgd(params, lr, batch_size): 
      for param in params:
          param[:] = param - lr * param.grad / batch_size
  

训练模型

• 在训练中，我们将多次迭代模型参数。

• 在每次迭代中，我们根据当前读取的小批量数据样本（特征 $X$ 和标签 $y$），通过调用反向函数backward 计算小批量随机梯度，并调用优化算法 sgd 迭代模型参数。

• 由于我们之前设批量大小 batch_size 为10，每个小批量的损失 $l$ 的形状为(10, 1)。由于变量 $l$ 并不是一个标量，运行 $l.backward()$ 将对 $l$ 中元素求和得到新的变量，再求该变量有关模型参数的梯度。

• 在一个迭代周期（epoch）中，我们将完整遍历一遍 data_iter 函数，并对训练数据集中所有样本都使用一次（假设样本数能够被批量大小整除）。

• 迭代周期个数 num_epochs 和学习率 lr 都是超参数，分别设3和0.03。

• 在实践中，大多超参数都需要通过反复试错来不断调节，虽然迭代周期数设得越大模型可能越有效，但是训练时间可能过长。

  # 训练模型的超参数设置
  lr = 0.03
  num_epochs = 3
  net = linreg
  loss = square_loss
  
  # 训练模型一共需要 num_epochs 个迭代周期
  for epoch in range(num_epochs):
      # 在每一个迭代周期中，会使用训练数据集中所有样本一次（假设样本数能够被批量大小整除）。
      # X 和 y 分别是小批量样本的特征和标签
      for X, y in data_iter(batch_size, features, labels):
          with autograd.record():
              # l 是有关小批量 X 和 y 的损失
              l = loss(net(X, w, b), y)
          # 小批量的损失对模型参数求梯度
          l.backward()    
          # 使用小批量随机梯度下降迭代模型参数
          sgd([w, b], lr, batch_size) 
      train_l = loss(net(features, w, b), labels)
      print('epoch %d, loss %f' % (epoch + 1, train_l.mean().asnumpy()))
  """
  Output:
  epoch 1, loss 0.034922
  epoch 2, loss 0.000121
  epoch 3, loss 0.000049
  """
  
  # 训练完成后，我们可以比较学到的参数和用来生成训练集的真实参数。
  print(true_w, w)
  print(true_b, b)
  """
  Output:
  [2, -3.4]
  [[ 1.9990884]
   [-3.3994849]]
  <NDArray 2x1 @cpu(0)>
  4.2
  [4.2002444]
  <NDArray 1 @cpu(0)>
  """