DL基础补全计划(三)---模型选择、欠拟合、过拟合

本文主要是介绍DL基础补全计划(三)---模型选择、欠拟合、过拟合，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

PS：要转载请注明出处，本人版权所有。

PS: 这个只是基于《我自己》的理解，

如果和你的原则及想法相冲突，请谅解，勿喷。

环境说明

Windows 10
VSCode
Python 3.8.10
Pytorch 1.8.1
Cuda 10.2

前言

在前文中，我们已经接触了两种回归模型，也接触了深度学习中的一些常见的概念。其中有趣的信息是，我们在《DL基础补全计划(二)—Softmax回归及示例（Pytorch，交叉熵损失）》中已经发现了，在softmax回归的时候，我们使用一个线性的隐藏层在其数据集上都能够达到不错的不错的准确率，这里的不错是指瞎猜和我们的模型推测的准确率，一个是10%，一个是80%左右。这至少说明了我们这个分类模型是有效的。其实后续我们就会更换线性隐藏层为其他层来实现我们的模型，比如：CNN、RNN等等，不同的隐藏层是后续我们要接触和学习的内容，这里不先做详解。

我们假设我们已经设计出了许多的不同隐藏层的模型，这个时候有一个重要的问题就是选择哪一个模型为我们实际的要应用的模型，本文将会介绍一些方法来实现怎么选择模型的问题。

一些基本概念简介

基本概念简介：

训练误差是指模型在参数更新后，在训练集上做一次测试，算出的和真实值的误差。
泛化误差是指模型在真实数据分布下，算出的和真实值的误差，但是一般情况下数据是无穷多的，我们只能够采集一些真实数据，并算出泛化误差。常见的情况是我们构造一个测试集来计算泛化误差。
欠拟合模型拟合能力差，训练误差和泛化误差差异小，但是两个误差都比较大，一般来说，就是模型基本没有学习到我们需要学习的规律和特征。
过拟合训练误差小，泛化误差大。一般来说就是在训练集上学习的太过分了，类似强行记住了训练集上的所有规律和特征，导致泛化能力太弱了。

一般来说欠拟合的话，就是换网络，加深加大网络等解决问题，欠拟合其实很明显，解决方向比较明确。

其实我们更多是遇到过拟合，因为随着发展，我们的模型越来越深和宽，但是我们能够收集到的数据是有限的，导致了我们的模型可能出现‘死记硬背’下我们的训练集，然后泛化能力就令人担忧，为了缓解这个问题，后续我们将会介绍几种缓解过拟合的方法。

下面我们将会通过一个实例来体会一下正常拟合、欠拟合、过拟合。

一个正常拟合、过拟合、欠拟合的实例

这里我们通过pytorch的高级API来设计一个线性规划的实例。

首先通过如下的代码生成 $Y=(X^3/3!)*W1 + (X^2/2!)*W2 + X*W3 + b + \epsilon, \epsilon=N(0, 0.1^2)$ 的特征和标签。

def synthetic_data(w, num_examples): #@save"""⽣成y = (X1^3/3!)*W1 + (X2^2/2!)*W1 + X3*W3 + b + 噪声。"""X = np.random.normal(0, 1, (num_examples, 1))y = np.dot(X**3/np.math.factorial(3), w[0]) + np.dot(X**2/np.math.factorial(2), w[1]) + np.dot(X/np.math.factorial(1), w[2]) + w[3]# 噪声y += np.random.normal(0, 0.1, y.shape)return X, y.reshape((-1, 1))

然后通过自定义Pytorch层，通过传入参数N，计算N项多项式的结果。

class TestLayer(nn.Module):def __init__(self, n, **kwargs):super(TestLayer, self).__init__(**kwargs)self.n = nself.w_array = nn.Parameter(torch.tensor( np.random.normal(0, 0.1, (1, n))).reshape(-1, 1))self.b = nn.Parameter(torch.tensor(np.random.normal(0, 0.1, 1)))def cal(self, X, n):X = X.reshape(batch_size, 1, 1)Y = self.bfor i in range(n):# print(X.shape)# print(self.w_array.shape)# print(Y.shape)Y  = Y + torch.matmul(X**(i + 1)/torch.tensor(np.math.factorial(i + 1)), self.w_array[i])return Ydef forward(self, x):return self.cal(x, self.n)class TestNet(nn.Module):def __init__(self, n):super(TestNet, self).__init__()self.test_net = nn.Sequential(TestLayer(n))   def forward(self, x):return self.test_net(x)

最终完整代码如下：

