K 折交叉验证(K-fold cross-validation)：

由于验证数据集不参与模型训练，当训练数据不够用时，预留大量的验证数据显得太奢侈。一种改善的方法是K折交叉验证（K-fold cross-validation）。在K折交叉验证中，我们把原始训练数据集分割成K个不重合的子数据集，然后我们做K次模型训练和验证。每一次，我们使用一个子数据集验证模型，并使用其他K−1个子数据集来训练模型。在这K次训练和验证中，每次用来验证模型的子数据集都不同。最后，我们对这K次训练误差和验证误差分别求平均。

将训练集分成 K 个划分，取一个做验证集，剩余 K-1 个做训练集，并进行轮换，最后对 K 次验证结果取平均。此法用于改善数据不够的情况。

多项式函数拟合实验

为了理解模型复杂度和训练数据集大小对欠拟合和过拟合的影响，下面我们以多项式函数拟合为例来实验。

  1. import torch
  2. import d2lzh

torch.cat(),torch.pow()的使用

.pow(tensor, n)函数是对tensor做n次幂的运算。参见：torch.pow()、torch.matmul()等

  1. a=torch.tensor(3)
  2. b=torch.pow(a,2)
  3. print(b)
  4. c=torch.randn(4)
  5. print(c)
  6. d=torch.pow(c,2)
  7. print(d)
  10. 结果:
  11. tensor(9)
  12. tensor([ 0.0923,  0.7006, -0.2963,  0.6543])
  13. tensor([0.0085, 0.4909, 0.0878, 0.4282])

.cat((tensor1, tensor2, …), dim)函数是concatenate的简写，意为将两个张量连接在一起，其中dim表示连接的维度，是按维数0（竖着）拼，还是按维数1（横着）拼。参见：Pytorch中的torch.cat()函数

  1. A = torch.ones(2, 3)  # 2x3的张量（矩阵）
  2. print(A)
  4. B = 2 * torch.ones(4, 3)  # 4x3的张量（矩阵）
  5. print(B)
  7. C = torch.cat((A, B), 0)  # 按维数0（行）拼接
  8. print(C)
  10. print(C.size())
  13. 结果：
  14. tensor([[1., 1., 1.],
  15.         [1., 1., 1.]])
  17. tensor([[2., 2., 2.],
  18.         [2., 2., 2.],
  19.         [2., 2., 2.],
  20.         [2., 2., 2.]])
  22. tensor([[1., 1., 1.],
  23.         [1., 1., 1.],
  24.         [2., 2., 2.],
  25.         [2., 2., 2.],
  26.         [2., 2., 2.],
  27.         [2., 2., 2.]])
  29. torch.Size([6, 3])

生成数据集

给定特征值x，采用如下的三次多项式生成样本标签：
模型选择、过拟合及欠拟合 - 图1
其中噪声项ϵ服从均值为0、标准差为0.01的正态分布。训练数据集和测试数据集的样本数都设为100。

  1. n_train, n_test, true_w, true_b = 100, 100, [1.2, -3.4, 5.6], 5
  2. features = torch.randn((n_train + n_test, 1))
  3. poly_features = torch.cat((features, torch.pow(features, 2), torch.pow(features, 3)), 1)
  4. labels = (true_w[0] * poly_features[:, 0] + true_w[1] * poly_features[:, 1] + true_w[2] * poly_features[:, 2]+true_b)
  5. labels += torch.normal(mean=0, std=0.01, size=labels.size(), dtype=torch.float)
  7. print(features[:2])
  8. print(poly_features[:2])
  9. print(labels[:2])
  13. 结果：
  14. tensor([[ 1.1996],
  15.         [-0.7766]])
  16. tensor([[ 1.1996,  1.4390,  1.7261],
  17.         [-0.7766,  0.6031, -0.4683]])
  18. tensor([11.2152, -0.6078])

定义、训练和测试模型

定义作图函数semilogy

  1. def semilogy(x_vals, y_vals, x_label, y_label, x2_vals=None, y2_vals=None,
  2.              legend=None, figsize=(3.5, 2.5)):
  3.     d2lzh.set_figsize(figsize)
  4.     d2lzh.plt.xlabel(x_label)
  5.     d2lzh.plt.ylabel(y_label)
  6.     d2lzh.plt.semilogy(x_vals, y_vals)
  7.     if x2_vals and y2_vals:
  8.         d2lzh.plt.semilogy(x2_vals, y2_vals, linestyle=':')
  9.         d2lzh.plt.legend(legend)

