数据挖掘-二手车价格预测Part3

赛题简介

本次新人赛是Datawhale与天池联合发起的0基础入门系列赛事第一场 —— 零基础入门数据挖掘之二手车交易价格预测大赛。

赛题以二手车市场为背景，要求选手预测二手汽车的交易价格，这是一个典型的回归问题。通过这道赛题来引导大家走进AI数据竞赛的世界，主要针对于于竞赛新人进行自我练习、自我提高。

数据获取：
https://tianchi.aliyun.com/competition/entrance/231784/information

代码

1、建模与调参

## xgb-Model
xgr = xgb.XGBRegressor(n_estimators=120, learning_rate=0.1, gamma=0, subsample=0.8,colsample_bytree=0.9, max_depth=7)  # ,objective ='reg:squarederror'

scores_train = []
scores = []
#iloc函数：通过行号来取行数据（如取第二行的数据）
## 5折交叉验证方式
sk = StratifiedKFold(n_splits=5, shuffle=True, random_state=0)
i=0
for train_ind, val_ind in sk.split(X_data, Y_data):
	train_x = X_data.iloc[train_ind].values
	train_y = Y_data.iloc[train_ind]
	val_x = X_data.iloc[val_ind].values
	val_y = Y_data.iloc[val_ind]

	xgr.fit(train_x, train_y)
	pred_train_xgb = xgr.predict(train_x)
	pred_xgb = xgr.predict(val_x)

	score_train = mean_absolute_error(train_y, pred_train_xgb)
	scores_train.append(score_train)
	score = mean_absolute_error(val_y, pred_xgb)
	scores.append(score)
	i+=1
	print('NO %d,Train mae:%f'%(i,np.mean(score_train)))
	print('Val mae', np.mean(scores))
print('Train mae:', np.mean(score_train))
print('Val mae', np.mean(scores))

def build_model_xgb(x_train,y_train):
    model = xgb.XGBRegressor(n_estimators=150, learning_rate=0.1, gamma=0, subsample=0.8,\
        colsample_bytree=0.9, max_depth=7) #, objective ='reg:squarederror'
    model.fit(x_train, y_train)
    return model

def build_model_lgb(x_train,y_train):
    estimator = lgb.LGBMRegressor(num_leaves=127,n_estimators = 150)
    param_grid = {
        'learning_rate': [0.01, 0.05, 0.1, 0.2],
    }
    gbm = GridSearchCV(estimator, param_grid)
    gbm.fit(x_train, y_train)
    return gbm

def build_model_random(x_train,y_train):
	my_model=RandomForestRegressor()
	my_model.fit(x_train, y_train)
	return my_model

## Split data with val
x_train,x_val,y_train,y_val = train_test_split(X_data,Y_data,test_size=0.3)

print('Train lgb...')
model_lgb = build_model_lgb(x_train,y_train)
val_lgb = model_lgb.predict(x_val)
MAE_lgb = mean_absolute_error(y_val,val_lgb)
print('MAE of val with lgb:',MAE_lgb)

print('Predict lgb...')
model_lgb_pre = build_model_lgb(X_data,Y_data)
subA_lgb = model_lgb_pre.predict(X_test)
print('Sta of Predict lgb:')
Sta_inf(subA_lgb)

print('Train xgb...')
model_xgb = build_model_xgb(x_train,y_train)
val_xgb = model_xgb.predict(x_val)
MAE_xgb = mean_absolute_error(y_val,val_xgb)
print('MAE of val with xgb:',MAE_xgb)

print('Predict xgb...')
model_xgb_pre = build_model_xgb(X_data,Y_data)
subA_xgb = model_xgb_pre.predict(X_test)
print('Sta of Predict xgb:')
Sta_inf(subA_xgb)

print('Train random...')
model_random=build_model_random(x_train,y_train)
val_random=model_random.predict(x_val)
MAE_random = mean_absolute_error(y_val,val_random)
print('MAE of val with random:',MAE_random)

print('Predict random...')
model_random_pre = build_model_random(X_data,Y_data)
subA_random = model_random_pre.predict(X_test)
print('Sta of Predict random:')
Sta_inf(subA_random)

## 这里我们采取了简单的加权融合的方式
val_Weighted = (1-MAE_lgb/(MAE_xgb+MAE_lgb))*val_lgb+(1-MAE_xgb/(MAE_xgb+MAE_lgb))*val_xgb
val_Weighted[val_Weighted<0]=10 # 由于我们发现预测的最小值有负数，而真实情况下，price为负是不存在的，由此我们进行对应的后修正
print('MAE of val with Weighted ensemble:',mean_absolute_error(y_val,val_Weighted))

sub_Weighted = (1-MAE_lgb/(MAE_xgb+MAE_lgb))*subA_lgb+(1-MAE_xgb/(MAE_xgb+MAE_lgb))*subA_xgb

2、说明
1）’’‘train_test_split’’'用法说明

'''train_test_split'''
'''在机器学习中，我们通常将原始数据按照比例分割为“测试集”和“训练集”，从 sklearn.model_selection 中调用train_test_split 函数 

简单用法如下：

X_train,X_test, y_train, y_test =sklearn.model_selection.train_test_split(train_data,train_target,test_size=0.4, random_state=0,stratify=y_train)
# train_data：所要划分的样本特征集

# train_target：所要划分的样本结果

# test_size：样本占比，如果是整数的话就是样本的数量

# random_state：是随机数的种子。
# 随机数种子：其实就是该组随机数的编号，在需要重复试验的时候，保证得到一组一样的随机数。比如你每次都填1，其他参数一样的情况下你得到的随机数组是一样的。但填0或不填，每次都会不一样。

stratify是为了保持split前类的分布。比如有100个数据，80个属于A类，20个属于B类。如果train_test_split(... test_size=0.25, stratify = y_all), 那么split之后数据如下： 
training: 75个数据，其中60个属于A类，15个属于B类。 
testing: 25个数据，其中20个属于A类，5个属于B类。 
'''