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

技术凯 2021-02-23 16:44:17 8589

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

五、总结与分析

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

声明:本文内容由易百纳平台入驻作者撰写,文章观点仅代表作者本人,不代表易百纳立场。如有内容侵权或者其他问题,请联系本站进行删除。
红包 97 5 评论 打赏
评论
0个
内容存在敏感词
手气红包
    易百纳技术社区暂无数据
相关专栏
置顶时间设置
结束时间
删除原因
  • 广告/SPAM
  • 恶意灌水
  • 违规内容
  • 文不对题
  • 重复发帖
打赏作者
易百纳技术社区
技术凯
您的支持将鼓励我继续创作!
打赏金额:
¥1易百纳技术社区
¥5易百纳技术社区
¥10易百纳技术社区
¥50易百纳技术社区
¥100易百纳技术社区
支付方式:
微信支付
支付宝支付
易百纳技术社区微信支付
易百纳技术社区
打赏成功!

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

举报反馈

举报类型

  • 内容涉黄/赌/毒
  • 内容侵权/抄袭
  • 政治相关
  • 涉嫌广告
  • 侮辱谩骂
  • 其他

详细说明

审核成功

发布时间设置
发布时间:
是否关联周任务-专栏模块

审核失败

失败原因
备注
拼手气红包 红包规则
祝福语
恭喜发财,大吉大利!
红包金额
红包最小金额不能低于5元
红包数量
红包数量范围10~50个
余额支付
当前余额:
可前往问答、专栏板块获取收益 去获取
取 消 确 定

小包子的红包

恭喜发财,大吉大利

已领取20/40,共1.6元 红包规则

    易百纳技术社区