2023年12月12日发(作者：电脑蓝屏修复按哪个键)

Python数据分析案例-利用多元线性回归与随机森林回归算法预测笔记本新品价

格

1.前言

目的：

本文通过多元线性回归与随机森林算法预测笔记本新品的发售价

工具：

语言：Python 3.8

软件：Jupyter Notebook

库：pandas、numpy、matplotlib、statsmodels、sklearn等

2.数据分析

2.1 数据来源

数据爬取自中关村（），为2021年上半年笔记本部分品牌新品，经过初步清洗之后，共包含：型号、品牌、价格、屏幕尺寸、分辨率、

CPU型号、CPU主频、显卡、内存容量、硬盘容量、重量、操作系统共12个特征。

下载地址见文末。

2.2 探索性分析

import pandas as pd

import numpy as np

import as plt

import seaborn as sns

ms['-serif'] = ['SimHei']

ms['e_minus'] = False

('fivethirtyeight')

import warnings

warnings("ignore")

数据加载及预览

#

数据加载

data = _excel('2021年上半年笔记本新品清单',index_col=0)

()

查看基本统计信息

()

共586行，12列

部分存在缺失值

描述统计

#

查看连续型变量描述统计

be().round(2)

#

定义一个绘制柱状图函数

def draw_bar(df, title):

fig, ax = ts(figsize=(15, 6))

(, )

_title(title)

for i,j in enumerate():

(i,j,j,va='bottom',ha='center')

(rotation=60)

()

看看各品牌上半年发布的各款式不同配置的数量

df_count = data['品牌'].value_counts()

draw_bar(df_count, '2021年上半年各品牌笔记本新品款式配置数量对比图')

大厂果然是大厂，产品线果然丰富

查看价格分布

(figsize=(12,6))

data['价格'].hist(bins=20)

()

价格呈现右偏分布，中位数价格为8199；

售价最高的可达53000，

售价最低的只有3299

看看5万3的笔记本到底是啥配置

("价格 == 53000")

果然不出意料，是壕无性价比可言的外星人。不过都卖5万多了，内存居然不是64g的，外星人可真有你的哦。

看看各品牌的价格中位数

df_price = y(['品牌'])['价格'].median().sort_values(ascending=False).astype("int")

draw_bar(df_price, '2021年上半年各品牌新笔记本品中位数价格对比图')

从价格中位数初步判断：

外星人超过25000，毕竟灯大灯亮灯会闪，手动狗头

而ROG在近年推出了魔霸等系列后，竟然有了一丝丝性价比的感觉，价格还不及雷蛇

国产游戏本机械革命、机械师、神舟、雷神价格相差无几，主打性价比

普通家用办公领域的笔记本价格相对游戏本较低不少，VAIO真信仰，价格比同为中高端办公本的微软、ThinkPad还要高一些

几大巨头华硕、戴尔、联想、惠普与近年来新入局的华为、小米 价格相差无几，华硕、戴尔稍高一些

红米、荣耀的价格则竞争他俩大哥的下一级低端市场

屏幕尺寸

df_screen = data['屏幕尺寸'].value_counts().sort_index()

df_ = df_("str")