采用不同复杂度的模型来拟合生成的数据集，因此这次把模型定义部分放在下面的函数中，包括定义及训练的过程。

  1. num_epochs, loss = 100, torch.nn.MSELoss()
  4. # 第一个参数表示训练用样本，第二个参数表示测试用样本，第三个参数表示训练用标签...
  5. def fit_and_plot(train_features, test_features, train_labels, test_labels):
  6.     net = torch.nn.Linear(train_features.shape[-1], 1)
  7.     # 通过Linear文档可知，pytorch已经将参数初始化了，所以我们这里就不手动初始化了
  9.     batch_size = min(10, train_labels.shape[0])
  10.     dataset = torch.utils.data.TensorDataset(train_features, train_labels)
  11.     train_iter = torch.utils.data.DataLoader(dataset, batch_size, shuffle=True)
  13.     optimizer = torch.optim.SGD(net.parameters(), lr=0.01)
  14.     train_ls, test_ls = [], []
  15.     for _ in range(num_epochs):
  16.         for X, y in train_iter:
  17.             l = loss(net(X), y.view(-1, 1))
  18.             optimizer.zero_grad()
  19.             l.backward()
  20.             optimizer.step()
  21.         train_labels = train_labels.view(-1, 1)
  22.         test_labels = test_labels.view(-1, 1)
  23.         train_ls.append(loss(net(train_features), train_labels).item())
  24.         test_ls.append(loss(net(test_features), test_labels).item())
  25.     print('final epoch: train loss', train_ls[-1], 'test loss', test_ls[-1])
  26.     semilogy(range(1, num_epochs + 1), train_ls, 'epochs', 'loss',
  27.              range(1, num_epochs + 1), test_ls, ['train', 'test'])
  28.     print('weight:', net.weight.data,
  29.           '\nbias:', net.bias.data)

三阶多项式函数拟合（正常）

使用三阶多项式函数拟合，误差在训练集和测试集上都较低。

  1. if __name__ == "__main__":
  2.     fit_and_plot(poly_features[:n_train, :], poly_features[n_train:, :],
  3.                  labels[:n_train], labels[n_train:])
  7. 结果：
  8. final epoch: train loss 7.490593998227268e-05 test loss 0.00011266930232523009
  9. weight: tensor([[ 1.1993, -3.4002,  5.5999]]) 
  10. bias: tensor([4.9988])

拟合图像：
image.png

线性函数拟合（欠拟合）

可以看到，使用线性函数拟合效果很差，误差非常大。

  1. if __name__ == "__main__":
  2.     fit_and_plot(features[:n_train, :], features[n_train:, :], labels[:n_train], labels[n_train:])
  5. 结果：
  6. final epoch: train loss 166.6153564453125 test loss 98.48001861572266
  7. weight: tensor([[18.4383]]) 
  8. bias: tensor([2.6094])

拟合图像：
image.png

训练样本不足（过拟合）

事实上，即便使用与数据生成模型同阶的三阶多项式函数模型，如果训练样本不足，该模型依然容易过拟合。让我们只使用两个样本来训练模型。显然，训练样本过少了，甚至少于模型参数的数量。这使模型显得过于复杂，以至于容易被训练数据中的噪声影响。在迭代过程中，尽管训练误差较低，但是测试数据集上的误差却很高。这是典型的过拟合现象。

可以看到，模型在训练集上误差较小，但在测试集上误差极大。

  1. if __name__ == "__main__":
  2.     fit_and_plot(poly_features[0:2, :], poly_features[n_train:, :], labels[0:2], labels[n_train:])
  5. 结果：
  6. final epoch: train loss 166.6153564453125 test loss 98.48001861572266
  7. weight: tensor([[18.4383]])
  8. bias: tensor([2.6094])

拟合图像：
image.png

小结：

  • 由于无法从训练误差估计泛化误差，一味地降低训练误差并不意味着泛化误差一定会降低。机器学习模型应关注降低泛化误差。
  • 可以使用验证数据集来进行模型选择。
  • 欠拟合指模型无法得到较低的训练误差，过拟合指模型的训练误差远小于它在测试数据集上的误差。
  • 应选择复杂度合适的模型并避免使用过少的训练样本。