import torch
from torch import nn
import numpy as np
import matplotlib.pyplot as plt
from torch.utils import data
from matplotlib.pyplot import MultipleLocatorfig, ax = plt.subplots()
xdata0, ydata0 = [], []
xdata1, ydata1 = [], []
line0, = ax.plot([], [], 'r-', label='TrainError')
line1, = ax.plot([], [], 'b-', label='TestError')def init_and_show():ax.set_xlabel('epoch')ax.set_ylabel('loss')ax.set_title('Train/Test Loss')ax.set_xlim(0, epochs)ax.set_ylim(0.05, 100)ax.set_yscale('log')# y_locator = MultipleLocator(0.1)# ax.yaxis.set_major_locator(y_locator)ax.legend([line0, line1], ('TrainError', 'TestError'))# ax.legend([line1], ('TestError', ))line0.set_data(xdata0, ydata0)line1.set_data(xdata1, ydata1)plt.show()def synthetic_data(w, num_examples): #@save"""⽣成y = X1^3*W1 + X2^2*W1 + X3*W3 + b + 噪声。"""X = np.random.normal(0, 1, (num_examples, 1))y = np.dot(X**3/np.math.factorial(3), w[0]) + np.dot(X**2/np.math.factorial(2), w[1]) + np.dot(X/np.math.factorial(1), w[2]) + w[3]# 噪声y += np.random.normal(0, 0.1, y.shape)return X, y.reshape((-1, 1))class TestLayer(nn.Module):def __init__(self, n, **kwargs):super(TestLayer, self).__init__(**kwargs)self.n = nself.w_array = nn.Parameter(torch.tensor( np.random.normal(0, 0.1, (1, n))).reshape(-1, 1))self.b = nn.Parameter(torch.tensor(np.random.normal(0, 0.1, 1)))def cal(self, X, n):X = X.reshape(batch_size, 1, 1)Y = self.bfor i in range(n):# print(X.shape)# print(self.w_array.shape)# print(Y.shape)Y  = Y + torch.matmul(X**(i + 1)/torch.tensor(np.math.factorial(i + 1)), self.w_array[i])return Ydef forward(self, x):return self.cal(x, self.n)class TestNet(nn.Module):def __init__(self, n):super(TestNet, self).__init__()self.test_net = nn.Sequential(TestLayer(n))   def forward(self, x):return self.test_net(x)# copy from d2l/torch.py
def load_array(data_arrays, batch_size, is_train=True):"""Construct a PyTorch data iterator."""dataset = data.TensorDataset(*data_arrays)return data.DataLoader(dataset, batch_size, shuffle=is_train)# def data_loader(batch_size, features, labels):
#     num_examples = len(features)
#     indices = list(range(num_examples))
#     np.random.shuffle(indices) # 样本的读取顺序是随机的#     for i in range(0, num_examples, batch_size):
#         j = np.array(indices[i: min(i + batch_size, num_examples)])
#         yield torch.tensor(features.take(j, 0)), torch.tensor(labels.take(j)) # take函数根据索引返回对应元素def train(dataloader, model, loss_fn, optimizer):size = train_examplesnum_batches = train_examples / batch_sizetrain_loss_sum = 0for batch, (X, y) in enumerate(dataloader):# move X, y to gpuif torch.cuda.is_available():X = X.to('cuda')y = y.to('cuda')# Compute prediction and losspred = model(X)loss = loss_fn(pred, y)# Backpropagationoptimizer.zero_grad()loss.backward()optimizer.step()train_loss_sum += loss.item()if batch % 5 == 0:loss, current = loss.item(), batch * len(X)print(f"loss: {loss:>7f}  [{current:>5d}/{size:>5d}]")print(f"Train Error: \n Avg loss: {train_loss_sum/num_batches:>8f} \n")return train_loss_sum/num_batchesdef test(dataloader, model, loss_fn):num_batches = test_examples / batch_sizetest_loss = 0with torch.no_grad():for X, y in dataloader:# move X, y to gpuif torch.cuda.is_available():X = X.to('cuda')y = y.to('cuda')pred = model(X)test_loss += loss_fn(pred, y).item()test_loss /= num_batchesprint(f"Test Error: \n Avg loss: {test_loss:>8f} \n")return test_lossif __name__ == '__main__':device = 'cuda' if torch.cuda.is_available() else 'cpu'print('Using {} device'.format(device))true_w1 = [1.65]true_w2 = [-2.46]true_w3 = [3.54]true_b = 0.78    test_examples = 100train_examples = 100num_examples = test_examples + train_examplesf1, labels = synthetic_data([true_w1, true_w2, true_w3, true_b], num_examples)print(f1.shape)print(labels.shape)num_weight = 3l1_loss_fn = torch.nn.MSELoss()learning_rate = 0.01model = TestNet(num_weight)optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)model = model.to(device)print(model)epochs = 1500model.train()batch_size = 10train_data = (torch.tensor(f1[:train_examples,]), torch.tensor(labels[:train_examples,]))test_data = (torch.tensor(f1[train_examples:,]), torch.tensor(labels[train_examples:,]))train_dataloader = load_array(train_data ,batch_size, True)test_dataloader = load_array(test_data ,batch_size, True)# verify dataloader# for x,y in train_dataloader:#     print(x.shape)#     print(y.shape)#     print(torch.matmul(x**3, torch.tensor(true_w1, dtype=torch.double)) + torch.matmul(x**2, torch.tensor(true_w2, dtype=torch.double)) + torch.matmul(x, torch.tensor(true_w3, dtype=torch.double)) + true_b)#     print(y)#     breakmodel.train()for t in range(epochs):print(f"Epoch {t+1}\n-------------------------------")train_l = train(train_dataloader, model, l1_loss_fn, optimizer)test_l = test(test_dataloader, model, l1_loss_fn)ydata0.append(train_l*10)ydata1.append(test_l*10)xdata0.append(t)xdata1.append(t)print("Done!")init_and_show()param_iter = model.parameters()print('W = ')print(next(param_iter)[: num_weight, :])print('b = ')print(next(param_iter))