机器学习（四）：关于模型复杂度与模型性能的关系

  之前，我们分别使用线性模型以及二次模型对数据进行拟合，发现模型复杂度越高，越能贴合数据，预测精度越高。因此，我们是否可以认为只要算力条件充足，我们就可以尽可能地使用高复杂度模型进行函数的拟合？这就是本文讨论的主题：使用更复杂的模型会出现的问题以及解决方式。本文将分别使用线性模型、二次模型、五次模型以及七次模型分别进行房价数据的拟合，观察训练集和测试集的分布，以得到模型复杂度与模型性能的关系。
  为了使现象更加明显，我们这次仅取少量的数据进行实验：10个数据组成的训练集和5个数据组成的测试集。关于这么做的原因，我们将在下一篇文章中进行解释。数据导入部分代码：

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import random
# 导入数据
datasFile=pd.read_csv('data/data1810/data.txt',names=['size','price'])
datas=np.array(datasFile)
# 取前15个数据进行实验，并划分数据集，10个训练数据和5个测试数据
trainSet=datas[0:10,:]
testSet=datas[10:15,:]

trainX=trainSet[:,0]
trainY=trainSet[:,1]

testX=testSet[:,0]
testY=testSet[:,1]

# 归一化数据，最大最小值按照训练数据集来取
trainX_min_max=(trainX-np.min(trainX))/(np.max(trainX)-np.min(trainX));
trainY_min_max=(trainY-np.min(trainY))/(np.max(trainY)-np.min(trainY));

testX_min_max=(testX-np.min(testX))/(np.max(testX)-np.min(testX));
testY_min_max=(testY-np.min(testY))/(np.max(testY)-np.min(testY));

导入的数据分布如下：
训练集：

测试集：

一、使用线性模型进行房价预测

  首先使用线性模型进行房价预测：

import random
# 初始化回归相关参数值
a=random.random()# 随机初始化一个值
b=random.random()

x=trainX_min_max
y=trainY_min_max

lr=0.1# 学习率
iter=500 # 训练次数
cost=0
# 开始训练
for i in range(1,iter+1):
    predict=a*x+b # 使用线性函数进行预测
    # 计算损失函数
    J=np.mean((predict-y)*(predict-y))
    cost=np.append(cost,J)
    # 计算损失函数的梯度值
    J_grad_a=np.mean((predict-y)*x)
    J_grad_b=np.mean(predict-y)
    # 进行参数迭代
    a=a-lr*J_grad_a
    b=b-lr*J_grad_b
    # 打印参数的值
    if i % 100 == 0:
        print("iter=%d," % i)
        print("cost=%.3f" % J)
        print("a=%.3f," % a)
        print("b=%.3f," % b)
        print("\n")

plt.plot(cost)

训练结果如下：

最终训练集的误差为0.019
损失函数曲线：

表明算法已经收敛
将结果可视化：

使用训练好的模型进行测试：

# 进行预测
x=testX_min_max
y=testY_min_max
result=a*x+b
# 计算预测误差
err=np.mean((result-y)*(result-y))
# 打印误差
print('err=%.3f' % err)
# 绘制拟合结果
plt.scatter(x,y)
plt.scatter(testX_min_max,result)

测试结果如下：

误差为0.028

二、使用二次模型进行预测

import random
# 初始化回归相关参数值
a=random.random()# 随机初始化一个值
b=random.random()
c=random.random()

x=trainX_min_max
y=trainY_min_max

lr=0.1# 学习率
iter=500 # 训练次数
cost=0
# 开始训练
for i in range(1,iter+1):
    predict=a*x*x+b*x+c # 使用二次函数进行预测
    # 计算损失函数
    J=np.mean((predict-y)*(predict-y))
    cost=np.append(cost,J)
    # 计算损失函数的梯度值
    J_grad_a=np.mean((predict-y)*x*x)
    J_grad_b=np.mean((predict-y)*x)
    J_grad_c=np.mean(predict-y)
    # 进行参数迭代
    a=a-lr*J_grad_a
    b=b-lr*J_grad_b
    c=c-lr*J_grad_c
    # 打印参数的值
    if i % 100 == 0:
        print("iter=%d," % i)
        print("cost=%.3f" % J)
        print("a=%.3f," % a)
        print("b=%.3f," % b)
        print("c=%.3f," % c)

        print("\n")

plt.plot(cost)

训练结果如下：


可以看出，算法成功收敛，并且误差为0.016，效果优于线性模型，下面将模型运用到测试集上：

# 进行预测
x=testX_min_max
y=testY_min_max
result=a*x*x+b*x+c
# 计算预测误差
err=np.mean((result-y)*(result-y))
# 打印误差
print('err=%.3f' % err)
# 绘制拟合结果
plt.scatter(x,y)
plt.scatter(testX_min_max,result)

结果如下：

测试集正确率为0.019，优于线性模型，符合我们之前的结论：模型越复杂，效果越好

三、使用五次方模型进行预测

训练部分代码：

import random
# 初始化回归相关参数值
a=random.random()# 随机初始化一个值
b=random.random()
c=random.random()
d=random.random()
e=random.random()
f=random.random()

x=trainX_min_max
y=trainY_min_max