draw_bar(df_screen , '2021年上半年各品牌笔记本新品屏幕尺寸分布'

笔记本屏幕尺寸主流大小为14与15.6

分辨率

df_resolution_ratio = data['分辨率'].value_counts()

draw_bar(df_resolution_ratio , '2021年上半年各品牌笔记本新品屏幕分辨率分布')

目前的新品，1080P还是主流，2k、3k、4k也仅限于部分高端机型中。

等等，居然还有1366*768的新品，这都2021年了！看看是哪家还在用如此辣眼睛的分辨率。

("分辨率 == '1366x768'")

366*768居然还卖六千多，人傻钱多戴果然名不虚传

CPU型号

#

筛选出各

cpu

所属品牌

data['CPU品牌'] = data['CPU型号'].(" ", expand=True)[0]

df_cpu_brand = data['CPU品牌'].value_counts()

draw_bar(df_cpu_brand, '2021年上半年各品牌笔记本新品CPU品牌分布')

Intel份额占据四分之三左右，AMD占据四分之一左右

海思和骁龙等移动端cpu的使用数量还是属于极个别

CPU主频

df_cpu_freq = data['CPU主频'].value_counts().sort_index()

df_cpu_ = df_cpu_("str")

draw_bar(df_cpu_freq, '2021年上半年各品牌笔记本新品CPU主频分布')

2.4GHz占据主流

最高可达3.7GHz

最低仅1.6GHz

来看看1.6GHz是啥处理器并且还有哪些机型再用

("CPU主频 == 1.6")

原来是i5-10210U，荣耀还在用英特尔十代cpu有点不厚道了

顺便看看3.5、3.7GHz的处理器

("CPU主频 >= 3.5")

未来人类yyds

话说作为英特尔旗舰系列，新一代i9-11900K与上一代i9-10900K相比，降主频，还少了两个核心，这波操作是没看懂，难道是觉得

十代的牙膏挤多了吸回来嘛

显卡

df_graphics_card = data['显卡'].value_counts()

draw_bar(df_graphics_card, '2021年上半年各品牌笔记本新品显卡分布')

集显数量最多

游戏显卡中，性价比较高的3060数量较多

部分产品还在使用上一代的显卡mx350,2060,甚至上上代的gtx 1650，让我们看看是哪些厂家在帮老黄清库存

("显卡.ns('MX 350|GTX|RTX 2')", engine='python')内存df_RAM = data['内存容量'].value_counts().sort_index()df_ = df_("str")

draw_bar(df_RAM, '2021年上半年各品牌笔记本新品内存分布')

主流内存为16G

好家伙，这年头居然还有4G内存的笔记本，手机都不止4G了

("内存容量 == 4")

赛扬配4G，这配置我直呼内行

硬盘容量

df_hard_drive= data['硬盘容量'].value_counts()

draw_bar(df_hard_drive, '2021年上半年各品牌笔记本新品硬盘分布')

硬盘容量512GB SSD为主流，1T SSD也占据了一定的数量

绝大多数新品均采用SSD固态硬盘，没想到在笔记本领域，机械硬盘快被淘汰了

重量

(figsize=(12,6))

data['重量'].hist(bins=20)

()

笔记本重量频数图有两个波峰，说明多数超极本的重量控制在1.5kg左右，家用笔记本与游戏本的重量在2-2.5kg

看看裸机重量超过4kg的笔记本

("重量 >= 4")

果然是GX8的新新新款，这就是习武之人的笔记本新宠嘛，爱了爱了

操作系统

df_system= data['操作系统'].value_counts()

draw_bar(df_system, '2021年上半年各品牌笔记本新品操作系统分布')

win10家庭版占据了绝大多数，少部分使用win10专业版，仅有一款笔记本使用国产的统信UOS操作系统

("操作系统 == 'UOS 20'")

在当前的环境下能有采用完全自主的CPU和系统的笔记本，确属不易，希望以后的国产笔记本自主化程度越来越高

2.3 特征工程

2.3.1 缺失值处理

查看缺失值数量与比例

#

查看缺失值数量与比例

(

ame({

"NaN_num": round(().sum(),2),

"NaN_percent":(().sum()/[0]).apply(lambda x:str(round(x*100,2))+'%') ,

})

.sort_values('NaN_num', ascending=False)

)

存在少量缺失值，保存只有价格缺失的数据，用于后续预测

删除所有缺失值

#

保存只有价格缺失的数据

pred_data = [(data['价格'].isnull()) & (~data[('价格')].isna().any(1))]

#

删除缺失值

(inplace=True)

2.3.2 相关性检验

查看相关系数图

(figsize=(12,10))

p((), annot=True, fmt='.2f')

()

CPU主频与价格基本没有相关性，将其删除

屏幕尺寸、重量与价格呈现弱相关性

内存与价格呈现中等强度的相关性

屏幕尺寸与重量呈现强共线性

屏幕尺寸和内存容量虽然是连续型变量，但可将其离散化作为分类变量处理

('CPU主频', axis=1, inplace=True)

2.3.3 数据转换

由探索性分析可知，价格呈现右偏分布。通常的做法是将其取对数处理，这样做之后因变量就变成了价格增长率，同样具有经济学上的意

义。

data['price_ln'] = (data['价格'])

#

查看偏度

print('价格对数转换前偏度：',data['价格'].skew())

#

查看转换后的偏度

print('价格对数转换后偏度：',data['price_ln'].skew())

价格对数转换前偏度： 2.2424

价格对数转换后偏度： 0.6876367722224298

查看转换前后的直方图与QQ图

from scipy import stats

from import norm, skew

def norm_test(data):

fig, ax = ts(nrows=1, ncols=2, figsize=(14, 5))

ot(data, fit=norm, ax=ax[0])

ot(data, plot=ax[1])

()

#

转换前

norm_test(data.价格)

转换后

norm_test(_ln)

价格相较于原来更符合正态分布

#

查看重量偏度

data['重量'].skew()

0.66866

偏度较小，所以就不做对数转换了

2.3.4 异常值处理

价格

数据在符合正态分布时，3倍标准差范围内的数为99.7%，超过这个范围可以认为是小概率事件。

# 3sigma

data[~data['price_ln'].apply(lambda x: (x - data['price_ln'].mean()) / data['price_ln'].std() <= 3)]

可以看到检测出的两款分别是玩家国度和外星人，除了价格外，各项配置基本拉满。由前面得探索性分析可知，玩家国度和外星人的价

格整体偏高，不删除这两项。

重量

#

绘制价格与重量分布散点图

r(data['重量'], data['价格'])

("重量")

("价格")

()

存在四个重量大于等于4的强影响点

删除强影响点

data = ("重量 < 4")

2.3.5 分箱

查看各分类变量的种类数量

cat_list = ['品牌', '屏幕尺寸', '分辨率', 'CPU型号', '显卡', '内存容量', '硬盘容量', '操作系统', 'CPU品牌']

data[cat_list].nunique()

可以看到各特征种类数量较多，所以接下来做分箱处理。

定义一个箱线图函数

#

定义一个箱线图函数

def draw_boxplot(feature):

fig, ax = ts(figsize=(15, 6))

t(x=feature, y='价格', data=data, ax=ax, linewidth=2)

(rotation=60)

()

品牌

draw_boxplot('品牌')

考虑到不同品牌的定位与价格，将电脑种类分为4类

brand_dict = {'game1':['外星人', '雷蛇', '微星', '技嘉', 'ROG'],

'game2':['未来人类', '机械革命', '机械师', '神舟', '雷神'],

'work1':['VAIO', '微软', 'ThinkPad'],

'work2':['联想', '惠普', '华硕', '戴尔', '小米', '华为','宏碁', '荣耀', '红米']}

def brand_func(x):

for key,values in brand_():

if x in values:

res = key

return res

data['brand_level'] = data['品牌'].apply(lambda x : brand_func(x))

data['brand_level'].value_counts()

分箱后的数量

屏幕尺寸

draw_boxplot('屏幕尺寸')

不同的屏幕大小代表笔记本的不同定位，一般来说14寸以下的为超极本，性能一般，讲究便携续航

14 为正常家用的笔记本

15.6 及以上的为游戏本居多

所以根据定位与价格，我们将屏幕分为4类

def func(x):

if x <= 13.9:

res = 's'

elif 13.9 < x <15 :

res = 'm'

elif 15 <= x < 16.2 :

res = 'l'

else:

res = 'xl'

return res

data['screen_level'] = data['屏幕尺寸'].apply(lambda x: func(x))

data['screen_level'].value_counts()

分辨率

draw_boxplot('分辨率')

一般来说，按照主流16:9的长宽比，1920×1080为1080p屏，2560×1440为2k屏，3200×1800为3k屏，3840×2160为

4k屏。

由于不同机型的屏幕长宽比(4:3、16:9、16:10等)不一样，导致分辨率的品种繁多，厂家的命名也充满噱头，什么2k+,2.5k之类的。

按照价格将其分类

def resolution_func(x):

if x in ['2560x1600', '1920x1080', '2160x1440', '2880x1800', '3200x2000', '2240x1400', '2520x1680', '2160x1350','1366x768']:

res = '1'

elif x in ['2560x1440', '1920x1200', '2256x1504', '3000x2000', '2736x1824', '2496x1664']:

res = '2'

else:

res = '3'

return res

data['resolution_level'] = data['分辨率'].apply(lambda x : resolution_func(x))

data['resolution_level'].value_counts()

CPU型号

#

提取处理器类别与最后的字母

tmp = data['CPU型号'].t("s(.*?d)sd+(w.?)")

data['CPU分类'] = tmp[0] + ' '+tmp[1]

#

像骁龙、海思处理器上面的正则表达式无法提取

,

结果为缺失值，所以将其赋值

data['CPU分类'].loc[data['CPU分类'].isnull()] = data['CPU型号']

draw_boxplot('CPU分类')

def cpu_func(x):

if x in ['酷睿i7 H', 'Ryzen 9 HX', '酷睿i7 G7','酷睿i9 H', '酷睿i9 HK', 'Ryzen 9 HS', 'Snapdragon 8cx 5G']:

res = '1'

else:

res = '2'

return res

data['cpu_level'] = data['CPU分类'].apply(lambda x : cpu_func(x))

data['cpu_level'].value_counts()显卡draw_boxplot('显卡')def card_func(x): if x in ['RTX 3050Ti', 'RTX 3050', 'GTX 1650', '集显', 'MX450', 'MX350', 'GTX 1650Ti']: res = '1' elif x in ['RTX 3060', 'RTX 3070', 'RTX 3060MQ', 'RTX 3070MQ']: res = '2' else: res = '3' return resdata['card_level'] = data['显卡'].apply(lambda x : card_func(x))data['card_level'].value_counts()内存draw_boxplot('内存容量')

4G与64G的数量太少，分别将其归入8G与32G中

def RAM_func(x):

if x in [4, 8]:

res = '8G及以下'

elif x == 16:

res = '16G'

else:

res = '32G及以上'

return res

data['RAM_level'] = data['内存容量'].apply(lambda x : RAM_func(x))

data['RAM_level'].value_counts()

硬盘容量

draw_boxplot('硬盘容量')data = ("硬盘容量 != '1TB HDD机械硬盘'") #

删除def hard_disk_func(x): if x in ['512GB SSD固态硬盘', '256GB SSD固态硬盘', '512GB+1TB 混合硬盘', '128GB SSD固态硬盘']: res = '1' elif x in ['1TB SSD固态硬盘', '1TB+2TB 混合硬盘', '512GB+1TB 混合硬盘', '512GB+1TB SSD固态硬盘']: res = '2' else: res = '3' return resdata['hard_disk_level'] = data['硬盘容量'].apply(lambda x : hard_disk_func(x))data['hard_disk_level'].value_counts()操作系统draw_boxplot('操作系统')删去UOS 20data = ("操作系统 != 'UOS 20' ")data['system'] = data['操作系统'].e(" ", "_")查看所有分完类的不同特征的价格是否存在差异tmp_list = [['RAM_level','brand_level','screen_level','resolution_level'], [ 'system','cpu_level','card_level','hard_disk_level']]

fig, ax = ts(ncols=2, nrows=4, figsize=(16, 20))for i,j in enumerate(tmp_list): for k, l in enumerate(j):

t(x= l, y='价格', data=data, ax=ax[k][i], linewidth=2)特征内的分类基本都存在差异2.4 建模2.4.1 划分测试集验证集from _selection import train_test_splittrain, test = train_test_split(data, test_size=0.2, random_state=42, )2.4.2 变量筛选

#

定义向前逐步回归函数

from import ols

def forward_select(data, target):

variate=set(s) #

将字段名转换成字典类型

(target) #

去掉因变量的字段名

selected=[]

current_score,best_new_score=float('inf'),float('inf') #

目前的分数和最好分数初始值都为无穷大（因为

AIC

越小越好）

#

循环筛选变量

while variate:

aic_with_variate=[]

for candidate in variate: #

逐个遍历自变量

formula="{}~{}".format(target,"+".join(selected+[candidate])) #

将自变量名连接起来

aic=ols(formula=formula,data=data).fit().aic #

利用

ols

训练模型得出

aic

值

aic_with_((aic,candidate)) #

将第每一次的

aic

值放进空列表

aic_with_(reverse=True) #

降序排序

aic

值

best_new_score,best_candidate=aic_with_() #

最好的

aic

值等于删除列表的最后一个值，以及最好的自变量等于列表最后一个自变量

if current_score>best_new_score: #

如果目前的

aic

值大于最好的

aic

值

(best_candidate) #

移除加进来的变量名，即第二次循环时，不考虑此自变量了

(best_candidate) #

将此自变量作为加进模型中的自变量

current_score=best_new_score #

最新的分数等于最好的分数

print("aic is {},continuing!".format(current_score)) #

输出最小的

aic

值

else:

print("for selection over!")

break

formula="{}~{}".format(target,"+".join(selected)) #

最终的模型式子

print("final formula is {}".format(formula))

delete_var = [i for i in variate if i not in selected]

print("剔除的变量为{}".format(delete_var)) #

打印删除的变量

model=ols(formula=formula,data=data).fit()

return model

variables = ['重量', 'brand_level', 'screen_level', 'resolution_level', 'cpu_level', 'card_level', 'RAM_level', 'hard_disk_level','system', 'price_ln']

ols_model = forward_select(train[variables], 'price_ln')

向前法剔除了屏幕大小

2.4.3 建模评估

ols_y()

2.4.4 模型解释

默认检验的显著性水平为0.05

(F-statistic)远小于0.05，证明模型是线性显著的，回归方程有意义。

2.R2：0.777，表示笔记本价格的77.7%能被其与多个自变量之间的线性关系解释。

3.回归系数coef：

截距系数为8.9582，p值小于0.001，显著，具有统计学意义

品牌类别game2相较game1价格低40.5%，p值小于0.001，差异显著

品牌类别work1相较于game1价格低8.04%，p值为0.220，差异不显著

品牌类别work2相较game1价格低37.55%，p值小于0.001，差异显著

显卡类别2相较类别1价格高21.19%，p值小于0.001，差异显著

显卡类别3相较类别1价格高51.81%，p值小于0.001，差异显著

硬盘类别2相较类别1价格高23.16%，p值小于0.001，差异显著

硬盘类别3相较类别1价格高25.81%，p值小于0.001，差异显著

分辨率类别2相较类别1价格高20.85%，p值小于0.001，差异显著

分辨率类别3相较类别1价格高35.72%，p值小于0.001，差异显著

内存类别32G及以上相较于16G价格高11.03%，p值为0.027，差异显著

内存类别8G及以下相较于16G价格低21.18%，p值小于0.001，差异显著

操作系统专业版比家庭版价格高27.95%，p值小于0.001，差异显著

cpu类别2相较于类别1价格低14%，p值为0.01，差异显著

重量系数为0.1522，表示重量每增加1kg，价格上涨15.22%，p值小于0.001，显著，具有统计学意义

4.通过输出ols_得到各特征系数，可构建回归方程

2.4.5 模型诊断

回归分析的基本假定：

1.自变量与因变量线性相关

2.自变量与误差项独立

3.自变量间相互独立。

4.误差项间不存在自相关。

5.误差项的方差齐性。

6.误差项应呈正态分布。

随机误差项是反应总体的误差，残差是反应样本的误差，由于随机误差项是不可观测的，所以一般用残差来估计随机误差项。

由之前的可知连续变量重量与价格有相关性。

自变量与误差项独立即要求没有其他的因素影响因变量，显然笔记本的价格还有其他因素影响，但是我收集到的数据就这些啦，┓( ´∀` )┏

摊手。

自变量间相互独立，即要求不存在多重共线性，查看上述的summary可知，模型没有提示存在多重共线性。

查看summary中的DW值，为1.994接近2，所以认为模型残差不存在自相关。

残差齐性检验

常见的残差分布图如下：

图a为方差齐性的残差分布图

#

残差齐性检验

train_pred = ols_t(train)

train_resid = ols_

r(train_pred, train_resid)

()

残差图没有明显的趋势，可以认为残差是齐性的

残差正态性检验

#

残差正态性检验

---

直方图与

QQ

图

norm_test(train_resid)残差近似符合正态分布2.4.6 模型效果评估from s import mean_squared_error, r2_score, explained_variance_scorepred_ols_model = ols_t(test)print('r2_score：', r2_score(_ln, pred_ols_model))

test['pred_price'] = (np.e, pred_ols_model)print('RMSE：', mean_squared_error(test['价格'], test['pred_price'])** 0.5)r2_score： 0.82244RMSE： 3499.9fig, ax = ts(figsize=(8,8))r(test['价格'], test['pred_price'])(xy1=(0, 0), xy2=(55000, 55000), linestyle='--', color='red')_xlabel('实际价格')_ylabel('预测价格')()

如果预测完全正确，所有的点应该分布在直线上。

试了几个变量交互项，效果并没有好多少，或许特征分类的时候还可以把品牌等更细分优化下

2.4.7 预测

爬取数据的时候联想拯救者Y900K新款还没公布价格，刚刚去翻了下居然公布价格了，来看看我们的模型预测价格与正式价格差多少。

pred_(1)

pred_df = (1).copy()

pred_df['重量'] = 2.5

pred_df['brand_level'] = 'work2'

pred_df['screen_level'] = 'l'

pred_df['cpu_level'] = '1'

pred_df['card_level'] = '2'

pred_df['RAM_level'] = '2'

pred_df['RAM_level'] = '16G'

pred_df['hard_disk_level'] = "2"

pred_df['system'] = "Windows_10_Home"

pred_df_value = ols_t(pred_df)

print(pred_(1)['型号'].values[0], '的预测价格为：', (np.e, pred_df_[0]))

联想拯救者Y9000K 2021(i7 11800H/16GB/1TB/RTX3060) 的预测价格为： 12169.965728061405

预测值与实际值居然只有170元的差距，狂喜

2.5 随机森林

2.5.1 特征转换

树模型是对一个特征中的多个值或连续值做切分，并找到符合目标最好的切分临界值。这种操作方式，如果在数值型索引下，可直接做切分

找最佳临界值；而如果做OneHotEncode后，原有的特征将会“稀疏化”。所以一般树模型特征无需进行OneHotEncode处理。

在本例中，之所以生成哑变量，是因为特征数量不多，哑变量处理后随机森林的效果好于OrdinalEncoder。

哑变量 vs OrdinalEncoder 处理后的R2： 0.8839 vs 0.8822343994588445

哑变量 vs OrdinalEncoder 处理后的RMSE： 2840.291594098016 vs 2914.578436639172

cat_list = [ 'RAM_level','brand_level', 'screen_level','resolution_level', 'system', 'cpu_level', 'card_level','hard_disk_level']

df = _dummies(data, columns=cat_list)

#

划分训练集测试集

train_X, train_y = [,][s[14:].tolist() + ['重量']], [,].price_ln

test_X, test_y = [,][s[14:].tolist() + ['重量']], [,].price_ln

2.5.2 默认参数效果

from le import RandomForestRegressor

RFR_model = RandomForestRegressor(random_state=43).fit(train_X, train_y)

RFR_preds = RFR_t(test_X)

print('模型默认参数验证集R2：', r2_score(test_y, RFR_preds))

test['pred_price_RFR'] = (np.e, RFR_preds)

print('模型默认参数验证集RMSE：',mean_squared_error(test['价格'], test['pred_price_RFR'])** 0.5)

模型默认参数验证集R2： 0.8839

模型默认参数验证集RMSE： 2840.291594098016

比线性回归效果提高了不少

2.5.3 网格搜索法调参

先设定一个步长较大的范围，通过RandomizedSearchCV来初步知道最优的参数的范围，再根据此结果选取邻近的范围，进行

GridSearchCV。这样可以提升训练速度。

%%time

from _selection import RandomizedSearchCV

RFR = RandomForestRegressor()

#

设置范围

n_estimators = (1, 1001, 100)

min_samples_split = [2, 7, 12, 17]

min_samples_leaf = [1, 4, 7, 10]

max_depth = [4, 7, 10, 13]

max_features = ['auto','sqrt']

bootstrap = [True,False]

#

需要调整的参数

random_params_group = {'n_estimators': n_estimators,

'min_samples_split': min_samples_split,

'min_samples_leaf': min_samples_leaf,

'max_depth': max_depth,

'max_features': max_features,

'bootstrap': bootstrap}

#

建立

RandomizedSearchCV

模型

random_search_model = RandomizedSearchCV(RFR, param_distributions = random_params_group, n_iter = 100,

scoring = 'neg_mean_squared_error' ,n_jobs = -1, cv = 3, random_state = 44)

#

训练数据

random_search_(train_X, train_y)

#

打印最佳参数

random_search__params_

精确查找

%%time

from _selection import GridSearchCV

#

网格搜索调参

n_estimators

param_grid = {'n_estimators': [150, 200, 250],

'min_samples_split': [2, 3, 4],

'min_samples_leaf': [1, 2, 3],

'max_depth': [9, 10, 11]}

RFR = RandomForestRegressor(random_state = 45)

grid_search_model = GridSearchCV(estimator=RFR, param_grid=param_grid,

scoring='neg_mean_squared_error', n_jobs = -1, cv=3)

grid_search_(train_X, train_y)

#

打印最佳参数

grid_search__params_

best_model = grid_search__estimator_

RFR_gs_preds = best_t(test_X)

print('模型默认参数验证集R2：', r2_score(test_y, RFR_gs_preds))

test['pred_price_RFR_gs'] = (np.e, RFR_gs_preds)

print('模型默认参数验证集RMSE：',mean_squared_error(test['价格'], test['pred_price_RFR_gs'])** 0.5)

模型默认参数验证集R2： 0.8898229302217273

模型默认参数验证集RMSE： 2736.9

相比默认参数有所提升，但有限

查看特征重要性

#

创建特征重要性

df

feature_importance= (ame({'feature': train_s,

'feature_importance': RFR_e_importances_})

.sort_values('feature_importance', ascending=False)

.round(4))

#

绘制

barh

图查看特征重要性排序

(figsize=(10, 15))

t(x='feature_importance', y='feature', data=feature_importance)

()

由上图可以看到各个特征对于模型的重要性，可以舍弃不重要的特征再次进行建模

2.5.4 预测

同样对联想拯救者价格预测

RFR_pred_data = [[1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 2.5]]

RFR_pred_value = best_t(RFR_pred_data)[0]

print(pred_(1)['型号'].values[0], '的随机森林回归预测价格为：', (np.e, RFR_pred_value))

联想拯救者Y9000K 2021(i7 11800H/16GB/1TB/RTX3060) 的随机森林回归预测价格为： 10924.8

个案误差比线性回归要大

3. 总结

本文分别使用线性回归与随机森林算法进行价格预测，线性回归R方0.82、RMSE3499.90，随机森林回归R方0.89、RMSE2736.92，

后者效果较好。

码字不易，若对您有所帮助，望能收藏点赞哈！