模型选择+过拟合和拟合

知识点

poly_features = np.power(features, np.arange(max_degree).reshape(1, -1))
# np.arange(max_degree) 生成一个从 0 到 max_degree-1 的数组，即 [0, 1, 2, ..., max_degree-1]。
# np.arange(max_degree).reshape(1, -1) 将生成的数组 reshape 成形状为 (1, max_degree)。
# np.power(features, np.arange(max_degree).reshape(1, -1)) 对 features 数组中的每个元素与 np.arange(max_degree).reshape(1, -1) 中的对应元素进行幂次计算。


np.arange(start, stop, step)
# 用于创建一个一维的数组，其中的元素按照指定的规则递增或递减。
# 其中 start 是起始值（包含），stop 是结束值（不包含），step 是步长。
# 如果只提供一个参数 stop，则默认起始值 start 为 0，步长 step 为 1。
np.arange(5)      # 输出 [0, 1, 2, 3, 4]
np.arange(1, 6)   # 输出 [1, 2, 3, 4, 5]
np.arange(1, 10, 2)   # 输出 [1, 3, 5, 7, 9]


reshape(1, -1) #是 NumPy 数组的一个方法，它用于改变数组的形状。reshape 方法接受一个或多个整数作为参数，指定了新的形状。
reshape(1, -1) 的参数解释如下：
# 第一个参数 1 指定新数组的行数为 1。
# 第二个参数 -1 表示列数根据原数组的大小自动计算。这样，通过 -1，NumPy 将会根据原始数组的大小和指定的行数，自动计算出新数组的列数。
np.arange(max_degree).reshape(1,-1)#将一维数组转换成二位数组


np.power(x, y) 的参数解释如下：
# x：数组，用作底数。
# y：数组或标量，用作指数。
import numpy as np

x = np.array([1, 2, 3, 4])
y = 2

result = np.power(x, y)
print(result)
# 输出：[ 1  4  9 16]

# 多个数组作为底数和指数
x = np.array([1, 2, 3, 4])
y = np.array([2, 3, 4, 5])

result = np.power(x, y)
print(result)
# 输出：[   1    8   81 1024]

拟合 

# 通过多项式拟合来交互地探索这些概念
import math
import numpy as np
import torch
from torch import nn
from d2l import torch as d2l

max_degree = 20 # 特征为20就是每一个样本是一个[20,1]的tensor
n_train, n_test = 100, 100 # 100个测试样本、100验证样本
true_w = np.zeros(max_degree)
print(true_w)
true_w[0:4] = np.array([5,1.2,-3.4,5.6]) # 真实标号为5
print(true_w)


features = np.random.normal(size=(n_train+n_test,1))
print('features.shape:',features.shape)
np.random.shuffle(features)
print('np.arange(max_degree):',np.arange(max_degree))
print("np.arange(max_degree).reshape(1,-1)",np.arange(max_degree).reshape(1,-1))
print(np.power([[10,20]],[[1,2]]))
# print("features:",features)
poly_features = np.power(features, np.arange(max_degree).reshape(1,-1)) # 对第所有维的特征取0次方、1次方、2次方...19次方
print("poly_features",poly_features)
for i in range(max_degree):
    poly_features[:,i] /= math.gamma(i+1) # i次方的特征除以(i+1)阶乘
labels = np.dot(poly_features,true_w) # 根据多项式生成y，即生成真实的labels
print('labels.shape:',labels.shape)
labels += np.random.normal(scale=0.1,size=labels.shape) # 对真实labels加噪音进去

#看一下前两个样本
true_w, features, poly_features, labels = [torch.tensor(x,dtype=torch.float32) for x in [true_w, features, poly_features, labels]]
print(features[:2]) # 前两个样本的x
print(poly_features[:2,:]) # 前两个样本的x的所有次方
print(labels[:2])  # 前两个样本的x对应的y

# 实现一个函数来评估模型在给定数据集上的损失
def evaluate_loss(net, data_iter, loss):
    """评估给定数据集上模型的损失"""
    metric = d2l.Accumulator(2) # 两个数的累加器
    for X, y in data_iter: # 从迭代器中拿出对应特征和标签
        out = net(X)
        y = y.reshape(out.shape) # 将真实标签改为网络输出标签的形式，统一形式
        l = loss(out, y) # 计算网络输出的预测值与真实值之间的损失差值
        metric.add(l.sum(), l.numel()) # 总量除以个数，等于平均
    return metric[0] / metric[1] # 返回数据集的平均损失

# 定义训练函数
def train(train_features, test_features, train_labels, test_labels, num_epochs=400):
    loss = nn.MSELoss()
    input_shape = train_features.shape[-1]
    net = nn.Sequential(nn.Linear(input_shape, 1, bias=False)) # 单层线性回归
    batch_size = min(10,train_labels.shape[0])
    train_iter = d2l.load_array((train_features,train_labels.reshape(-1,1)),batch_size)
    test_iter = d2l.load_array((test_features,test_labels.reshape(-1,1)),batch_size,is_train=False)
    trainer = torch.optim.SGD(net.parameters(),lr=0.01)
    animator = d2l.Animator(xlabel='epoch',ylabel='loss',yscale='log',xlim=[1,num_epochs],ylim=[1e-3,1e2],legend=['train','test'])
    for epoch in range(num_epochs):
        d2l.train_epoch_ch3(net, train_iter, loss, trainer)
        if epoch == 0 or (epoch + 1) % 20 == 0:
            animator.add(epoch + 1, (evaluate_loss(net, train_iter, loss), evaluate_loss(net,test_iter,loss)))
    print('weight',net[0].weight.data.numpy()) # 训练完后打印，打印最终学到的weight值

train(poly_features[:n_train, :4], poly_features[n_train:, :4], labels[:n_train],
          labels[n_train:])  # 最后返回的weight值和公式真实weight值很接近
d2l.plt.show()

欠拟合 

# 一阶多项式函数拟合(欠拟合)
# 这里相当于用一阶多项式拟合真实的三阶多项式，欠拟合了，损失很高，根本就没降
train(poly_features[:n_train,:2],poly_features[n_train:,:2],labels[:n_train],labels[n_train:])

过拟合

# 十九阶多项式函数拟合(过拟合)
# 这里相当于用十九阶多项式拟合真实的三阶多项式，过拟合了
train(poly_features[:n_train,:],poly_features[n_train:,:],labels[:n_train],labels[n_train:])