零基础入门数据挖掘 - 二手车交易价格预测
赛题理解
比赛要求参赛选手根据给定的数据集，建立模型，二手汽车的交易价格。
赛题以预测二手车的交易价格为任务，数据集报名后可见并可下载，该数据来自某交易平台的二手车交易记录，总数据量超过40w，包含31列变量信息，其中15列为匿名变量。为了保证比赛的公平性，将会从中抽取15万条作为训练集，5万条作为测试集A，5万条作为测试集B，同时会对name、model、brand和regionCode等信息进行脱敏。
数据形式
训练数据集具有的特征如下：
- name - 汽车编码
- regDate - 汽车注册时间
- model - 车型编码
- brand - 品牌
- bodyType - 车身类型
- fuelType - 燃油类型
- gearbox - 变速箱
- power - 汽车功率
- kilometer - 汽车行驶公里
- notRepairedDamage - 汽车有尚未修复的损坏
- regionCode - 看车地区编码
- seller - 销售方
- offerType - 报价类型
- creatDate - 广告发布时间
- price - 汽车价格（目标列）
- v_0’, ‘v_1’, ‘v_2’, ‘v_3’, ‘v_4’, ‘v_5’, ‘v_6’, ‘v_7’, ‘v_8’, ‘v_9’, ‘v_10’, ‘v_11’, ‘v_12’, ‘v_13’,‘v_14’（根据汽车的评论、标签等大量信息得到的embedding向量）【人工构造 匿名特征】
预测指标
赛题要求采用mae作为评价指标
具体算法
导入相关库
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import missingno as msno
import scipy.stats as st
import warnings
warnings.filterwarnings('ignore')# 解决中文显示问题
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus']=False
数据分析
先读入数据：
train_data = pd.read_csv("used_car_train_20200313.csv", sep =" ")
用excel打开可以看到每一行数据都放下一个单元格中，彼此之间用空格分隔，因此此处需要指定sep为空格，才能够正确读入数据。
观看一下数据：
train_data.head(5).append(train_data.tail(5))
那么下面就开始对数据进行分析。
train_data.columns.values
array(['SaleID','name','regDate','model','brand','bodyType','fuelType','gearbox','power','kilometer','notRepairedDamage','regionCode','seller','offerType','creatDate','price','v_0','v_1','v_2','v_3','v_4','v_5','v_6','v_7','v_8','v_9','v_10','v_11','v_12','v_13','v_14'], dtype=object)
以上为数据具有的具体特征，那么可以先初步探索一下每个特征的数值类型以及取值等。
train_data.info()
<class'pandas.core.frame.DataFrame'>
RangeIndex:150000 entries,0 to 149999
Data columns (total 31 columns):# Column Non-Null Count Dtype ----------------------------0 SaleID 150000 non-null int64
1 name 150000 non-null int64
2 regDate 150000 non-null int64
3 model 149999 non-null float64
4 brand 150000 non-null int64
5 bodyType 145494 non-null float64
6 fuelType 141320 non-null float64
7 gearbox 144019 non-null float64
8 power 150000 non-null int64
9 kilometer 150000 non-null float64
10 notRepairedDamage 150000 non-null object11 regionCode 150000 non-null int64
12 seller 150000 non-null int64
13 offerType 150000 non-null int64
14 creatDate 150000 non-null int64
15 price 150000 non-null int64
16 v_0 150000 non-null float64
17 v_1 150000 non-null float64
18 v_2 150000 non-null float64
19 v_3 150000 non-null float64
20 v_4 150000 non-null float64
21 v_5 150000 non-null float64
22 v_6 150000 non-null float64
23 v_7 150000 non-null float64
24 v_8 150000 non-null float64
25 v_9 150000 non-null float64
26 v_10 150000 non-null float64
27 v_11 150000 non-null float64
28 v_12 150000 non-null float64
29 v_13 150000 non-null float64
30 v_14 150000 non-null float64
dtypes: float64(20), int64(10),object(1)
memory usage:35.5+ MB
可以看到除了notRepairedDamage是object类型，其他都是int或者float类型，同时可以看到部分特征还是存在缺失值的，因此这也是后续处理的重要方向。下面查看缺失值的情况：
train_data.isnull().sum()
SaleID 0
name 0
regDate 0
model 1
brand 0
bodyType 4506
fuelType 8680
gearbox 5981
power 0
kilometer 0
notRepairedDamage 0
regionCode 0
seller 0
offerType 0
creatDate 0
price 0
v_0 0
v_1 0
v_2 0
v_3 0
v_4 0
v_5 0
v_6 0
v_7 0
v_8 0
v_9 0
v_10 0
v_11 0
v_12 0
v_13 0
v_14 0
dtype: int64
可以看到是部分特征存在较多的缺失值的，因此这是需要处理的部分，下面对缺失值的数目进行可视化展示：
missing = train_data.isnull().sum()
missing = missing[missing >0]
missing.sort_values(inplace =True)
missing.plot.bar()
我们也可用多种方式来查看缺失值：
msno.matrix(train_data.sample(10000))
这种图中的白线代表为缺失值，可以看到中间的三个特征存在较多白线，说明其采样10000个的话其中仍然存在较多缺失值。
msno.bar(train_data.sample(10000))
上图中同样是那三个特征，非缺失值的个数也明显比其他特征少。
再回到最开始的数据类型处，我们可以发现notRepairedDamage特征的类型为object，因此我们可以来观察其具有几种取值：
train_data['notRepairedDamage'].value_counts()
0.0111361-243241.014315
Name: notRepairedDamage, dtype: int64
可以看到其存在"-“取值，这也可以认为是一种缺失值，因此我们可以将”-"转换为nan，然后再统一对nan进行处理。
而为了测试数据集也得到了相同的处理，因此读入数据集并合并：
test_data = pd.read_csv("used_car_testB_20200421.csv", sep =" ")
train_data["origin"]="train"
test_data["origin"]="test"
data = pd.concat([train_data, test_data], axis =0, ignore_index =True)
得到的data数据，是具有20000万条数据。那么可以统一对该数据集的notRepairedDamage特征进行处理：
data['notRepairedDamage'].replace("-", np.nan, inplace =True)
data['notRepairedDamage'].value_counts()
0.01485851.019022
Name: notRepairedDamage, dtype: int64
可以看到"-"已经被替换成了nan，因此在计数时没有被考虑在内。
而以下这两种特征的类别严重不平衡，这种情况可以认为它们对于结果的预测并不会起到什么作用：
data['seller'].value_counts()
019999911
Name: seller, dtype: int64
data["offerType"].value_counts()
0200000
Name: offerType, dtype: int64
因此可以对这两个特征进行删除：
del data["seller"]del data["offerType"]
以上是对特征的初步分析，那么接下来我们对目标列，也就是预测价格进行进一步的分析，先观察其分布情况：
target = train_data['price']
plt.figure(1)
plt.title('Johnson SU')
sns.distplot(target, kde=False, fit=st.johnsonsu)
plt.figure(2)
plt.title('Normal')
sns.distplot(target, kde=False, fit=st.norm)
plt.figure(3)
plt.title('Log Normal')
sns.distplot(target, kde=False, fit=st.lognorm)
我们可以看到价格的分布是极其不均匀的，这对预测是不利的，部分取值较为极端的例子将会对模型产生较大的影响，并且大部分模型及算法都希望预测的分布能够尽可能地接近正态分布，因此后期需要进行处理，那我们可以从偏度和峰度两个正态分布的角度来观察：
sns.distplot(target);print("偏度: %f"% target.skew())print("峰度: %f"% target.kurt())
偏度:3.346487
峰度:18.995183
对这种数据分布的处理，通常可以用log来进行压缩转换：
# 需要将其转为正态分布
sns.distplot(np.log(target))print("偏度: %f"% np.log(target).skew())print("峰度: %f"% np.log(target).kurt())
偏度:-0.265100
峰度:-0.171801
可以看到，经过log变换之后其分布相对好了很多，比较接近正态分布了。
接下来，我们对不同类型的特征进行观察，分别对类别特征和数字特征来观察。由于这里没有在数值类型上加以区分，因此我们需要人工挑选：
numeric_features =['power','kilometer','v_0','v_1','v_2','v_3','v_4','v_5','v_6','v_7','v_8','v_9','v_10','v_11','v_12','v_13','v_14']
categorical_features =['name','model','brand','bodyType','fuelType','gearbox','notRepairedDamage','regionCode',]
那么对于类别型特征，我们可以查看其具有多少个取值，是否能够转换one-hot向量：
# 对于类别型的特征需要查看其取值有多少个，能不能转换为onehotfor feature in categorical_features:print(feature,"特征有{}个取值".format(train_data[feature].nunique()))print(train_data[feature].value_counts())
name 特征有99662个取值
387282708282552801541263203233...26403128450132544110217411847301
Name: name, Length:99662, dtype: int64
model 特征有248个取值
0.01176219.095734.084451.0603829.05186...242.02209.02245.02240.02247.01
Name: model, Length:248, dtype: int64
brand 特征有40个取值
03148041673714160891014249113794610217973065466513381711294532461723611622238207725206427205321154715145819138820123612110922108526966309401791324772286493259229406373332321313181831636228342273321823186351803865399
Name: brand, dtype: int64
bodyType 特征有8个取值
0.0414201.0352722.0303243.0134914.096095.076076.064827.01289
Name: bodyType, dtype: int64
fuelType 特征有7个取值
0.0916561.0469912.022123.02624.01185.0456.036
Name: fuelType, dtype: int64
gearbox 特征有2个取值
0.01116231.032396
Name: gearbox, dtype: int64
notRepairedDamage 特征有2个取值
0.01113611.014315
Name: notRepairedDamage, dtype: int64
regionCode 特征有7905个取值
419369764258125137176136462134...7081172431731917742179601
Name: regionCode, Length:7905, dtype: int64
可以看到name和regionCode 有很多个取值，因此不能转换为onthot，其他是可以的。
而对于数值特征，我们可以来查看其与价格之间的相关性关系，这也有利于我们判断哪些特征更加重要：
numeric_features.append("price")
price_numeric = train_data[numeric_features]
correlation_score = price_numeric.corr()# 得到是一个特征数*特征数的矩阵，元素都行和列对应特征之间的相关性
correlation_score['price'].sort_values(ascending =False)
price 1.000000
v_12 0.692823
v_8 0.685798
v_0 0.628397
power 0.219834
v_5 0.164317
v_2 0.085322
v_6 0.068970
v_1 0.060914
v_14 0.035911
v_13 -0.013993
v_7 -0.053024
v_4 -0.147085
v_9 -0.206205
v_10 -0.246175
v_11 -0.275320
kilometer -0.440519
v_3 -0.730946
Name: price, dtype: float64
可以看到，例如v14,v13,v1,v7这种跟price之间的相关系数实在是过低，如果是在计算资源有限的情况下可以考虑舍弃这部分特征。我们也可以直观的展示相关性：
fig,ax = plt.subplots(figsize =(12,12))
plt.title("相关性展示")
sns.heatmap(correlation_score, square =True, vmax =0.8)
对于数值特征来说，我们同样关心其分布，下面先具体分析再说明分布的重要性：
# 查看特征值的偏度和峰度for col in numeric_features:print("{:15}\t Skewness:{:05.2f}\t Kurtosis:{:06.2f}".format(col,
train_data[col].skew(),
train_data[col].kurt()))
power Skewness:65.86 Kurtosis:5733.45
kilometer Skewness:-1.53 Kurtosis:001.14
v_0 Skewness:-1.32 Kurtosis:003.99
v_1 Skewness:00.36 Kurtosis:-01.75
v_2 Skewness:04.84 Kurtosis:023.86
v_3 Skewness:00.11 Kurtosis:-00.42
v_4 Skewness:00.37 Kurtosis:-00.20
v_5 Skewness:-4.74 Kurtosis:022.93
v_6 Skewness:00.37 Kurtosis:-01.74
v_7 Skewness:05.13 Kurtosis:025.85
v_8 Skewness:00.20 Kurtosis:-00.64
v_9 Skewness:00.42 Kurtosis:-00.32
v_10 Skewness:00.03 Kurtosis:-00.58
v_11 Skewness:03.03 Kurtosis:012.57
v_12 Skewness:00.37 Kurtosis:000.27
v_13 Skewness:00.27 Kurtosis:-00.44
v_14 Skewness:-1.19 Kurtosis:002.39
price Skewness:03.35 Kurtosis:019.00
可以看到power特征的偏度和峰度都非常大，那么把分布图画出来：
f = pd.melt(train_data, value_vars=numeric_features)# 这里相当于f是一个两列的矩阵，第一列是原来特征# 第二列是特征对应的取值，例如power有n个取值，那么它会占据n行，这样叠在一起
g = sns.FacetGrid(f, col="variable", col_wrap=2, sharex=False, sharey=False)#g 是产生一个对象，可以用来应用各种图面画图，map应用# 第一个参数就是dataframe数据，但是要求是长数据，也就是melt处理完的数据# 第二个参数是用来画图依据的列，valiable是melt处理完，那些特征的列名称# 而那些值的列名称为value# 第三个参数col_wrap是代表分成多少列
g = g.map(sns.distplot,"value")
关于melt的使用可以看使用Pandas melt()重塑DataFrame - 知乎 (zhihu.com)，我觉得讲得非常容易理解。
可以看到power的分布非常不均匀，那么跟price同样，如果出现较大极端值的power，就会对结果产生非常严重的影响，这就使得在学习的时候关于power 的权重设定非常不好做。因此后续也需要对这部分进行处理。而匿名的特征的分布相对来说会比较均匀一点，后续可能就不需要进行处理了。
还可以通过散点图来观察两两之间大概的关系分布：
sns.pairplot(train_data[numeric_features], size =2, kind ="scatter",diag_kind ="kde")
(这部分就自己看自己发挥吧)
下面继续回到类别型特征，由于其中存在nan不方便我们画图展示，因此我们可以先将nan进行替换，方便画图展示：
# 下面对类别特征做处理
categorical_features_2 =['model','brand','bodyType','fuelType','gearbox','notRepairedDamage']for c in categorical_features_2:
train_data[c]= train_data[c].astype("category")# 将这些的类型转换为分类类型，不保留原来的int或者float类型if train_data[c].isnull().any():# 如果该列存在nan的话
train_data[c]= train_data[c].cat.add_categories(['Missing'])# 增加一个新的分类为missing，用它来填充那些nan，代表缺失值，# 这样在后面画图方便展示
train_data[c]= train_data[c].fillna('Missing')
下面通过箱型图来对类别特征的每个取值进行直观展示：
defbar_plot(x, y,**kwargs):
sns.barplot(x = x, y = y)
x = plt.xticks(rotation =90)
f = pd.melt(train_data, id_vars =['price'], value_vars = categorical_features_2)
g = sns.FacetGrid(f, col ='variable', col_wrap =2, sharex =False, sharey =False)
g = g.map(bar_plot,"value","price")
这可以看到类别型特征相对来说分布也不会出现极端情况。
特征工程
在特征处理中，最重要的我觉得是对异常数据的处理。之前我们已经看到了power特征的分布尤为不均匀，那么这部分有两种处理方式，一种是对极端值进行舍去，一部分是采用log的方式进行压缩，那么这里都进行介绍。
首先是对极端值进行舍去，那么可以采用箱型图来协助判断，下面封装一个函数实现：
# 主要就是power的值分布太过于异常，那么可以对一些进行处理，删除掉# 下面定义一个函数用来处理异常值defoutliers_proc(data, col_name, scale =3):# data：原数据# col_name：要处理异常值的列名称# scale：用来控制删除尺度的defbox_plot_outliers(data_ser, box_scale):
iqr = box_scale *(data_ser.quantile(0.75)- data_ser.quantile(0.25))# quantile是取出数据对应分位数的数值
val_low = data_ser.quantile(0.25)- iqr # 下界
val_up = data_ser.quantile(0.75)+ iqr # 上界
rule_low =(data_ser < val_low)# 筛选出小于下界的索引
rule_up =(data_ser > val_up)# 筛选出大于上界的索引return(rule_low, rule_up),(val_low, val_up)
data_n = data.copy()
data_series = data_n[col_name]# 取出对应数据
rule, values = box_plot_outliers(data_series, box_scale = scale)
index = np.arange(data_series.shape[0])[rule[0]| rule[1]]# 先产生0到n-1，然后再用索引把其中处于异常值的索引取出来print("Delete number is {}".format(len(index)))
data_n = data_n.drop(index)# 整行数据都丢弃
data_n.reset_index(drop =True, inplace =True)# 重新设置索引print("Now column number is:{}".format(data_n.shape[0]))
index_low = np.arange(data_series.shape[0])[rule[0]]
outliers = data_series.iloc[index_low]# 小于下界的值print("Description of data less than the lower bound is:")print(pd.Series(outliers).describe())
index_up = np.arange(data_series.shape[0])[rule[1]]
outliers = data_series.iloc[index_up]print("Description of data larger than the lower bound is:")print(pd.Series(outliers).describe())
fig, axes = plt.subplots(1,2,figsize =(10,7))
ax1 = sns.boxplot(y = data[col_name], data = data, palette ="Set1", ax = axes[0])
ax1.set_title("处理异常值前")
ax2 = sns.boxplot(y = data_n[col_name], data = data_n, palette ="Set1", ax = axes[1])
ax2.set_title("处理异常值后")return data_n
我们应用于power数据集尝试：
train_data_delete_after = outliers_proc(train_data,"power", scale =3)
Delete number is963
Now column number is:149037
Description of data less than the lower bound is:
count 0.0
mean NaN
std NaN
min NaN
25% NaN
50% NaN
75% NaN
max NaN
Name: power, dtype: float64
Description of data larger than the lower bound is:
count 963.000000
mean 846.836968
std 1929.418081min376.00000025%400.00000050%436.00000075%514.000000max19312.000000
Name: power, dtype: float64
可以看到总共删除了900多条数据，使得最终的箱型图也正常许多。
那么另外一种方法就是采用log进行压缩，但这里因为我还想用power进行数据分桶，构造出一个power等级的特征，因此我就先构造再进行压缩：
bin_power =[i*10for i inrange(31)]
data["power_bin"]= pd.cut(data["power"],bin_power,right =False,labels =False)
这种方法就是将power按照bin_power的数值进行分段，最低一段在新特征中取值为1，以此类推，但是这样会导致大于最大一段的取值为nan，也就是power取值大于300的在power_bin中取值为nan，因此可以设置其等级为31来处理：
data['power_bin']= data['power_bin'].fillna(31)
那么对于power现在就可以用log进行压缩了：
data['power']= np.log(data['power']+1)
接下来进行新特征的构造。
首先是使用时间，我们可以用creatDate减去regDate来表示：
data["use_time"]=(pd.to_datetime(data['creatDate'],format="%Y%m%d",errors ="coerce")- pd.to_datetime(data["regDate"],format="%Y%m%d", errors ="coerce")).dt.days
# errors是当格式转换错误就赋予nan
而这种处理方法由于部分数据日期的缺失，会导致存在缺失值，那么我的处理方法是填充为均值，但是测试集的填充也需要用训练数据集的均值来填充，因此我放到后面划分的时候再来处理。
下面是对品牌的销售统计量创造特征，因为要计算某个品牌的销售均值、最大值、方差等等数据，因此我们需要在训练数据集上计算，测试数据集是未知的，计算完毕后再根据品牌一一对应填上数值即可：
# 计算某个品牌的各种统计数目量
train_gb = train_data.groupby("brand")
all_info ={}for kind, kind_data in train_gb:
info ={}
kind_data = kind_data[kind_data["price"]>0]# 把价格小于0的可能存在的异常值去除
info["brand_amount"]=len(kind_data)# 该品牌的数量
info["brand_price_max"]= kind_data.price.max()# 该品牌价格最大值
info["brand_price_min"]= kind_data.price.min()# 该品牌价格最小值
info["brand_price_median"]= kind_data.price.median()# 该品牌价格中位数
info["brand_price_sum"]= kind_data.price.sum()# 该品牌价格总和
info["brand_price_std"]= kind_data.price.std()# 方差
info["brand_price_average"]=round(kind_data.price.sum()/(len(kind_data)+1),2)# 均值，保留两位小数
all_info[kind]= info
brand_feature = pd.DataFrame(all_info).T.reset_index().rename(columns ={"index":"brand"})
这里的brand_feature获得方法可能有点复杂，我一步步解释出来：
brand_feature = pd.DataFrame(all_info)
brand_feature
这里是7个统计量特征作为索引，然后有40列代表有40个品牌。
brand_feature = pd.DataFrame(all_info).T.reset_index()
brand_feature
转置后重新设置索引，也就是：
将品牌统计量作为列，然后加入一个列为index，可以认为是品牌的取值。
brand_feature = pd.DataFrame(all_info).T.reset_index().rename(columns ={"index":"brand"})
brand_feature
这一个就是将index更名为brand，这一列就是品牌的取值，方便我们后续融合到data中：
data = data.merge(brand_feature, how='left', on='brand')
这就是将data中的brand取值和刚才那个矩阵中的取值一一对应，然后取出对应的特征各个值，作为新的特征。
接下来需要对大部分数据进行归一化：
defmax_min(x):return(x - np.min(x))/(np.max(x)- np.min(x))for feature in["brand_amount","brand_price_average","brand_price_max","brand_price_median","brand_price_min","brand_price_std","brand_price_sum","power","kilometer"]:
data[feature]= max_min(data[feature])
对类别特征进行encoder：
# 对类别特征转换为onehot
data = pd.get_dummies(data, columns=['model','brand','bodyType','fuelType','gearbox','notRepairedDamage','power_bin'],dummy_na=True)
对没用的特征可以进行删除了：
data = data.drop(['creatDate',"regDate","regionCode"], axis =1)
至此，关于特征的处理工作基本上就完成了，但是这只是简单的处理方式，可以去探索更加深度的特征信息（我不会哈哈哈哈）。
建立模型
先处理数据集：
use_feature =[x for x in data.columns if x notin['SaleID',"name","price","origin"]]
target = data[data["origin"]=="train"]["price"]
target_lg =(np.log(target+1))
train_x = data[data["origin"]=="train"][use_feature]
test_x = data[data["origin"]=="test"][use_feature]
train_x["use_time"]= train_x["use_time"].fillna(train_x["use_time"].mean())
test_x["use_time"]= test_x["use_time"].fillna(train_x["use_time"].mean())# 用训练数据集的均值填充
train_x.shape
(150000,371)
可以看看训练数据是否还存在缺失值：
test_x.isnull().sum()
power 0
kilometer 0
v_0 0
v_1 0
v_2 0
v_3 0
v_4 0
v_5 0
v_6 0
v_7 0
v_8 0
v_9 0
v_10 0
v_11 0
v_12 0
v_13 0
v_14 0
use_time 0
brand_amount 0
brand_price_max 0
brand_price_min 0
brand_price_median 0
brand_price_sum 0
brand_price_std 0
brand_price_average 0
model_0.00
model_1.00
model_2.00
model_3.00
model_4.00
model_5.00
model_6.00
model_7.00
model_8.00
model_9.00
model_10.00
model_11.00
model_12.00
model_13.00
model_14.00
model_15.00
model_16.00
model_17.00
model_18.00
model_19.00
model_20.00
model_21.00
model_22.00
model_23.00
model_24.00
model_25.00
model_26.00
model_27.00
model_28.00
model_29.00
model_30.00
model_31.00
model_32.00
model_33.00
model_34.00
model_35.00
model_36.00
model_37.00
model_38.00
model_39.00
model_40.00
model_41.00
model_42.00
model_43.00
model_44.00
model_45.00
model_46.00
model_47.00
model_48.00
model_49.00
model_50.00
model_51.00
model_52.00
model_53.00
model_54.00
model_55.00
model_56.00
model_57.00
model_58.00
model_59.00
model_60.00
model_61.00
model_62.00
model_63.00
model_64.00
model_65.00
model_66.00
model_67.00
model_68.00
model_69.00
model_70.00
model_71.00
model_72.00
model_73.00
model_74.00
model_75.00
model_76.00
model_77.00
model_78.00
model_79.00
model_80.00
model_81.00
model_82.00
model_83.00
model_84.00
model_85.00
model_86.00
model_87.00
model_88.00
model_89.00
model_90.00
model_91.00
model_92.00
model_93.00
model_94.00
model_95.00
model_96.00
model_97.00
model_98.00
model_99.00
model_100.00
model_101.00
model_102.00
model_103.00
model_104.00
model_105.00
model_106.00
model_107.00
model_108.00
model_109.00
model_110.00
model_111.00
model_112.00
model_113.00
model_114.00
model_115.00
model_116.00
model_117.00
model_118.00
model_119.00
model_120.00
model_121.00
model_122.00
model_123.00
model_124.00
model_125.00
model_126.00
model_127.00
model_128.00
model_129.00
model_130.00
model_131.00
model_132.00
model_133.00
model_134.00
model_135.00
model_136.00
model_137.00
model_138.00
model_139.00
model_140.00
model_141.00
model_142.00
model_143.00
model_144.00
model_145.00
model_146.00
model_147.00
model_148.00
model_149.00
model_150.00
model_151.00
model_152.00
model_153.00
model_154.00
model_155.00
model_156.00
model_157.00
model_158.00
model_159.00
model_160.00
model_161.00
model_162.00
model_163.00
model_164.00
model_165.00
model_166.00
model_167.00
model_168.00
model_169.00
model_170.00
model_171.00
model_172.00
model_173.00
model_174.00
model_175.00
model_176.00
model_177.00
model_178.00
model_179.00
model_180.00
model_181.00
model_182.00
model_183.00
model_184.00
model_185.00
model_186.00
model_187.00
model_188.00
model_189.00
model_190.00
model_191.00
model_192.00
model_193.00
model_194.00
model_195.00
model_196.00
model_197.00
model_198.00
model_199.00
model_200.00
model_201.00
model_202.00
model_203.00
model_204.00
model_205.00
model_206.00
model_207.00
model_208.00
model_209.00
model_210.00
model_211.00
model_212.00
model_213.00
model_214.00
model_215.00
model_216.00
model_217.00
model_218.00
model_219.00
model_220.00
model_221.00
model_222.00
model_223.00
model_224.00
model_225.00
model_226.00
model_227.00
model_228.00
model_229.00
model_230.00
model_231.00
model_232.00
model_233.00
model_234.00
model_235.00
model_236.00
model_237.00
model_238.00
model_239.00
model_240.00
model_241.00
model_242.00
model_243.00
model_244.00
model_245.00
model_246.00
model_247.00
model_nan 0
brand_0.00
brand_1.00
brand_2.00
brand_3.00
brand_4.00
brand_5.00
brand_6.00
brand_7.00
brand_8.00
brand_9.00
brand_10.00
brand_11.00
brand_12.00
brand_13.00
brand_14.00
brand_15.00
brand_16.00
brand_17.00
brand_18.00
brand_19.00
brand_20.00
brand_21.00
brand_22.00
brand_23.00
brand_24.00
brand_25.00
brand_26.00
brand_27.00
brand_28.00
brand_29.00
brand_30.00
brand_31.00
brand_32.00
brand_33.00
brand_34.00
brand_35.00
brand_36.00
brand_37.00
brand_38.00
brand_39.00
brand_nan 0
bodyType_0.00
bodyType_1.00
bodyType_2.00
bodyType_3.00
bodyType_4.00
bodyType_5.00
bodyType_6.00
bodyType_7.00
bodyType_nan 0
fuelType_0.00
fuelType_1.00
fuelType_2.00
fuelType_3.00
fuelType_4.00
fuelType_5.00
fuelType_6.00
fuelType_nan 0
gearbox_0.00
gearbox_1.00
gearbox_nan 0
notRepairedDamage_0.00
notRepairedDamage_1.00
notRepairedDamage_nan 0
power_bin_0.00
power_bin_1.00
power_bin_2.00
power_bin_3.00
power_bin_4.00
power_bin_5.00
power_bin_6.00
power_bin_7.00
power_bin_8.00
power_bin_9.00
power_bin_10.00
power_bin_11.00
power_bin_12.00
power_bin_13.00
power_bin_14.00
power_bin_15.00
power_bin_16.00
power_bin_17.00
power_bin_18.00
power_bin_19.00
power_bin_20.00
power_bin_21.00
power_bin_22.00
power_bin_23.00
power_bin_24.00
power_bin_25.00
power_bin_26.00
power_bin_27.00
power_bin_28.00
power_bin_29.00
power_bin_31.00
power_bin_nan 0
dtype: int64
可以看到都没有缺失值了，因此接下来可以用来选择模型了。
由于现实原因（电脑跑不动xgboost）因此我选择了lightGBM和随机森林、梯度提升决策树三种，然后再用模型融合，具体代码如下：
from sklearn import metrics
import matplotlib.pyplot as plt
from sklearn.metrics import roc_auc_score, roc_curve, mean_squared_error,mean_absolute_error, f1_score
import lightgbm as lgb
import xgboost as xgb
from sklearn.ensemble import RandomForestRegressor as rfr
from sklearn.model_selection import KFold, StratifiedKFold,GroupKFold, RepeatedKFold
from sklearn.model_selection import train_test_split
from sklearn.model_selection import GridSearchCV
from sklearn import preprocessing
from sklearn.metrics import mean_absolute_error
from sklearn.ensemble import GradientBoostingRegressor as gbr
from sklearn.linear_model import LinearRegression as lr
lightGBM：
lgb_param ={# 这是训练的参数列表"num_leaves":7,"min_data_in_leaf":20,# 一个叶子上最小分配到的数量，用来处理过拟合"objective":"regression",# 设置类型为回归"max_depth":-1,# 限制树的最大深度，-1代表没有限制"learning_rate":0.003,"boosting":"gbdt",# 用gbdt算法"feature_fraction":0.50,# 每次迭代时使用18%的特征参与建树，引入特征子空间的多样性"bagging_freq":1,# 每一次迭代都执行bagging"bagging_fraction":0.55,# 每次bagging在不进行重采样的情况下随机选择55%数据训练"bagging_seed":1,"metric":'mean_absolute_error',"lambda_l1":0.5,"lambda_l2":0.5,"verbosity":-1# 打印消息的详细程度}
folds = StratifiedKFold(n_splits=5, shuffle=True, random_state =4)# 产生一个容器，可以用来对对数据集进行打乱的5次切分，以此来进行五折交叉验证
valid_lgb = np.zeros(len(train_x))
predictions_lgb = np.zeros(len(test_x))for fold_,(train_idx, valid_idx)inenumerate(folds.split(train_x, target)):# 切分后返回的训练集和验证集的索引print("fold n{}".format(fold_+1))# 当前第几折
train_data_now = lgb.Dataset(train_x.iloc[train_idx], target_lg[train_idx])
valid_data_now = lgb.Dataset(train_x.iloc[valid_idx], target_lg[valid_idx])# 取出数据并转换为lgb的数据
num_round =10000
lgb_model = lgb.train(lgb_param, train_data_now, num_round,
valid_sets=[train_data_now, valid_data_now], verbose_eval=500,
early_stopping_rounds =800)
valid_lgb[valid_idx]= lgb_model.predict(train_x.iloc[valid_idx],
num_iteration=lgb_model.best_iteration)
predictions_lgb += lgb_model.predict(test_x, num_iteration=
lgb_model.best_iteration)/ folds.n_splits
# 这是将预测概率进行平均print("CV score: {:<8.8f}".format(mean_absolute_error(valid_lgb, target_lg)))
这里需要注意我进入训练时split用的是target，而在其中价格用的是target_lg，因为target是原始的价格，可以认为是离散的取值，但是我target_lg经过np.log之后，我再用target_lg进行split时就会报错，为：
Supported target types are: (‘binary’, ‘multiclass’). Got ‘continuous’ instead.
我认为是np.nan将其转换为了连续型数值，而不是原来的离散型数值取值，因此我只能用target去产生切片索引。
CV score:0.15345674
同样，观察一下特征重要性：
pd.set_option("display.max_columns",None)# 设置可以显示的最大行和最大列
pd.set_option('display.max_rows',None)# 如果超过就显示省略号，none表示不省略#设置value的显示长度为100，默认为50
pd.set_option('max_colwidth',100)# 创建，然后只有一列就是刚才所使用的的特征
df = pd.DataFrame(train_x.columns.tolist(), columns=['feature'])
df['importance']=list(lgb_model.feature_importance())
df = df.sort_values(by='importance', ascending=False)# 降序排列
plt.figure(figsize =(14,28))
sns.barplot(x='importance', y='feature', data = df.head(50))# 取出前五十个画图
plt.title('Features importance (averaged/folds)')
plt.tight_layout()# 自动调整适应范围
可以看到使用时间遥遥领先。
随机森林：
#RandomForestRegressor随机森林
folds = KFold(n_splits=5, shuffle=True, random_state=2019)
valid_rfr = np.zeros(len(train_x))
predictions_rfr = np.zeros(len(test_x))for fold_,(trn_idx, val_idx)inenumerate(folds.split(train_x, target)):print("fold n°{}".format(fold_+1))
tr_x = train_x.iloc[trn_idx]
tr_y = target_lg[trn_idx]
rfr_model = rfr(n_estimators=1600,max_depth=9, min_samples_leaf=9,
min_weight_fraction_leaf=0.0,max_features=0.25,
verbose=1,n_jobs=-1)#并行化#verbose = 0 为不在标准输出流输出日志信息#verbose = 1 为输出进度条记录#verbose = 2 为每个epoch输出一行记录
rfr_model.fit(tr_x,tr_y)
valid_rfr[val_idx]= rfr_model.predict(train_x.iloc[val_idx])
predictions_rfr += rfr_model.predict(test_x)/ folds.n_splits
print("CV score: {:<8.8f}".format(mean_absolute_error(valid_rfr, target_lg)))
CV score:0.17160127
梯度提升：
#GradientBoostingRegressor梯度提升决策树
folds = StratifiedKFold(n_splits=5, shuffle=True, random_state=2018)
valid_gbr = np.zeros(len(train_x))
predictions_gbr = np.zeros(len(test_x))for fold_,(trn_idx, val_idx)inenumerate(folds.split(train_x, target)):print("fold n°{}".format(fold_+1))
tr_x = train_x.iloc[trn_idx]
tr_y = target_lg[trn_idx]
gbr_model = gbr(n_estimators=100, learning_rate=0.1,subsample=0.65,max_depth=7,
min_samples_leaf=20, max_features=0.22,verbose=1)
gbr_model.fit(tr_x,tr_y)
valid_gbr[val_idx]= gbr_model.predict(train_x.iloc[val_idx])
predictions_gbr += gbr_model.predict(test_x)/ folds.n_splits
print("CV score: {:<8.8f}".format(mean_absolute_error(valid_gbr, target_lg)))
CV score:0.14386158
下面用逻辑回归对这三种模型进行融合：
train_stack2 = np.vstack([valid_lgb, valid_rfr, valid_gbr]).transpose()
test_stack2 = np.vstack([predictions_lgb, predictions_rfr,predictions_gbr]).transpose()#交叉验证:5折，重复2次
folds_stack = RepeatedKFold(n_splits=5, n_repeats=2, random_state=7)
valid_stack2 = np.zeros(train_stack2.shape[0])
predictions_lr2 = np.zeros(test_stack2.shape[0])for fold_,(trn_idx, val_idx)inenumerate(folds_stack.split(train_stack2,target)):print("fold {}".format(fold_))
trn_data, trn_y = train_stack2[trn_idx], target_lg.iloc[trn_idx].values
val_data, val_y = train_stack2[val_idx], target_lg.iloc[val_idx].values
#Kernel Ridge Regression
lr2 = lr()
lr2.fit(trn_data, trn_y)
valid_stack2[val_idx]= lr2.predict(val_data)
predictions_lr2 += lr2.predict(test_stack2)/10print("CV score: {:<8.8f}".format(mean_absolute_error(target_lg.values, valid_stack2)))
CV score:0.14343221
那么就可以将预测结果先经过exp得到真正结果就去提交啦！
prediction_test = np.exp(predictions_lr2)-1
test_submission = pd.read_csv("used_car_testB_20200421.csv", sep =" ")
test_submission["price"]= prediction_test
feature_submission =["SaleID","price"]
sub = test_submission[feature_submission]
sub.to_csv("mysubmission.csv",index =False)
上述是直接指定参数，那么接下来我会对lightGBM进行调参，看看是否能够取得更好的结果：
# 下面对lightgbm调参# 构建数据集
train_y = target_lg
x_train, x_valid, y_train, y_valid = train_test_split(train_x, train_y,
random_state =1, test_size =0.2)# 数据转换
lgb_train = lgb.Dataset(x_train, y_train, free_raw_data =False)
lgb_valid = lgb.Dataset(x_valid, y_valid, reference=lgb_train,free_raw_data=False)# 设置初始参数
params ={"boosting_type":"gbdt","objective":"regression","metric":"mae","nthread":4,"learning_rate":0.1,"verbosity":-1}# 交叉验证调参print("交叉验证")
min_mae =10000
best_params ={}print("调参1：提高准确率")for num_leaves inrange(5,100,5):for max_depth inrange(3,10,1):
params["num_leaves"]= num_leaves
params["max_depth"]= max_depth
cv_results = lgb.cv(params, lgb_train,seed =1,nfold =5,
metrics=["mae"], early_stopping_rounds =15,stratified=False,
verbose_eval =True)
mean_mae = pd.Series(cv_results['l1-mean']).max()
boost_rounds = pd.Series(cv_results["l1-mean"]).idxmax()if mean_mae <= min_mae:
min_mae = mean_mae
best_params["num_leaves"]= num_leaves
best_params["max_depth"]= max_depth
if"num_leaves"and"max_depth"in best_params.keys():
params["num_leaves"]= best_params["num_leaves"]
params["max_depth"]= best_params["max_depth"]print("调参2：降低过拟合")for max_bin inrange(5,256,10):for min_data_in_leaf inrange(1,102,10):
params['max_bin']= max_bin
params['min_data_in_leaf']= min_data_in_leaf
cv_results = lgb.cv(
params,
lgb_train,
seed=1,
nfold=5,
metrics=['mae'],
early_stopping_rounds=10,
verbose_eval=True,
stratified=False)
mean_mae = pd.Series(cv_results['l1-mean']).max()
boost_rounds = pd.Series(cv_results['l1-mean']).idxmax()if mean_mae <= min_mae:
min_mae = mean_mae
best_params['max_bin']= max_bin
best_params['min_data_in_leaf']= min_data_in_leaf
if'max_bin'and'min_data_in_leaf'in best_params.keys():
params['min_data_in_leaf']= best_params['min_data_in_leaf']
params['max_bin']= best_params['max_bin']print("调参3：降低过拟合")for feature_fraction in[0.6,0.7,0.8,0.9,1.0]:for bagging_fraction in[0.6,0.7,0.8,0.9,1.0]:for bagging_freq inrange(0,50,5):
params['feature_fraction']= feature_fraction
params['bagging_fraction']= bagging_fraction
params['bagging_freq']= bagging_freq
cv_results = lgb.cv(
params,
lgb_train,
seed=1,
nfold=5,
metrics=['mae'],
early_stopping_rounds=10,
verbose_eval=True,
stratified=False)
mean_mae = pd.Series(cv_results['l1-mean']).max()
boost_rounds = pd.Series(cv_results['l1-mean']).idxmax()if mean_mae <= min_mae:
min_mae = mean_mae
best_params['feature_fraction']= feature_fraction
best_params['bagging_fraction']= bagging_fraction
best_params['bagging_freq']= bagging_freq
if'feature_fraction'and'bagging_fraction'and'bagging_freq'in best_params.keys():
params['feature_fraction']= best_params['feature_fraction']
params['bagging_fraction']= best_params['bagging_fraction']
params['bagging_freq']= best_params['bagging_freq']print("调参4：降低过拟合")for lambda_l1 in[1e-5,1e-3,1e-1,0.0,0.1,0.3,0.5,0.7,0.9,1.0]:for lambda_l2 in[1e-5,1e-3,1e-1,0.0,0.1,0.4,0.6,0.7,0.9,1.0]:
params['lambda_l1']= lambda_l1
params['lambda_l2']= lambda_l2
cv_results = lgb.cv(
params,
lgb_train,
seed=1,
nfold=5,
metrics=['mae'],
early_stopping_rounds=10,
verbose_eval=True,
stratified=False)
mean_mae = pd.Series(cv_results['l1-mean']).max()
boost_rounds = pd.Series(cv_results['l1-mean']).idxmax()if mean_mae <= min_mae:
min_mae = mean_mae
best_params['lambda_l1']= lambda_l1
best_params['lambda_l2']= lambda_l2
if'lambda_l1'and'lambda_l2'in best_params.keys():
params['lambda_l1']= best_params['lambda_l1']
params['lambda_l2']= best_params['lambda_l2']print("调参5：降低过拟合2")for min_split_gain in[0.0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0]:
params['min_split_gain']= min_split_gain
cv_results = lgb.cv(
params,
lgb_train,
seed=1,
nfold=5,
metrics=['mae'],
early_stopping_rounds=10,
verbose_eval=True,
stratified=False)
mean_mae = pd.Series(cv_results['l1-mean']).max()
boost_rounds = pd.Series(cv_results['l1-mean']).idxmax()if mean_mae <= min_mae:
min_mae = mean_mae
best_params['min_split_gain']= min_split_gain
if'min_split_gain'in best_params.keys():
params['min_split_gain']= best_params['min_split_gain']print(best_params)
注意在lgb.cv中要设置参数stratified=False，同样是之间那个连续与离散的问题！
{'num_leaves':95,'max_depth':9,'max_bin':215,'min_data_in_leaf':71,'feature_fraction':1.0,'bagging_fraction':1.0,'bagging_freq':45,'lambda_l1':0.0,'lambda_l2':0.0,'min_split_gain':1.0}
那么再用该模型做出预测：
best_params["verbosity"]=-1
folds = StratifiedKFold(n_splits=5, shuffle=True, random_state =4)# 产生一个容器，可以用来对对数据集进行打乱的5次切分，以此来进行五折交叉验证
valid_lgb = np.zeros(len(train_x))
predictions_lgb = np.zeros(len(test_x))for fold_,(train_idx, valid_idx)inenumerate(folds.split(train_x, target)):# 切分后返回的训练集和验证集的索引print("fold n{}".format(fold_+1))# 当前第几折
train_data_now = lgb.Dataset(train_x.iloc[train_idx], target_lg[train_idx])
valid_data_now = lgb.Dataset(train_x.iloc[valid_idx], target_lg[valid_idx])# 取出数据并转换为lgb的数据
num_round =10000
lgb_model = lgb.train(best_params, train_data_now, num_round,
valid_sets=[train_data_now, valid_data_now], verbose_eval=500,
early_stopping_rounds =800)
valid_lgb[valid_idx]= lgb_model.predict(train_x.iloc[valid_idx],
num_iteration=lgb_model.best_iteration)
predictions_lgb += lgb_model.predict(test_x, num_iteration=
lgb_model.best_iteration)/ folds.n_splits
# 这是将预测概率进行平均print("CV score: {:<8.8f}".format(mean_absolute_error(valid_lgb, target_lg)))
CV score:0.14548046
再用模型融合，同样的代码，得到：
CV score:0.14071899
完成！
本文转载自: https://blog.csdn.net/StarandTiAmo/article/details/128162151
版权归原作者 FavoriteStar 所有， 如有侵权，请联系我们删除。
版权归原作者 FavoriteStar 所有， 如有侵权，请联系我们删除。