lr=0.1# 学习率
iter=500 # 训练次数
cost=0
# 开始训练
for i in range(1,iter+1):
    predict=a*np.power(x,5)+b*np.power(x,4)+c*np.power(x,3)+d*np.power(x,2)+e*x+f # 使用五次函数预测
    # 计算损失函数
    J=np.mean((predict-y)*(predict-y))
    cost=np.append(cost,J)
    # 计算损失函数的梯度值
    J_grad_a=np.mean((predict-y)*np.power(x,5))
    J_grad_b=np.mean((predict-y)*np.power(x,4))
    J_grad_c=np.mean((predict-y)*np.power(x,3))
    J_grad_d=np.mean((predict-y)*np.power(x,2))
    J_grad_e=np.mean((predict-y)*x)
    J_grad_f=np.mean(predict-y)
    # 进行参数迭代
    a=a-lr*J_grad_a
    b=b-lr*J_grad_b
    c=c-lr*J_grad_c
    d=d-lr*J_grad_d
    e=e-lr*J_grad_e
    f=f-lr*J_grad_f
    # 打印参数的值
    if i % 100 == 0:
        print("iter=%d," % i)
        print("cost=%.3f" % J)
        print("a=%.3f," % a)
        print("b=%.3f," % b)
        print("c=%.3f," % c)
        print("d=%.3f," % d)
        print("e=%.3f," % e)
        print("f=%.3f," % f)

        print("\n")

plt.plot(cost)

训练结果：


算法收敛，最终误差为0.015，优于二次模型，且预测更能贴合真实数据，下面来看测试集的效果：

# 进行预测
x=testX_min_max
y=testY_min_max
result=a*np.power(x,5)+b*np.power(x,4)+c*np.power(x,3)+d*np.power(x,2)+e*x+f
# 计算预测误差
err=np.mean((result-y)*(result-y))
# 打印误差
print('err=%.3f' % err)
# 绘制拟合结果
plt.scatter(x,y)
plt.scatter(testX_min_max,result)

结果如图：

误差为0.023，测试集效果不如线性模型和二次模型。

四、七次模型进行预测

训练部分：
代码：

import random
# 初始化回归相关参数值
a=random.random()# 随机初始化一个值
b=random.random()
c=random.random()
d=random.random()
e=random.random()
f=random.random()
g=random.random()
h=random.random()

x=trainX_min_max
y=trainY_min_max

lr=0.1# 学习率
iter=2000 # 训练次数
cost=0
# 开始训练
for i in range(1,iter+1):
    predict=a*np.power(x,7)+b*np.power(x,6)+c*np.power(x,5)+d*np.power(x,4)+e*np.power(x,3)+f*np.power(x,2)+g*x+h # 使用七次函数预测
    # 计算损失函数
    J=np.mean((predict-y)*(predict-y))
    cost=np.append(cost,J)
    # 计算损失函数的梯度值
    J_grad_a=np.mean((predict-y)*np.power(x,7))
    J_grad_b=np.mean((predict-y)*np.power(x,6))
    J_grad_c=np.mean((predict-y)*np.power(x,5))
    J_grad_d=np.mean((predict-y)*np.power(x,4))
    J_grad_e=np.mean((predict-y)*np.power(x,3))
    J_grad_f=np.mean((predict-y)*np.power(x,2))
    J_grad_g=np.mean((predict-y)*x)
    J_grad_h=np.mean(predict-y)

    # 进行参数迭代
    a=a-lr*J_grad_a
    b=b-lr*J_grad_b
    c=c-lr*J_grad_c
    d=d-lr*J_grad_d
    e=e-lr*J_grad_e
    f=f-lr*J_grad_f
    g=g-lr*J_grad_g
    h=h-lr*J_grad_h
    # 打印参数的值
    if i % 1000 == 0:
        print("iter=%d," % i)
        print("cost=%.3f" % J)
        print("a=%.3f," % a)
        print("b=%.3f," % b)
        print("c=%.3f," % c)
        print("d=%.3f," % d)
        print("e=%.3f," % e)
        print("f=%.3f," % f)
        print("g=%.3f," % g)
        print("h=%.3f," % h)

        print("\n")

plt.plot(cost)

训练结果如下：


算法收敛并且误差为0.012，优于上述所有模型。下面来看测试部分的结果：
代码：

# 进行预测
x=testX_min_max
y=testY_min_max
result=predict=a*np.power(x,7)+b*np.power(x,6)+c*np.power(x,5)+d*np.power(x,4)+e*np.power(x,3)+f*np.power(x,2)+g*x+h
# 计算预测误差
err=np.mean((result-y)*(result-y))
# 打印误差
print('err=%.3f' % err)
# 绘制拟合结果
plt.scatter(x,y)
plt.scatter(testX_min_max,result)

结果如下：

误差竟然高达0.027，效果与线性模型接近

五、总结与分析

  经过上述实验，我们发现，模型越复杂，训练集的误差越低，说明拟合结果确实越来越贴合训练数据，这是合乎情理的。但是我们同时发现，模型越复杂，测试集的误差不一定越低，甚至有可能变大。因此，模型复杂度越高，模型的性能不一定越好。那么我们有没有办法克服这个现象呢？下一篇文章，我们将介绍上述现象产生的原因以及解决方法。