Task4 Datawhale活动:建模调参
地址:https://tianchi.aliyun.com/competition/entrance/231784/introduction?spm=5176.12281957.1004.1.38b02448ausjSX
reduce_mem_usage 函数通过调整数据类型,帮助我们减少数据在内存中占用的空间
def reduce_mem_usage(df):
""" iterate through all the columns of a dataframe and modify the data type
to reduce memory usage.
"""
start_mem = df.memory_usage().sum()
print('Memory usage of dataframe is {:.2f} MB'.format(start_mem))
for col in df.columns:
col_type = df[col].dtype
if col_type != object:
c_min = df[col].min()
c_max = df[col].max()
if str(col_type)[:3] == 'int':
if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max:
df[col] = df[col].astype(np.int8)
elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max:
df[col] = df[col].astype(np.int16)
elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max:
df[col] = df[col].astype(np.int32)
elif c_min > np.iinfo(np.int64).min and c_max < np.iinfo(np.int64).max:
df[col] = df[col].astype(np.int64)
else:
if c_min > np.finfo(np.float16).min and c_max < np.finfo(np.float16).max:
df[col] = df[col].astype(np.float16)
elif c_min > np.finfo(np.float32).min and c_max < np.finfo(np.float32).max:
df[col] = df[col].astype(np.float32)
else:
df[col] = df[col].astype(np.float64)
else:
df[col] = df[col].astype('category')
end_mem = df.memory_usage().sum()
print('Memory usage after optimization is: {:.2f} MB'.format(end_mem))
print('Decreased by {:.1f}%'.format(100 * (start_mem - end_mem) / start_mem))
return df
sample_feature = reduce_mem_usage(pd.read_csv('data_for_tree.csv'))
Memory usage of dataframe is 62099672.00 MB
Memory usage after optimization is: 16520303.00 MB
Decreased by 73.4%
线性回归
sample_feature = sample_feature.dropna().replace('-', 0).reset_index(drop=True)
sample_feature['notRepairedDamage'] = sample_feature['notRepairedDamage'].astype(np.float32)
train = sample_feature[continuous_feature_names + ['price']]
train_X = train[continuous_feature_names]
train_y = train['price']
from sklearn.linear_model import LinearRegression
model = LinearRegression(normalize=True)
model = model.fit(train_X, train_y)
'intercept:'+ str(model.intercept_)
sorted(dict(zip(continuous_feature_names, model.coef_)).items(), key=lambda x:x[1], reverse=True)
[('v_6', 3367064.3416418773),
('v_8', 700675.5609398658),
('v_9', 170630.27723220887),
('v_7', 32322.66193201985),
('v_12', 20473.6707969639),
('v_3', 17868.079541497777),
('v_11', 11474.938996701725),
('v_13', 11261.764560015463),
('v_10', 2683.9200906023975),
('gearbox', 881.8225039247513),
('fuelType', 363.9042507215941),
('bodyType', 189.60271012070683),
('city', 44.94975120523033),
('power', 28.553901616752416),
('brand_price_median', 0.5103728134078794),
('brand_price_std', 0.4503634709263301),
('brand_amount', 0.14881120395065628),
('brand_price_max', 0.0031910186703119504),
('SaleID', 5.355989919853205e-05),
('train', 2.7008354663848877e-07),
('offerType', -2.230750396847725e-06),
('seller', -3.391294740140438e-06),
('brand_price_sum', -2.1750068681875342e-05),
('name', -0.0002980012713119153),
('used_time', -0.002515894332887234),
('brand_price_average', -0.4049048451011269),
('brand_price_min', -2.2467753486885997),
('power_bin', -34.42064411726994),
('v_14', -274.78411807763786),
('kilometer', -372.89752666071104),
('notRepairedDamage', -495.19038446277233),
('v_0', -2045.0549573548044),
('v_5', -11022.986240560502),
('v_4', -15121.731109857172),
('v_2', -26098.299920528138),
('v_1', -45556.18929726618)]
from matplotlib import pyplot as plt
subsample_index = np.random.randint(low=0, high=len(train_y), size=50)
plt.scatter(train_X['v_9'][subsample_index], train_y[subsample_index], color='black')
plt.scatter(train_X['v_9'][subsample_index], model.predict(train_X.loc[subsample_index]), color='blue')
plt.xlabel('v_9')
plt.ylabel('price')
plt.legend(['True Price','Predicted Price'],loc='upper right')
print('The predicted price is obvious different from true price')
plt.show()
The predicted price is obvious different from true price
import seaborn as sns
print('It is clear to see the price shows a typical exponential distribution')
plt.figure(figsize=(15,5))
plt.subplot(1,2,1)
sns.distplot(train_y)
plt.subplot(1,2,2)
sns.distplot(train_y[train_y < np.quantile(train_y, 0.9)])
It is clear to see the price shows a typical exponential distribution
train_y_ln = np.log(train_y + 1)
import seaborn as sns
print('The transformed price seems like normal distribution')
plt.figure(figsize=(15,5))
plt.subplot(1,2,1)
sns.distplot(train_y_ln)
plt.subplot(1,2,2)
sns.distplot(train_y_ln[train_y_ln < np.quantile(train_y_ln, 0.9)])
The transformed price seems like normal distribution
model = model.fit(train_X, train_y_ln)
print('intercept:'+ str(model.intercept_))
sorted(dict(zip(continuous_feature_names, model.coef_)).items(), key=lambda x:x[1], reverse=True)
intercept:18.750749465570607
[('v_9', 8.052409900567602),
('v_5', 5.764236596652759),
('v_12', 1.6182081236784163),
('v_1', 1.4798310582944711),
('v_11', 1.1669016563622117),
('v_13', 0.9404711296030676),
('v_7', 0.713727308356542),
('v_3', 0.6837875771076573),
('v_0', 0.008500518010093529),
('power_bin', 0.008497969302892117),
('gearbox', 0.007922377278335285),
('fuelType', 0.006684769706828693),
('bodyType', 0.004523520092703198),
('power', 0.0007161894205358566),
('brand_price_min', 3.334351114743061e-05),
('brand_amount', 2.8978797042777754e-06),
('brand_price_median', 1.2571172873027632e-06),
('brand_price_std', 6.659176363436127e-07),
('brand_price_max', 6.194956307517733e-07),
('brand_price_average', 5.999345965043507e-07),
('SaleID', 2.1194170039647818e-08),
('train', 1.8189894035458565e-12),
('offerType', -5.3287152468328713e-11),
('seller', -1.1784173636897322e-10),
('brand_price_sum', -1.5126504215929971e-10),
('name', -7.015512588871499e-08),
('used_time', -4.12247937235175e-06),
('city', -0.0022187824810422333),
('v_14', -0.004234223418099023),
('kilometer', -0.013835866226884243),
('notRepairedDamage', -0.27027942349846473),
('v_4', -0.8315701200992444),
('v_2', -0.9470842241623264),
('v_10', -1.6261466689797768),
('v_8', -40.3430074876164),
('v_6', -238.7903638550661)]
plt.scatter(train_X['v_9'][subsample_index], train_y[subsample_index], color='black')
plt.scatter(train_X['v_9'][subsample_index], np.exp(model.predict(train_X.loc[subsample_index])), color='blue')
plt.xlabel('v_9')
plt.ylabel('price')
plt.legend(['True Price','Predicted Price'],loc='upper right')
print('The predicted price seems normal after np.log transforming')
plt.show()
The predicted price seems normal after np.log transforming
五折交叉验证
在使用训练集对参数进行训练的时候,经常会发现人们通常会将一整个训练集分为三个部分(比如mnist手写训练集)。一般分为:训练集(train_set),评估集(valid_set),测试集(test_set)这三个部分。这其实是为了保证训练效果而特意设置的。其中测试集很好理解,其实就是完全不参与训练的数据,仅仅用来观测测试效果的数据。而训练集和评估集则牵涉到下面的知识了。
因为在实际的训练中,训练的结果对于训练集的拟合程度通常还是挺好的(初始条件敏感),但是对于训练集之外的数据的拟合程度通常就不那么令人满意了。因此我们通常并不会把所有的数据集都拿来训练,而是分出一部分来(这一部分不参加训练)对训练集生成的参数进行测试,相对客观的判断这些参数对训练集之外的数据的符合程度。这种思想就称为交叉验证(Cross Validation)
from sklearn.model_selection import cross_val_score
from sklearn.metrics import mean_absolute_error, make_scorer
def log_transfer(func):
def wrapper(y, yhat):
result = func(np.log(y), np.nan_to_num(np.log(yhat)))
return result
return wrapper
scores = cross_val_score(model, X=train_X, y=train_y, verbose=1, cv = 5, scoring=make_scorer(log_transfer(mean_absolute_error)))
[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.
[Parallel(n_jobs=1)]: Done 5 out of 5 | elapsed: 0.9s finished
使用线性回归模型,对未处理标签的特征数据进行五折交叉验证(Error 1.36)
print('AVG:', np.mean(scores))
AVG: 1.3658023920314446
使用线性回归模型,对处理过标签的特征数据进行五折交叉验证(Error 0.19)
scores = cross_val_score(model, X=train_X, y=train_y_ln, verbose=1, cv = 5, scoring=make_scorer(mean_absolute_error))
[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.
[Parallel(n_jobs=1)]: Done 5 out of 5 | elapsed: 0.8s finished
print('AVG:', np.mean(scores))
AVG: 0.1932530183704744
scores = pd.DataFrame(scores.reshape(1,-1))
scores.columns = ['cv' + str(x) for x in range(1, 6)]
scores.index = ['MAE']
scores
cv1 | cv2 | cv3 | cv4 | cv5 | |
---|---|---|---|---|---|
MAE | 0.190792 | 0.193758 | 0.194132 | 0.191825 | 0.195758 |
模拟真实业务情况
但在事实上,由于我们并不具有预知未来的能力,五折交叉验证在某些与时间相关的数据集上反而反映了不真实的情况。通过2018年的二手车价格预测2017年的二手车价格,这显然是不合理的,因此我们还可以采用时间顺序对数据集进行分隔。在本例中,我们选用靠前时间的4/5样本当作训练集,靠后时间的1/5当作验证集,最终结果与五折交叉验证差距不大
import datetime
sample_feature = sample_feature.reset_index(drop=True)
split_point = len(sample_feature) // 5 * 4
train = sample_feature.loc[:split_point].dropna()
val = sample_feature.loc[split_point:].dropna()
train_X = train[continuous_feature_names]
train_y_ln = np.log(train['price'] + 1)
val_X = val[continuous_feature_names]
val_y_ln = np.log(val['price'] + 1)
model = model.fit(train_X, train_y_ln)
mean_absolute_error(val_y_ln, model.predict(val_X))
0.1957766727030102
绘制学习率曲线与验证曲线
from sklearn.model_selection import learning_curve, validation_curve
def plot_learning_curve(estimator, title, X, y, ylim=None, cv=None,n_jobs=1, train_size=np.linspace(.1, 1.0, 5 )):
plt.figure()
plt.title(title)
if ylim is not None:
plt.ylim(*ylim)
plt.xlabel('Training example')
plt.ylabel('score')
train_sizes, train_scores, test_scores = learning_curve(estimator, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_size, scoring = make_scorer(mean_absolute_error))
train_scores_mean = np.mean(train_scores, axis=1)
train_scores_std = np.std(train_scores, axis=1)
test_scores_mean = np.mean(test_scores, axis=1)
test_scores_std = np.std(test_scores, axis=1)
plt.grid()#区域
plt.fill_between(train_sizes, train_scores_mean - train_scores_std,
train_scores_mean + train_scores_std, alpha=0.1,
color="r")
plt.fill_between(train_sizes, test_scores_mean - test_scores_std,
test_scores_mean + test_scores_std, alpha=0.1,
color="g")
plt.plot(train_sizes, train_scores_mean, 'o-', color='r',
label="Training score")
plt.plot(train_sizes, test_scores_mean,'o-',color="g",
label="Cross-validation score")
plt.legend(loc="best")
return plt
plot_learning_curve(LinearRegression(), 'Liner_model', train_X[:1000], train_y_ln[:1000], ylim=(0.0, 0.5), cv=5, n_jobs=1)
lasso回归和ridge回归
train = sample_feature[continuous_feature_names + ['price']].dropna()
train_X = train[continuous_feature_names]
train_y = train['price']
train_y_ln = np.log(train_y + 1)
from sklearn.linear_model import LinearRegression
from sklearn.linear_model import Ridge
from sklearn.linear_model import Lasso
models = [LinearRegression(),
Ridge(),
Lasso()]
result = dict()
for model in models:
model_name = str(model).split('(')[0]
scores = cross_val_score(model, X=train_X, y=train_y_ln, verbose=0, cv = 5, scoring=make_scorer(mean_absolute_error))
result[model_name] = scores
print(model_name + ' is finished')
LinearRegression is finished
Ridge is finished
Lasso is finished
对三种方法的效果对比
result = pd.DataFrame(result)
result.index = ['cv' + str(x) for x in range(1, 6)]
result
LinearRegression | Ridge | Lasso | |
---|---|---|---|
cv1 | 0.190792 | 0.194832 | 0.383899 |
cv2 | 0.193758 | 0.197632 | 0.381893 |
cv3 | 0.194132 | 0.198123 | 0.384090 |
cv4 | 0.191825 | 0.195670 | 0.380526 |
cv5 | 0.195758 | 0.199676 | 0.383611 |
model = LinearRegression().fit(train_X, train_y_ln)
print('intercept:'+ str(model.intercept_))
sns.barplot(abs(model.coef_), continuous_feature_names)
intercept:18.75074946558032
L2正则化在拟合过程中通常都倾向于让权值尽可能小,最后构造一个所有参数都比较小的模型。因为一般认为参数值小的模型比较简单,能适应不同的数据集,也在一定程度上避免了过拟合现象。可以设想一下对于一个线性回归方程,若参数很大,那么只要数据偏移一点点,就会对结果造成很大的影响;但如果参数足够小,数据偏移得多一点也不会对结果造成什么影响,专业一点的说法是『抗扰动能力强』
model = Ridge().fit(train_X, train_y_ln)
print('intercept:'+ str(model.intercept_))
sns.barplot(abs(model.coef_), continuous_feature_names)
intercept:4.67170978755046
L1正则化有助于生成一个稀疏权值矩阵,进而可以用于特征选择。如下图,我们发现power与userd_time特征非常重要。
model = Lasso().fit(train_X, train_y_ln)
print('intercept:'+ str(model.intercept_))
sns.barplot(abs(model.coef_), continuous_feature_names)
intercept:8.672182462666198
除此之外,决策树通过信息熵或GINI指数选择分裂节点时,优先选择的分裂特征也更加重要,这同样是一种特征选择的方法。XGBoost与LightGBM模型中的model_importance指标正是基于此计算的
非线性模型
除了线性模型以外,还有许多我们常用的非线性模型如下,在此篇幅有限不再一一讲解原理。我们选择了部分常用模型与线性模型进行效果比对。
from sklearn.linear_model import LinearRegression
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.neural_network import MLPRegressor
from xgboost.sklearn import XGBRegressor
from lightgbm.sklearn import LGBMRegressor
models = [LinearRegression(),
DecisionTreeRegressor(),
RandomForestRegressor(),
GradientBoostingRegressor(),
MLPRegressor(solver='lbfgs', max_iter=100),
XGBRegressor(n_estimators = 100, objective='reg:squarederror'),
LGBMRegressor(n_estimators = 100)]
result = dict()
for model in models:
model_name = str(model).split('(')[0]
scores = cross_val_score(model, X=train_X, y=train_y_ln, verbose=0, cv = 5, scoring=make_scorer(mean_absolute_error))
result[model_name] = scores
print(model_name + ' is finished')
LinearRegression is finished
DecisionTreeRegressor is finished
RandomForestRegressor is finished
GradientBoostingRegressor is finished
MLPRegressor is finished
XGBRegressor is finished
LGBMRegressor is finished
result = pd.DataFrame(result)
result.index = ['cv' + str(x) for x in range(1, 6)]
result
LinearRegression | DecisionTreeRegressor | RandomForestRegressor | GradientBoostingRegressor | MLPRegressor | XGBRegressor | LGBMRegressor | |
---|---|---|---|---|---|---|---|
cv1 | 0.190792 | 0.197535 | 0.141677 | 0.168902 | 201.022970 | 0.142378 | 0.141544 |
cv2 | 0.193758 | 0.193823 | 0.143696 | 0.171831 | 340.877529 | 0.140922 | 0.145501 |
cv3 | 0.194132 | 0.188803 | 0.143172 | 0.170902 | 355.540951 | 0.139393 | 0.143887 |
cv4 | 0.191825 | 0.189200 | 0.142017 | 0.169076 | 243.761489 | 0.137492 | 0.142497 |
cv5 | 0.195758 | 0.206211 | 0.147477 | 0.174094 | 542.388522 | 0.143733 | 0.144852 |
可以看到随机森林模型在每一个fold中均取得了更好的效果
模型调参
## LGB的参数集合:
objective = ['regression', 'regression_l1', 'mape', 'huber', 'fair']
num_leaves = [3,5,10,15,20,40, 55]
max_depth = [3,5,10,15,20,40, 55]
bagging_fraction = []
feature_fraction = []
drop_rate = []
贪心调参
best_obj = dict()
for obj in objective:
model = LGBMRegressor(objective=obj)
score = np.mean(cross_val_score(model, X=train_X, y=train_y_ln, verbose=0, cv = 5, scoring=make_scorer(mean_absolute_error)))
best_obj[obj] = score
best_leaves = dict()
for leaves in num_leaves:
model = LGBMRegressor(objective=min(best_obj.items(), key=lambda x:x[1])[0], num_leaves=leaves)
score = np.mean(cross_val_score(model, X=train_X, y=train_y_ln, verbose=0, cv = 5, scoring=make_scorer(mean_absolute_error)))
best_leaves[leaves] = score
best_depth = dict()
for depth in max_depth:
model = LGBMRegressor(objective=min(best_obj.items(), key=lambda x:x[1])[0],
num_leaves=min(best_leaves.items(), key=lambda x:x[1])[0],
max_depth=depth)
score = np.mean(cross_val_score(model, X=train_X, y=train_y_ln, verbose=0, cv = 5, scoring=make_scorer(mean_absolute_error)))
best_depth[depth] = score
sns.lineplot(x=['0_initial','1_turning_obj','2_turning_leaves','3_turning_depth'], y=[0.143 ,min(best_obj.values()), min(best_leaves.values()), min(best_depth.values())])
Grid Search 调参
from sklearn.model_selection import GridSearchCV
parameters = {'objective': objective , 'num_leaves': num_leaves, 'max_depth': max_depth}
model = LGBMRegressor()
clf = GridSearchCV(model, parameters, cv=5)
clf = clf.fit(train_X, train_y)
clf.best_params_
{'max_depth': 15, 'num_leaves': 55, 'objective': 'regression'}
model = LGBMRegressor(objective='regression',
num_leaves=55,
max_depth=15)
np.mean(cross_val_score(model, X=train_X, y=train_y_ln, verbose=0, cv = 5, scoring=make_scorer(mean_absolute_error)))
0.13626164479243302
贝叶斯调参
from bayes_opt import BayesianOptimization
def rf_cv(num_leaves, max_depth, subsample, min_child_samples):
val = cross_val_score(
LGBMRegressor(objective = 'regression_l1',
num_leaves=int(num_leaves),
max_depth=int(max_depth),
subsample = subsample,
min_child_samples = int(min_child_samples)
),
X=train_X, y=train_y_ln, verbose=0, cv = 5, scoring=make_scorer(mean_absolute_error)
).mean()
return 1 - val
rf_bo = BayesianOptimization(
rf_cv,
{
'num_leaves': (2, 100),
'max_depth': (2, 100),
'subsample': (0.1, 1),
'min_child_samples' : (2, 100)
}
)
rf_bo.maximize()
| iter | target | max_depth | min_ch... | num_le... | subsample |
-------------------------------------------------------------------------
| [0m 1 [0m | [0m 0.8649 [0m | [0m 89.57 [0m | [0m 47.3 [0m | [0m 55.13 [0m | [0m 0.1792 [0m |
| [0m 2 [0m | [0m 0.8477 [0m | [0m 99.86 [0m | [0m 60.91 [0m | [0m 15.35 [0m | [0m 0.4716 [0m |
| [95m 3 [0m | [95m 0.8698 [0m | [95m 81.74 [0m | [95m 83.32 [0m | [95m 92.59 [0m | [95m 0.9559 [0m |
| [0m 4 [0m | [0m 0.8627 [0m | [0m 90.2 [0m | [0m 8.754 [0m | [0m 43.34 [0m | [0m 0.7772 [0m |
| [0m 5 [0m | [0m 0.8115 [0m | [0m 10.07 [0m | [0m 86.15 [0m | [0m 4.109 [0m | [0m 0.3416 [0m |
| [95m 6 [0m | [95m 0.8701 [0m | [95m 99.15 [0m | [95m 9.158 [0m | [95m 99.47 [0m | [95m 0.494 [0m |
| [0m 7 [0m | [0m 0.806 [0m | [0m 2.166 [0m | [0m 2.416 [0m | [0m 97.7 [0m | [0m 0.224 [0m |
| [0m 8 [0m | [0m 0.8701 [0m | [0m 98.57 [0m | [0m 97.67 [0m | [0m 99.87 [0m | [0m 0.3703 [0m |
| [95m 9 [0m | [95m 0.8703 [0m | [95m 99.87 [0m | [95m 43.03 [0m | [95m 99.72 [0m | [95m 0.9749 [0m |
| [0m 10 [0m | [0m 0.869 [0m | [0m 10.31 [0m | [0m 99.63 [0m | [0m 99.34 [0m | [0m 0.2517 [0m |
| [95m 11 [0m | [95m 0.8703 [0m | [95m 52.27 [0m | [95m 99.56 [0m | [95m 98.97 [0m | [95m 0.9641 [0m |
| [0m 12 [0m | [0m 0.8669 [0m | [0m 99.89 [0m | [0m 8.846 [0m | [0m 66.49 [0m | [0m 0.1437 [0m |
| [0m 13 [0m | [0m 0.8702 [0m | [0m 68.13 [0m | [0m 75.28 [0m | [0m 98.71 [0m | [0m 0.153 [0m |
| [0m 14 [0m | [0m 0.8695 [0m | [0m 84.13 [0m | [0m 86.48 [0m | [0m 91.9 [0m | [0m 0.7949 [0m |
| [0m 15 [0m | [0m 0.8702 [0m | [0m 98.09 [0m | [0m 59.2 [0m | [0m 99.65 [0m | [0m 0.3275 [0m |
| [0m 16 [0m | [0m 0.87 [0m | [0m 68.97 [0m | [0m 98.62 [0m | [0m 98.93 [0m | [0m 0.2221 [0m |
| [0m 17 [0m | [0m 0.8702 [0m | [0m 99.85 [0m | [0m 63.74 [0m | [0m 99.63 [0m | [0m 0.4137 [0m |
| [0m 18 [0m | [0m 0.8703 [0m | [0m 45.87 [0m | [0m 99.05 [0m | [0m 99.89 [0m | [0m 0.3238 [0m |
| [0m 19 [0m | [0m 0.8702 [0m | [0m 79.65 [0m | [0m 46.91 [0m | [0m 98.61 [0m | [0m 0.8999 [0m |
| [0m 20 [0m | [0m 0.8702 [0m | [0m 99.25 [0m | [0m 36.73 [0m | [0m 99.05 [0m | [0m 0.1262 [0m |
| [0m 21 [0m | [0m 0.8702 [0m | [0m 85.51 [0m | [0m 85.34 [0m | [0m 99.77 [0m | [0m 0.8917 [0m |
| [0m 22 [0m | [0m 0.8696 [0m | [0m 99.99 [0m | [0m 38.51 [0m | [0m 89.13 [0m | [0m 0.9884 [0m |
| [0m 23 [0m | [0m 0.8701 [0m | [0m 63.29 [0m | [0m 97.93 [0m | [0m 99.94 [0m | [0m 0.9585 [0m |
| [0m 24 [0m | [0m 0.8702 [0m | [0m 93.04 [0m | [0m 71.42 [0m | [0m 99.94 [0m | [0m 0.9646 [0m |
| [0m 25 [0m | [0m 0.8701 [0m | [0m 99.73 [0m | [0m 16.21 [0m | [0m 99.38 [0m | [0m 0.9778 [0m |
| [0m 26 [0m | [0m 0.87 [0m | [0m 86.28 [0m | [0m 58.1 [0m | [0m 99.47 [0m | [0m 0.107 [0m |
| [0m 27 [0m | [0m 0.8703 [0m | [0m 47.28 [0m | [0m 99.83 [0m | [0m 99.65 [0m | [0m 0.4674 [0m |
| [0m 28 [0m | [0m 0.8703 [0m | [0m 68.29 [0m | [0m 99.51 [0m | [0m 99.4 [0m | [0m 0.2757 [0m |
| [0m 29 [0m | [0m 0.8701 [0m | [0m 76.49 [0m | [0m 73.41 [0m | [0m 99.86 [0m | [0m 0.9394 [0m |
| [0m 30 [0m | [0m 0.8695 [0m | [0m 37.27 [0m | [0m 99.87 [0m | [0m 89.87 [0m | [0m 0.7588 [0m |
=========================================================================
1 - rf_bo.max['target']
0.1296693644053145
总结:在本章中,我们完成了建模与调参的工作,并对我们的模型进行了验证。此外,我们还采用了一些基本方法来提高预测的精度,提升如下图所示。
plt.figure(figsize=(13,5))
sns.lineplot(x=['0_origin','1_log_transfer','2_L1_&_L2','3_change_model','4_parameter_turning'], y=[1.36 ,0.19, 0.19, 0.14, 0.13])