Loading...
首页专栏正文

机器学习(四):关于模型复杂度与模型性能的关系

 
1人已赏
技术凯 发布于 2021-02-23 18:08:14 浏览 3145 点赞 97 收藏 5

  之前,我们分别使用线性模型以及二次模型对数据进行拟合,发现模型复杂度越高,越能贴合数据,预测精度越高。因此,我们是否可以认为只要算力条件充足,我们就可以尽可能地使用高复杂度模型进行函数的拟合?这就是本文讨论的主题:使用更复杂的模型会出现的问题以及解决方式。本文将分别使用线性模型、二次模型、五次模型以及七次模型分别进行房价数据的拟合,观察训练集和测试集的分布,以得到模型复杂度与模型性能的关系。   为了使现象更加明显,我们这次仅取少量的数据进行实验: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,效果与线性模型接近

五、总结与分析

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

*本文仅代表作者观点,不代表易百纳技术社区立场。系作者授权易百纳技术社区发表,未经许可不得转载。

精彩评论

内容存在敏感词
打赏
打赏作者
技术凯
您的支持将鼓励我继续创作!
金额:
¥1 ¥5 ¥10 ¥50 ¥100
支付方式:
微信支付
支付宝支付
微信支付
打赏成功!

感谢您的打赏,如若您也想被打赏,可前往 发表专栏 哦~

易百纳技术社区
确定要删除此文章、专栏、评论吗?
确定
取消
易百纳技术社区